FileAccess

public bool BigEndian { get; set; }

Byte-order setting for numeric Get/Store operations on this handle: false is little-endian, true big-endian. A new Open() has a fresh false-default handle; the setting is not stored as file metadata. Does not reorder GetBuffer/StoreBuffer bytes or UTF-8 text. StoreVar/GetVar applies it to the 32-bit length prefix, not the inner Variant payload; tested. Reader and writer must agree on the format.

public void Close();

Closes this handle file; using/Dispose of an owned wrapper also ends its use. Do not read, seek or call EofReached() after closing. Repeated Close() was tested on Windows, but does not reopen; Open() creates another handle. Returns no Error, so closing does not certify reliable persistence.

public static FileAccess CreateTemp(FileAccess.ModeFlags modeFlags, string prefix = "", string extension = "", bool keep = false);

Creates a file in OS temp and returns an owned RefCounted handle in the requested mode. Native code first creates it with Write then reopens with that mode, so Read can open a new empty temp file. prefix/extension are filename parts, not paths. On null immediately check GetOpenError(). keep=false enables best-effort deletion of the original temp file on last native-reference release; Close() alone only closes the stream. keep=true preserves the file after release. C# using releases your reference, but other owners can extend lifetime. Cleanup after process failure is not guaranteed; lifecycle was source-reviewed only here.

public static FileAccess CreateTemp(int modeFlags, string prefix, string extension, bool keep);

Creates a file in OS temp and returns an owned RefCounted handle in the requested mode. Native code first creates it with Write then reopens with that mode, so Read can open a new empty temp file. prefix/extension are filename parts, not paths. On null immediately check GetOpenError(). keep=false enables best-effort deletion of the original temp file on last native-reference release; Close() alone only closes the stream. keep=true preserves the file after release. C# using releases your reference, but other owners can extend lifetime. Cleanup after process failure is not guaranteed; lifecycle was source-reviewed only here. The int overload forwards a numeric value as ModeFlags; use only values of that enum.

public bool EofReached();

Read-past-end indicator, not GetPosition() compared with GetLength(). An exact read of all available bytes leaves false on Windows; the next read attempt sets EOF. An empty line can be a valid blank file line. Use only on an open handle and check actual GetBuffer() length/read results.

public static bool FileExists(string path);

Tests a file through the backend/packed data; a directory is not a file. False does not distinguish absence from inaccessibility; true guarantees no later Open() and does not replace ResourceLoader for imported resources. Check Open() itself rather than relying on this test alone.

public void Flush();

Flushes an open handle output buffer to its backend without closing it. Windows calls fflush and supplies no separate Error. Call before Resize() after buffered writes, otherwise a later flush can restore the old length; reproduced in testing. Not equivalent to System.IO.FileStream.Flush(true) and not a power-loss guarantee.

public ushort Get16();

Reads an unsigned 16-bit number from 2 bytes at the current cursor. Byte order follows this handle BigEndian; defaults to little-endian. A short read supplies no separate bool and can return a partial value; zero is also valid data. Check record size and GetError(), not the numeric value alone.

public uint Get32();

Reads an unsigned 32-bit number from 4 bytes at the current cursor. Byte order follows this handle BigEndian; defaults to little-endian. A short read supplies no separate bool and can return a partial value; zero is also valid data. Check record size and GetError(), not the numeric value alone.

public ulong Get64();

Reads an unsigned 64-bit number from 8 bytes at the current cursor. Byte order follows this handle BigEndian; defaults to little-endian. A short read supplies no separate bool and can return a partial value; zero is also valid data. Check record size and GetError(), not the numeric value alone.

public byte Get8();

Reads an unsigned 8-bit number from 1 bytes at the current cursor. BigEndian has no effect on one byte. A short read supplies no separate bool and can return a partial value; zero is also valid data. Check record size and GetError(), not the numeric value alone.

public static ulong GetAccessTime(string file);

Access time in whole Unix-epoch seconds. Not a read counter or reliable last-gameplay-action signal: updates depend on OS/filesystem policy. Windows can fall back to creation time when access time is absent; errors can give 0 with a diagnostic. Do not infer accessibility/read permission from this timestamp alone.

public string GetAsText();

Reads the entire file as UTF-8 from the beginning, then restores the original cursor. Does not read only the remainder. The main overload retains CR; it allocates for the whole content, so bound file size first. Not strict UTF-8/schema validation; for strict decoding read a bounded GetBuffer() and validate separately. Cursor restoration does not guarantee unchanged GetError().

public string GetAsText(bool skipCr);

Reads the entire file as UTF-8 from the beginning, then restores the original cursor. Does not read only the remainder. The main overload retains CR; it allocates for the whole content, so bound file size first. Not strict UTF-8/schema validation; for strict decoding read a bounded GetBuffer() and validate separately. Cursor restoration does not guarantee unchanged GetError().

public byte[] GetBuffer(long length);

Reads up to length bytes from the current position into a new C# byte[]. At EOF the array can be shorter than requested; check Length for fixed-format data. 0 returns empty without reading; negative length is invalid. Bound allocations beforehand; empty alone does not distinguish a zero request, end or error.

public string[] GetCsvLine(string delim = ",");

Reads a CSV record into string[]; quoted fields can span physical lines. Delimiter must be one non-double-quote character; double embedded quotes inside quoted fields. Line breaks are normalized through GetLine(). A blank line yields one empty field, not an unambiguous EOF signal. Does not validate schema/column count; damaged quotes can produce a diagnostic and a result, so validate records separately.

public double GetDouble();

Reads Double from 8 bytes and returns C# double. BigEndian applies through the numeric layout. Does not enforce finite values or gameplay-domain bounds. Check format, remaining record size and I/O status separately; this does not parse a text number.

public Error GetError();

Last backend status of this handle, not the last Open() error. Inspect immediately after an operation. On Windows a successful Seek() can clear the EOF indicator while GetError() retains FileEof; a later successful read refreshes it. Do not treat stale status as a new failure or ignore the current operation bool/returned length.

public static byte[] GetExtendedAttribute(string file, string attributeName);

Reads named extended attribute/stream bytes through the backend; Windows uses an alternate data stream. Empty byte[] does not distinguish an empty value, absent name, failure or unsupported backend. The name list adds information but is not an atomic check. Raw data written by SetExtendedAttributeString() can include a trailing NUL.

public static string GetExtendedAttributeString(string file, string attributeName);

Gets named bytes and decodes UTF-8. Not strict text validation; empty cannot distinguish absence, empty data and failure. For exact formats use GetExtendedAttribute() with an explicit UTF-8/terminator policy. Do not treat the attribute as part of the main content returned by GetFileAsBytes().

public static string[] GetExtendedAttributesList(string file);

Names of backend-visible extended attributes/streams. Windows lists named data streams, excluding the main unnamed stream. Order is unspecified. Empty can also result from unavailability/failure with no separate Error; the list can change before reading a value.

public static byte[] GetFileAsBytes(string path);

Opens a file, allocates for its full length and returns undecoded bytes. The bound helper updates GetOpenError(): empty can mean a valid empty file or an opening error, so check immediately. A convenience helper rather than a size-bounded reader: native code exposes no separate actual read count. For strict limits/short-read handling use Open(), GetLength() and bounded GetBuffer().

public static string GetFileAsString(string path);

Reads the whole file and decodes UTF-8, retaining CR. Empty can be valid data or an opening error; immediately check GetOpenError(), which this helper updates. That status describes opening, not full UTF-8/schema validation or concurrent file changes. Use bounded byte reads and a validating decoder for strict decoding.

public float GetFloat();

Reads Float from 4 bytes and returns C# float. BigEndian applies through the numeric layout. Does not enforce finite values or gameplay-domain bounds. Check format, remaining record size and I/O status separately; this does not parse a text number.

public float GetHalf();

Reads Half from 2 bytes and returns C# float. BigEndian applies through the numeric layout. Half loses source float precision: storage is 16-bit, not 32-bit. Check format, remaining record size and I/O status separately; this does not parse a text number.

public static bool GetHiddenAttribute(string file);

Queries a path hidden attribute through the backend; Windows reads FILE_ATTRIBUTE_HIDDEN. Not a universal dot-prefixed-name rule or access control. False can result from an error with a diagnostic rather than proving a normal file. Packed entries may provide no attribute.

public ulong GetLength();

Open file length in bytes, not remaining bytes or character count. Check a size limit before allocating buffers, while allowing for later changes. Windows temporarily seeks to end and back; EOF state can change, so this is not a substitute for checking read results.

public string GetLine();

Reads the next UTF-8 line from the current cursor without its terminator. Handles LF, CRLF and lone CR; NUL also ends a line, so this is unsuitable for arbitrary binary data. Empty does not necessarily mean EOF; an unterminated final line is also returned. Bound file size for input constraints.

public static string GetMd5(string path);

Reads the main file stream and returns MD5 as 32 lowercase hex characters. A valid empty file has a nonempty digest; opening failure gives empty string. A hash, not a digital signature or source-trust check. Native helper supplies no separate complete-read status; post-partial-read I/O errors and concurrent changes were not tested here.

public static ulong GetModifiedTime(string file);

Modification time in whole Unix-epoch seconds, not milliseconds or local time. Windows can fall back to creation time when write time is absent; failure/unavailability can return 0. Precision and updates depend on the backend. A timestamp alone does not verify content; packed/export metadata was not exercised here.

public static Error GetOpenError();

Last public file-opening error on this thread. A later Open-family call can replace it even on success. Read immediately after null; for an already opened handle, inspect operation results and GetError() instead of this static getter.

public string GetPascalString();

Reads a 32-bit length then UTF-8 payload, not an LF/NUL-terminated line. Length is bytes and uses BigEndian. Native code allocates from the prefix: validate a length bound and payload availability before using this on external data. Returned text is not strict corrupted-record validation; invalid/huge lengths were not executed in this pass.

public string GetPath();

Path associated with the open handle; Windows returns the original Open() string, such as asset://. Not necessarily a normalized OS path or persistent ID. Use GetPathAbsolute() for a physical path, subject to backend/export limits.

public string GetPathAbsolute();

Absolute path representation when supplied by the backend. Windows removes its internal prefix and uses forward separators. Does not prove existence, write permission, availability outside the application or a loose file in an exported package.

public ulong GetPosition();

Current byte position in an open file. A UTF-8 character can span several bytes, so this is not a character count. Interpret alongside the data format and read result. Position at file end alone does not imply EofReached().

public static bool GetReadOnlyAttribute(string file);

Reads the backend read-only attribute, FILE_ATTRIBUTE_READONLY on Windows. Not a full ACL test or guarantee about Open(Write)/another process access. Query errors can also return false with a diagnostic; check actual write operations separately.

public float GetReal();

Reads native real according to the internal read mode; the current SDK returns C# float and the installed build read 4 bytes. Not universal precision negotiation between builds. For a stable external format explicitly choose GetFloat() or GetDouble() and fix width, byte order and record version.

public static string GetSha256(string path);

Reads the main file stream and returns SHA-256 as 64 lowercase hex characters. A valid empty file has a nonempty digest; opening failure gives empty string. A hash, not a digital signature or source-trust check. Native helper supplies no separate complete-read status; post-partial-read I/O errors and concurrent changes were not tested here.

public static long GetSize(string file);

File byte size by path without a public handle. Ordinary backend failures can return -1, but this is not a universal indicator: Windows returns 0 for some invalid paths. Zero therefore proves no existing empty file. Check Open() for subsequent I/O; size can change after querying.

public static FileAccess.UnixPermissionFlags GetUnixPermissions(string file);

Returns Unix permission bits where supplied by the backend, not a full ACL. Windows returns 0 even for accessible files; this does not mean all access is denied. Packed entries can also give 0. Determine support and actual opening access separately.

public Variant GetVar(bool allowObjects = false);

Reads a StoreVar record: a 32-bit length using current BigEndian and a native Variant payload. Scope the C# result with using Variant. Nil may be valid stored data and can also result from an error; it is insufficient as a success test. Bound framing beforehand and validate schema/types. Keep allowObjects=false for external data; true permits native object construction from data, not merely extra fields. Full objects and corrupted lengths were not executed here.

public bool IsBigEndian();

Byte-order setting for numeric Get/Store operations on this handle: false is little-endian, true big-endian. A new Open() has a fresh false-default handle; the setting is not stored as file metadata. Does not reorder GetBuffer/StoreBuffer bytes or UTF-8 text. StoreVar/GetVar applies it to the 32-bit length prefix, not the inner Variant payload; tested. Reader and writer must agree on the format.

public bool IsOpen();

Tests whether a live handle has an open file. Returns false after Close() on the tested Windows backend. Proves no write mode, free space, current contents or previous-operation success. Do not use a wrapper after Dispose even for this test.

public static FileAccess Open(string path, FileAccess.ModeFlags flags);

Opens a file and returns an owned RefCounted handle; use using in C#. On null read GetOpenError() immediately on the same thread. Read/ReadWrite require an existing file; Write/WriteRead create or truncate it. ReadWrite preserves contents and starts at position 0, not append mode. Creates no parents. Use user:// for progress; original files under asset:// are not guaranteed after export.

public static FileAccess OpenCompressed(string path, FileAccess.ModeFlags modeFlags, FileAccess.CompressionMode compressionMode = FileAccess.CompressionMode.Fastlz);

Opens a FileAccess compression container, not an arbitrary .zip/.gz file. Even CompressionMode.GZip selects an algorithm inside the engine GCPF container. Use Write for writing and Read for reading; ReadWrite is rejected and WriteRead is not supported editing of an existing container. Reads select the algorithm from the header. Writes stay buffered until Close()/release; Flush() does not finalize them. The returned handle is owned; on null immediately check GetOpenError(). Corrupt/foreign containers are not validated inputs here.

public static FileAccess OpenEncrypted(string path, FileAccess.ModeFlags modeFlags, byte[] key);

Opens an engine encrypted FileAccess container with a 32-byte key; use only Read or Write. Critical 1.0.0 limitation: the base Write opens/truncates the destination before key validation. An invalid key length can return null/Error.InvalidParameter after previous contents are lost; reproduced on a disposable file. Validate parameters before calling and avoid overwriting the only valuable copy. Data stays in memory until Close()/release; Flush() writes no finished container. A write IV must be empty for generation or 16 bytes; reads use the file IV. The format uses AES-CFB and a data MD5, not a separately validated authenticated-encryption protocol. Security assessment and wrong-key reads were not executed; roundtrip does not prove security. On null check GetOpenError() immediately. The overload without iV selects automatic IV generation on writes.

public static FileAccess OpenEncrypted(string path, FileAccess.ModeFlags modeFlags, byte[] key, byte[] iV = null);

Opens an engine encrypted FileAccess container with a 32-byte key; use only Read or Write. Critical 1.0.0 limitation: the base Write opens/truncates the destination before key validation. An invalid key length can return null/Error.InvalidParameter after previous contents are lost; reproduced on a disposable file. Validate parameters before calling and avoid overwriting the only valuable copy. Data stays in memory until Close()/release; Flush() writes no finished container. A write IV must be empty for generation or 16 bytes; reads use the file IV. The format uses AES-CFB and a data MD5, not a separately validated authenticated-encryption protocol. Security assessment and wrong-key reads were not executed; roundtrip does not prove security. On null check GetOpenError() immediately.

public static FileAccess OpenEncrypted(string path, FileAccess.ModeFlags modeFlags, ReadOnlySpan<byte> key);

Opens an engine encrypted FileAccess container with a 32-byte key; use only Read or Write. Critical 1.0.0 limitation: the base Write opens/truncates the destination before key validation. An invalid key length can return null/Error.InvalidParameter after previous contents are lost; reproduced on a disposable file. Validate parameters before calling and avoid overwriting the only valuable copy. Data stays in memory until Close()/release; Flush() writes no finished container. A write IV must be empty for generation or 16 bytes; reads use the file IV. The format uses AES-CFB and a data MD5, not a separately validated authenticated-encryption protocol. Security assessment and wrong-key reads were not executed; roundtrip does not prove security. On null check GetOpenError() immediately. The overload without iV selects automatic IV generation on writes.

public static FileAccess OpenEncrypted(string path, FileAccess.ModeFlags modeFlags, ReadOnlySpan<byte> key, ReadOnlySpan<byte> iV);

Opens an engine encrypted FileAccess container with a 32-byte key; use only Read or Write. Critical 1.0.0 limitation: the base Write opens/truncates the destination before key validation. An invalid key length can return null/Error.InvalidParameter after previous contents are lost; reproduced on a disposable file. Validate parameters before calling and avoid overwriting the only valuable copy. Data stays in memory until Close()/release; Flush() writes no finished container. A write IV must be empty for generation or 16 bytes; reads use the file IV. The format uses AES-CFB and a data MD5, not a separately validated authenticated-encryption protocol. Security assessment and wrong-key reads were not executed; roundtrip does not prove security. On null check GetOpenError() immediately.

public static FileAccess OpenEncryptedWithPass(string path, FileAccess.ModeFlags modeFlags, string pass);

Opens the same encrypted FileAccess container using a password. Current native code derives the key from 32 characters of password MD5 text; this promises no modern password KDF, salt or separate authentication. Use Read/Write; check null and immediately GetOpenError(). Writes finalize only on close; Flush() leaves data in memory. The base Write already changes an existing file before setup completes, so container-opening failure does not guarantee destination preservation. A successful password roundtrip was tested; no security assessment was performed.

public static Error RemoveExtendedAttribute(string file, string attributeName);

Removes one named value/stream, not the file or all attributes. A missing name returns an error on Windows; do not assume automatic idempotence. Check Error/backend support; remove empty values by name like nonempty ones.

public Error Resize(long length);

Changes a writable open file byte length. Flush() first after writes: on Windows pending output can restore the old length even after Resize() returns Ok; reproduced. Check Error and final length; explicitly set the next operation cursor. Zero-filled growth was tested only on the current Windows filesystem, not guaranteed for every backend.

public void Seek(ulong position);

Sets an absolute byte offset from the beginning of an open file. Not a character index or truncation; a short overwrite can leave the old tail. Returns no Error; validate the offset and inspect subsequent I/O results. Windows successful seek clears the EOF indicator but may leave the previous GetError().

public void SeekEnd(long position = 0);

Moves relative to file end in bytes. 0 selects end for appending; negative values move before end; do not seek before the beginning. Creates no file and changes no mode. Call SeekEnd() to append after ReadWrite rather than assuming its initial cursor is at the end.

public void SetBigEndian(bool bigEndian);

Byte-order setting for numeric Get/Store operations on this handle: false is little-endian, true big-endian. A new Open() has a fresh false-default handle; the setting is not stored as file metadata. Does not reorder GetBuffer/StoreBuffer bytes or UTF-8 text. StoreVar/GetVar applies it to the 32-bit length prefix, not the inner Variant payload; tested. Reader and writer must agree on the format.

public static Error SetExtendedAttribute(string file, string attributeName, byte[] data);

Writes named bytes through the backend; array/span overloads supply the same content. Windows creates/overwrites a separate data stream, not the file main bytes. Check Error and filesystem support. An empty array can create an existing name with an empty value; it is not removal—use RemoveExtendedAttribute().

public static Error SetExtendedAttribute(string file, string attributeName, ReadOnlySpan<byte> data);

Writes named bytes through the backend; array/span overloads supply the same content. Windows creates/overwrites a separate data stream, not the file main bytes. Check Error and filesystem support. An empty array can create an existing name with an empty value; it is not removal—use RemoveExtendedAttribute().

public static Error SetExtendedAttributeString(string file, string attributeName, string data);

Encodes UTF-8 text for the attribute backend. The current implementation includes a trailing NUL, confirmed by reading raw bytes on Windows. For exact external byte formats use SetExtendedAttribute() with explicit encoding/terminator rules. Check Error; this does not write the main file content.

public static Error SetHiddenAttribute(string file, bool hidden);

Changes the backend hidden attribute; check returned Error. Windows changes the corresponding bit while retaining other attributes. Creates no file and protects no content from reading. OS/filesystem/packed-resource support varies; unavailable/failure is not successful application.

public static Error SetReadOnlyAttribute(string file, bool ro);

Sets/clears the backend read-only attribute; Windows changes one bit while retaining others. Not equivalent to configuring all permissions/ACLs and does not guarantee reversal if environment permissions change. Check Error; packed entries may not support this operation.

public static Error SetUnixPermissions(string file, FileAccess.UnixPermissionFlags permissions);

Requests Unix permission-bit changes. The tested Windows backend returns Error.Unavailable without changing ACLs. Packed entries are also unavailable for setting. Check Error; success of another attribute API proves no chmod support. Unix platforms were not executed here.

public bool Store16(ushort value);

Writes an unsigned 16-bit number in exactly 2 bytes at the current cursor, without a type/length tag. Byte order follows this handle BigEndian; defaults to little-endian. The reader must know the format and use Get16(). Check bool; writing is not atomic and guarantees no media flush.

public bool Store32(uint value);

Writes an unsigned 32-bit number in exactly 4 bytes at the current cursor, without a type/length tag. Byte order follows this handle BigEndian; defaults to little-endian. The reader must know the format and use Get32(). Check bool; writing is not atomic and guarantees no media flush.

public bool Store64(ulong value);

Writes an unsigned 64-bit number in exactly 8 bytes at the current cursor, without a type/length tag. Byte order follows this handle BigEndian; defaults to little-endian. The reader must know the format and use Get64(). Check bool; writing is not atomic and guarantees no media flush.

public bool Store8(byte value);

Writes an unsigned 8-bit number in exactly 1 bytes at the current cursor, without a type/length tag. BigEndian has no effect on one byte. The reader must know the format and use Get8(). Check bool; writing is not atomic and guarantees no media flush.

public bool StoreBuffer(byte[] buffer);

Writes supplied bytes at the current cursor without text, size or byte-order conversion. Array/span overloads perform the same write. Creates no parents, truncates no remaining old tail and promises no atomicity. Check bool/status and use a suitable ReadWrite/WriteRead mode when writing after reading.

public bool StoreBuffer(ReadOnlySpan<byte> buffer);

Writes supplied bytes at the current cursor without text, size or byte-order conversion. Array/span overloads perform the same write. Creates no parents, truncates no remaining old tail and promises no atomicity. Check bool/status and use a suitable ReadWrite/WriteRead mode when writing after reading.

public bool StoreCsvLine(ReadOnlySpan<string> values, string delim);

Writes a CSV record and one LF. Fields containing a delimiter, quote or LF are quoted; embedded quotes are doubled. A lone CR does not trigger quoting in the current implementation: such a field can split into two records when read, as reproduced. Normalize CRLF/CR to LF first when line breaks are needed inside fields; this changes original line endings. Use one non-double-quote delimiter for matching GetCsvLine(). Array/span overloads use the same format; check bool.

public bool StoreCsvLine(string[] values, string delim = ",");

Writes a CSV record and one LF. Fields containing a delimiter, quote or LF are quoted; embedded quotes are doubled. A lone CR does not trigger quoting in the current implementation: such a field can split into two records when read, as reproduced. Normalize CRLF/CR to LF first when line breaks are needed inside fields; this changes original line endings. Use one non-double-quote delimiter for matching GetCsvLine(). Array/span overloads use the same format; check bool.

public bool StoreDouble(double value);

Encodes a number as Double in 8 bytes with selected BigEndian; no text representation or type tag. Does not enforce finite values or gameplay-domain bounds. Read with matching GetDouble() and format; check the write bool.

public bool StoreFloat(float value);

Encodes a number as Float in 4 bytes with selected BigEndian; no text representation or type tag. Does not enforce finite values or gameplay-domain bounds. Read with matching GetFloat() and format; check the write bool.

public bool StoreHalf(float value);

Encodes a number as Half in 2 bytes with selected BigEndian; no text representation or type tag. Half loses source float precision: storage is 16-bit, not 32-bit. Read with matching GetHalf() and format; check the write bool.

public bool StoreLine(string line);

Writes UTF-8 text followed by one LF byte (0x0A), not platform CRLF. Does not remove a terminator already present in the argument. Returns the combined bool result; position grows by UTF-8 byte count plus LF. Overwrite and persistence limits are the same as StoreString().

public bool StorePascalString(string @string);

Writes a 32-bit UTF-8 byte length followed by the string bytes. Not a one-byte Pascal length or C# character count. The prefix uses BigEndian; payload remains UTF-8. Read with GetPascalString(), matching byte order and an agreed record-size bound; check bool.

public bool StoreReal(float value);

Native real write width depends on build precision: source selects StoreFloat or StoreDouble by sizeof(real_t). The installed build used 4 bytes; other precision builds were not tested. Explicitly choose StoreFloat()/StoreDouble() for a fixed-width external format. BigEndian applies; bool does not certify media persistence.

public bool StoreString(string @string);

Writes UTF-8 bytes at the current cursor without an automatic LF or length prefix. Position is measured in bytes. A short overwrite does not truncate an old tail; choose Write/WriteRead or controlled Resize(). Check bool and GetError(); true guarantees neither media persistence nor atomic saving.

public bool StoreVar(Variant value, bool fullObjects = false);

Serializes a Variant into native binary payload with a 32-bit length prefix. Format belongs to StoreVar/GetVar, not JSON, a prefab or a whole-level snapshot. BigEndian changes the length prefix, not inner payload bytes. fullObjects defaults to false; full-object serialization was not executed. Takes no ownership of the input Variant. Add your own save version/schema; check write bool and loaded types.