@carbonenginejs/runtime-resource 0.11.1 → 0.12.1

package/dist/_virtual/_rollupPluginBabelHelpers.js

@@ -121,9 +121,6 @@ function _checkInRHS(e) {
   if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null"));
   return e;
 }
-function _identity(t) {
-  return t;
-}
 function _setFunctionName(e, t, n) {
   "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : "");
   try {
@@ -149,5 +146,5 @@ function _toPropertyKey(t) {
   return "symbol" == typeof i ? i : i + "";
 }
 
-export { _applyDecs2311 as applyDecs2311, _checkInRHS as checkInRHS, _identity as identity, _setFunctionName as setFunctionName, _toPrimitive as toPrimitive, _toPropertyKey as toPropertyKey };
+export { _applyDecs2311 as applyDecs2311, _checkInRHS as checkInRHS, _setFunctionName as setFunctionName, _toPrimitive as toPrimitive, _toPropertyKey as toPropertyKey };
 //# sourceMappingURL=_rollupPluginBabelHelpers.js.map

package/dist/_virtual/_rollupPluginBabelHelpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"_rollupPluginBabelHelpers.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"_rollupPluginBabelHelpers.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/format/CjsByteReader.js

@@ -0,0 +1,310 @@
+import { CjsReader } from './CjsReader.js';
+import { CjsFormatReadError } from './CjsFormatError.js';
+import { asUint8Array } from '@carbonenginejs/runtime-utils/bytes';
+
+const textDecoder = new TextDecoder("utf-8", {
+  fatal: false
+});
+
+/**
+ * Little-endian cursor over resource bytes, with optional string-table arena
+ * resolution.
+ *
+ * This is the shared implementation behind `HlslReader`, `WebglReader`, and
+ * the Carbon-effect reader. Specialized readers only
+ * replace the error class and the end-of-data message:
+ *
+ * ```js
+ * class MyReader extends CjsByteReader
+ * {
+ *     static ReadError = MyReadError;
+ *     static endOfDataMessage = "Unexpected end of my data";
+ * }
+ * ```
+ *
+ * The arena primitives (`readString`, `readStringAt`, `readStringOptional`,
+ * `readTableBlob`, `readTableBlobOptional`) model Carbon's string table, where a
+ * single `uint32` offset resolves either to a NUL-terminated string or to a
+ * sized blob inside the same arena (`trinity/shadercompiler/StringTable.cpp`).
+ */
+class CjsByteReader extends CjsReader {
+  /** Error class raised for out-of-bounds and arena failures. */
+  static ReadError = CjsFormatReadError;
+
+  /** Message used when a read would run past the configured end. */
+  static endOfDataMessage = "Unexpected end of data";
+
+  /**
+   * Creates a reader over a byte payload and optional shared string table.
+   *
+   * @param {ArrayBuffer|ArrayBufferView|Uint8Array} bytes Source payload.
+   * @param {object} [options] Reader bounds and metadata.
+   * @param {number} [options.offset] Initial byte offset.
+   * @param {number} [options.end] Exclusive end offset.
+   * @param {string} [options.source] Source name used in error details.
+   * @param {ArrayBuffer|ArrayBufferView|Uint8Array} [options.stringTable] Arena bytes.
+   * @param {number} [options.stringTableSize] Valid arena byte count.
+   */
+  constructor(bytes, options = {}) {
+    super(options);
+    this.bytes = asUint8Array(bytes);
+    this.view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength);
+    this.offset = Number(options.offset) || 0;
+    this.end = Number.isInteger(options.end) ? options.end : this.bytes.length;
+    this.source = options.source || "memory";
+    this.stringTable = options.stringTable ? asUint8Array(options.stringTable) : null;
+    this.stringTableSize = Number.isInteger(options.stringTableSize) ? options.stringTableSize : this.stringTable ? this.stringTable.length : 0;
+  }
+
+  /**
+   * Attaches or replaces the string-table arena used by string and blob reads.
+   *
+   * @param {ArrayBuffer|ArrayBufferView|Uint8Array} bytes Arena bytes.
+   * @param {number|null} [size] Valid arena byte count.
+   */
+  setStringTable(bytes, size = null) {
+    this.stringTable = asUint8Array(bytes);
+    this.stringTableSize = Number.isInteger(size) ? size : this.stringTable.length;
+  }
+
+  /**
+   * Returns the unread byte count inside the configured reader bounds.
+   *
+   * @returns {number} Remaining bytes.
+   */
+  get remaining() {
+    return this.end - this.offset;
+  }
+
+  /**
+   * Advances the reader by a fixed number of bytes.
+   *
+   * @param {number} size Byte count to skip.
+   */
+  skip(size) {
+    this._require(size);
+    this.offset += size;
+  }
+
+  /**
+   * Reads a byte range from the main payload.
+   *
+   * @param {number} size Byte count to read.
+   * @returns {Uint8Array} View over the read bytes.
+   */
+  readRaw(size) {
+    this._require(size);
+    const start = this.offset;
+    this.offset += size;
+    return this.bytes.subarray(start, start + size);
+  }
+
+  /**
+   * Reads an unsigned 8-bit integer.
+   *
+   * @returns {number} Integer value.
+   */
+  readUint8() {
+    this._require(1);
+    const value = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+
+  /**
+   * Reads a little-endian unsigned 16-bit integer.
+   *
+   * @returns {number} Integer value.
+   */
+  readUint16() {
+    this._require(2);
+    const value = this.view.getUint16(this.offset, true);
+    this.offset += 2;
+    return value;
+  }
+
+  /**
+   * Reads a little-endian unsigned 32-bit integer.
+   *
+   * @returns {number} Integer value.
+   */
+  readUint32() {
+    this._require(4);
+    const value = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+
+  /**
+   * Reads a little-endian signed 32-bit integer.
+   *
+   * @returns {number} Integer value.
+   */
+  readInt32() {
+    this._require(4);
+    const value = this.view.getInt32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+
+  /**
+   * Reads a little-endian 32-bit float.
+   *
+   * @returns {number} Float value.
+   */
+  readFloat32() {
+    this._require(4);
+    const value = this.view.getFloat32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+
+  /**
+   * Reads Carbon's byte-sized boolean encoding.
+   *
+   * @returns {boolean} Boolean value.
+   */
+  readBool() {
+    return this.readUint8() !== 0;
+  }
+
+  /**
+   * Reads a string-table offset and resolves it to a UTF-8 string.
+   *
+   * @param {number} [sizeHint] Optional maximum byte span for bounds checking.
+   * @returns {string} Decoded string.
+   */
+  readString(sizeHint = 0) {
+    const offset = this.readUint32();
+    return this.readStringAt(offset, sizeHint);
+  }
+
+  /**
+   * Reads an optional string-table offset, returning null for zero-length fields.
+   *
+   * Carbon consumes the offset word regardless of the length and only
+   * dereferences it when the length is non-zero, which is the single site
+   * where the `0xffffffff` null reference is legal
+   * (`Tr2EffectDescription.cpp:80-91`).
+   *
+   * @param {number} length Source field length.
+   * @returns {string|null} Decoded string or null.
+   */
+  readStringOptional(length) {
+    const offset = this.readUint32();
+    if (length === 0) {
+      return null;
+    }
+    return this.readStringAt(offset, length);
+  }
+
+  /**
+   * Reads a string-table blob offset and returns the referenced byte range.
+   *
+   * @param {number} size Blob byte count.
+   * @returns {{offset:number,bytes:Uint8Array}} Blob location and bytes.
+   */
+  readTableBlob(size) {
+    const offset = this.readUint32();
+    this._requireStringTable(offset, size);
+    return {
+      offset,
+      bytes: this.stringTable.subarray(offset, offset + size)
+    };
+  }
+
+  /**
+   * Reads a possibly empty string-table blob reference.
+   *
+   * @param {number} size Blob byte count.
+   * @returns {{offset:number,bytes:Uint8Array}} Blob location and bytes.
+   */
+  readTableBlobOptional(size) {
+    const offset = this.readUint32();
+    if (size === 0) {
+      return {
+        offset,
+        bytes: new Uint8Array(0)
+      };
+    }
+    this._requireStringTable(offset, size);
+    return {
+      offset,
+      bytes: this.stringTable.subarray(offset, offset + size)
+    };
+  }
+
+  /**
+   * Resolves a string table offset to a null-terminated UTF-8 string.
+   *
+   * @param {number} offset String-table byte offset.
+   * @param {number} [sizeHint] Optional maximum byte span for bounds checking.
+   * @returns {string} Decoded string.
+   */
+  readStringAt(offset, sizeHint = 0) {
+    this._requireStringTable(offset, sizeHint);
+    let end = offset;
+    while (end < this.stringTableSize && this.stringTable[end] !== 0) {
+      end += 1;
+    }
+    return textDecoder.decode(this.stringTable.subarray(offset, end));
+  }
+
+  /**
+   * Creates this reader's error type with shared reader-state details.
+   *
+   * @param {string} message Human-readable failure reason.
+   * @param {object} [details] Extra reader state.
+   * @returns {Error} Reader-specific error instance.
+   * @protected
+   */
+  _error(message, details = {}) {
+    const ReadError = this.constructor.ReadError ?? CjsFormatReadError;
+    return new ReadError(message, {
+      source: this.source,
+      ...details
+    });
+  }
+
+  /**
+   * Ensures the requested read fits inside the configured payload bounds.
+   *
+   * @param {number} size Requested byte count.
+   * @private
+   */
+  _require(size) {
+    if (!Number.isInteger(size) || size < 0 || this.offset + size > this.end) {
+      throw this._error(this.constructor.endOfDataMessage, {
+        offset: this.offset,
+        requested: size,
+        end: this.end
+      });
+    }
+  }
+
+  /**
+   * Ensures a string-table offset and optional span are valid.
+   *
+   * @param {number} offset String-table byte offset.
+   * @param {number} [sizeHint] Optional byte span for bounds checking.
+   * @private
+   */
+  _requireStringTable(offset, sizeHint = 0) {
+    const size = Number(sizeHint) || 0;
+    if (!this.stringTable) {
+      throw this._error("Missing effect string table", {
+        offset
+      });
+    }
+    if (!Number.isInteger(offset) || offset < 0 || offset >= this.stringTableSize || offset + size > this.stringTableSize) {
+      throw this._error("Invalid string-table offset", {
+        offset,
+        sizeHint: size,
+        stringTableSize: this.stringTableSize
+      });
+    }
+  }
+}
+
+export { CjsByteReader };
+//# sourceMappingURL=CjsByteReader.js.map

package/dist/format/CjsByteReader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CjsByteReader.js","sources":["../../../src/format/CjsByteReader.js"],"sourcesContent":["import { CjsReader } from \"./CjsReader.js\";\nimport { CjsFormatReadError } from \"./CjsFormatError.js\";\nimport { asUint8Array } from \"@carbonenginejs/runtime-utils/bytes\";\n\nconst textDecoder = new TextDecoder(\"utf-8\", { fatal: false });\n\n/**\n * Little-endian cursor over resource bytes, with optional string-table arena\n * resolution.\n *\n * This is the shared implementation behind `HlslReader`, `WebglReader`, and\n * the Carbon-effect reader. Specialized readers only\n * replace the error class and the end-of-data message:\n *\n * ```js\n * class MyReader extends CjsByteReader\n * {\n *     static ReadError = MyReadError;\n *     static endOfDataMessage = \"Unexpected end of my data\";\n * }\n * ```\n *\n * The arena primitives (`readString`, `readStringAt`, `readStringOptional`,\n * `readTableBlob`, `readTableBlobOptional`) model Carbon's string table, where a\n * single `uint32` offset resolves either to a NUL-terminated string or to a\n * sized blob inside the same arena (`trinity/shadercompiler/StringTable.cpp`).\n */\nexport class CjsByteReader extends CjsReader\n{\n    /** Error class raised for out-of-bounds and arena failures. */\n    static ReadError = CjsFormatReadError;\n\n    /** Message used when a read would run past the configured end. */\n    static endOfDataMessage = \"Unexpected end of data\";\n\n    /**\n     * Creates a reader over a byte payload and optional shared string table.\n     *\n     * @param {ArrayBuffer|ArrayBufferView|Uint8Array} bytes Source payload.\n     * @param {object} [options] Reader bounds and metadata.\n     * @param {number} [options.offset] Initial byte offset.\n     * @param {number} [options.end] Exclusive end offset.\n     * @param {string} [options.source] Source name used in error details.\n     * @param {ArrayBuffer|ArrayBufferView|Uint8Array} [options.stringTable] Arena bytes.\n     * @param {number} [options.stringTableSize] Valid arena byte count.\n     */\n    constructor(bytes, options = {})\n    {\n        super(options);\n        this.bytes = asUint8Array(bytes);\n        this.view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength);\n        this.offset = Number(options.offset) || 0;\n        this.end = Number.isInteger(options.end) ? options.end : this.bytes.length;\n        this.source = options.source || \"memory\";\n        this.stringTable = options.stringTable ? asUint8Array(options.stringTable) : null;\n        this.stringTableSize = Number.isInteger(options.stringTableSize)\n            ? options.stringTableSize\n            : (this.stringTable ? this.stringTable.length : 0);\n    }\n\n    /**\n     * Attaches or replaces the string-table arena used by string and blob reads.\n     *\n     * @param {ArrayBuffer|ArrayBufferView|Uint8Array} bytes Arena bytes.\n     * @param {number|null} [size] Valid arena byte count.\n     */\n    setStringTable(bytes, size = null)\n    {\n        this.stringTable = asUint8Array(bytes);\n        this.stringTableSize = Number.isInteger(size) ? size : this.stringTable.length;\n    }\n\n    /**\n     * Returns the unread byte count inside the configured reader bounds.\n     *\n     * @returns {number} Remaining bytes.\n     */\n    get remaining()\n    {\n        return this.end - this.offset;\n    }\n\n    /**\n     * Advances the reader by a fixed number of bytes.\n     *\n     * @param {number} size Byte count to skip.\n     */\n    skip(size)\n    {\n        this._require(size);\n        this.offset += size;\n    }\n\n    /**\n     * Reads a byte range from the main payload.\n     *\n     * @param {number} size Byte count to read.\n     * @returns {Uint8Array} View over the read bytes.\n     */\n    readRaw(size)\n    {\n        this._require(size);\n        const start = this.offset;\n        this.offset += size;\n        return this.bytes.subarray(start, start + size);\n    }\n\n    /**\n     * Reads an unsigned 8-bit integer.\n     *\n     * @returns {number} Integer value.\n     */\n    readUint8()\n    {\n        this._require(1);\n        const value = this.view.getUint8(this.offset);\n        this.offset += 1;\n        return value;\n    }\n\n    /**\n     * Reads a little-endian unsigned 16-bit integer.\n     *\n     * @returns {number} Integer value.\n     */\n    readUint16()\n    {\n        this._require(2);\n        const value = this.view.getUint16(this.offset, true);\n        this.offset += 2;\n        return value;\n    }\n\n    /**\n     * Reads a little-endian unsigned 32-bit integer.\n     *\n     * @returns {number} Integer value.\n     */\n    readUint32()\n    {\n        this._require(4);\n        const value = this.view.getUint32(this.offset, true);\n        this.offset += 4;\n        return value;\n    }\n\n    /**\n     * Reads a little-endian signed 32-bit integer.\n     *\n     * @returns {number} Integer value.\n     */\n    readInt32()\n    {\n        this._require(4);\n        const value = this.view.getInt32(this.offset, true);\n        this.offset += 4;\n        return value;\n    }\n\n    /**\n     * Reads a little-endian 32-bit float.\n     *\n     * @returns {number} Float value.\n     */\n    readFloat32()\n    {\n        this._require(4);\n        const value = this.view.getFloat32(this.offset, true);\n        this.offset += 4;\n        return value;\n    }\n\n    /**\n     * Reads Carbon's byte-sized boolean encoding.\n     *\n     * @returns {boolean} Boolean value.\n     */\n    readBool()\n    {\n        return this.readUint8() !== 0;\n    }\n\n    /**\n     * Reads a string-table offset and resolves it to a UTF-8 string.\n     *\n     * @param {number} [sizeHint] Optional maximum byte span for bounds checking.\n     * @returns {string} Decoded string.\n     */\n    readString(sizeHint = 0)\n    {\n        const offset = this.readUint32();\n        return this.readStringAt(offset, sizeHint);\n    }\n\n    /**\n     * Reads an optional string-table offset, returning null for zero-length fields.\n     *\n     * Carbon consumes the offset word regardless of the length and only\n     * dereferences it when the length is non-zero, which is the single site\n     * where the `0xffffffff` null reference is legal\n     * (`Tr2EffectDescription.cpp:80-91`).\n     *\n     * @param {number} length Source field length.\n     * @returns {string|null} Decoded string or null.\n     */\n    readStringOptional(length)\n    {\n        const offset = this.readUint32();\n        if (length === 0)\n        {\n            return null;\n        }\n        return this.readStringAt(offset, length);\n    }\n\n    /**\n     * Reads a string-table blob offset and returns the referenced byte range.\n     *\n     * @param {number} size Blob byte count.\n     * @returns {{offset:number,bytes:Uint8Array}} Blob location and bytes.\n     */\n    readTableBlob(size)\n    {\n        const offset = this.readUint32();\n        this._requireStringTable(offset, size);\n        return {\n            offset,\n            bytes: this.stringTable.subarray(offset, offset + size)\n        };\n    }\n\n    /**\n     * Reads a possibly empty string-table blob reference.\n     *\n     * @param {number} size Blob byte count.\n     * @returns {{offset:number,bytes:Uint8Array}} Blob location and bytes.\n     */\n    readTableBlobOptional(size)\n    {\n        const offset = this.readUint32();\n        if (size === 0)\n        {\n            return {\n                offset,\n                bytes: new Uint8Array(0)\n            };\n        }\n        this._requireStringTable(offset, size);\n        return {\n            offset,\n            bytes: this.stringTable.subarray(offset, offset + size)\n        };\n    }\n\n    /**\n     * Resolves a string table offset to a null-terminated UTF-8 string.\n     *\n     * @param {number} offset String-table byte offset.\n     * @param {number} [sizeHint] Optional maximum byte span for bounds checking.\n     * @returns {string} Decoded string.\n     */\n    readStringAt(offset, sizeHint = 0)\n    {\n        this._requireStringTable(offset, sizeHint);\n        let end = offset;\n        while (end < this.stringTableSize && this.stringTable[end] !== 0)\n        {\n            end += 1;\n        }\n        return textDecoder.decode(this.stringTable.subarray(offset, end));\n    }\n\n    /**\n     * Creates this reader's error type with shared reader-state details.\n     *\n     * @param {string} message Human-readable failure reason.\n     * @param {object} [details] Extra reader state.\n     * @returns {Error} Reader-specific error instance.\n     * @protected\n     */\n    _error(message, details = {})\n    {\n        const ReadError = this.constructor.ReadError ?? CjsFormatReadError;\n        return new ReadError(message, { source: this.source, ...details });\n    }\n\n    /**\n     * Ensures the requested read fits inside the configured payload bounds.\n     *\n     * @param {number} size Requested byte count.\n     * @private\n     */\n    _require(size)\n    {\n        if (!Number.isInteger(size) || size < 0 || this.offset + size > this.end)\n        {\n            throw this._error(this.constructor.endOfDataMessage, {\n                offset: this.offset,\n                requested: size,\n                end: this.end\n            });\n        }\n    }\n\n    /**\n     * Ensures a string-table offset and optional span are valid.\n     *\n     * @param {number} offset String-table byte offset.\n     * @param {number} [sizeHint] Optional byte span for bounds checking.\n     * @private\n     */\n    _requireStringTable(offset, sizeHint = 0)\n    {\n        const size = Number(sizeHint) || 0;\n        if (!this.stringTable)\n        {\n            throw this._error(\"Missing effect string table\", { offset });\n        }\n        if (!Number.isInteger(offset) || offset < 0 || offset >= this.stringTableSize || offset + size > this.stringTableSize)\n        {\n            throw this._error(\"Invalid string-table offset\", {\n                offset,\n                sizeHint: size,\n                stringTableSize: this.stringTableSize\n            });\n        }\n    }\n}\n\nexport default CjsByteReader;\n"],"names":["textDecoder","TextDecoder","fatal","CjsByteReader","CjsReader","ReadError","CjsFormatReadError","endOfDataMessage","constructor","bytes","options","asUint8Array","view","DataView","buffer","byteOffset","byteLength","offset","Number","end","isInteger","length","source","stringTable","stringTableSize","setStringTable","size","remaining","skip","_require","readRaw","start","subarray","readUint8","value","getUint8","readUint16","getUint16","readUint32","getUint32","readInt32","getInt32","readFloat32","getFloat32","readBool","readString","sizeHint","readStringAt","readStringOptional","readTableBlob","_requireStringTable","readTableBlobOptional","Uint8Array","decode","_error","message","details","requested"],"mappings":"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"}

package/dist/format/CjsByteWriter.js

@@ -0,0 +1,242 @@
+import { CjsFormatWriteError } from './CjsFormatError.js';
+
+const textEncoder = new TextEncoder();
+
+/**
+ * Growable little-endian append cursor with reserve-and-patch support.
+ *
+ * `formats/cmf/core/writer.js` already has a growable buffer, but it is
+ * patch-style throughout: every write takes an explicit offset produced by a
+ * prior `reserve`. Container assembly wants the opposite default — append in
+ * field order — with patching kept for the one case that needs it, an offset
+ * table whose values are only known after the payload it points at has been
+ * measured.
+ *
+ * Every append returns the offset it wrote at, so the reserve-and-patch case is
+ * just "keep the offset an append returned".
+ */
+class CjsByteWriter {
+  #bytes;
+  #view;
+  #length = 0;
+
+  /**
+   * Creates an empty writer with an initial capacity.
+   *
+   * @param {number} [initialCapacity] Starting buffer size in bytes.
+   */
+  constructor(initialCapacity = 1024) {
+    const capacity = Number.isInteger(initialCapacity) && initialCapacity > 0 ? initialCapacity : 1024;
+    this.#bytes = new Uint8Array(capacity);
+    this.#view = new DataView(this.#bytes.buffer);
+  }
+
+  /**
+   * Returns the number of bytes written so far.
+   *
+   * @returns {number} Written byte count.
+   */
+  get length() {
+    return this.#length;
+  }
+
+  /**
+   * Appends an unsigned 8-bit integer.
+   *
+   * @param {number} value Integer value.
+   * @returns {number} Offset the value was written at.
+   */
+  u8(value) {
+    const offset = this.#advance(1);
+    this.#view.setUint8(offset, value & 0xff);
+    return offset;
+  }
+
+  /**
+   * Appends a little-endian unsigned 16-bit integer.
+   *
+   * @param {number} value Integer value.
+   * @returns {number} Offset the value was written at.
+   */
+  u16(value) {
+    const offset = this.#advance(2);
+    this.#view.setUint16(offset, value & 0xffff, true);
+    return offset;
+  }
+
+  /**
+   * Appends a little-endian unsigned 32-bit integer.
+   *
+   * @param {number} value Integer value.
+   * @returns {number} Offset the value was written at.
+   */
+  u32(value) {
+    const offset = this.#advance(4);
+    this.#view.setUint32(offset, value >>> 0, true);
+    return offset;
+  }
+
+  /**
+   * Appends a little-endian signed 32-bit integer.
+   *
+   * @param {number} value Integer value.
+   * @returns {number} Offset the value was written at.
+   */
+  i32(value) {
+    const offset = this.#advance(4);
+    this.#view.setInt32(offset, value | 0, true);
+    return offset;
+  }
+
+  /**
+   * Appends a little-endian 32-bit float.
+   *
+   * @param {number} value Float value.
+   * @returns {number} Offset the value was written at.
+   */
+  f32(value) {
+    const offset = this.#advance(4);
+    this.#view.setFloat32(offset, Number(value) || 0, true);
+    return offset;
+  }
+
+  /**
+   * Appends Carbon's byte-sized boolean encoding.
+   *
+   * @param {boolean} value Boolean value.
+   * @returns {number} Offset the value was written at.
+   */
+  bool(value) {
+    return this.u8(value ? 1 : 0);
+  }
+
+  /**
+   * Appends raw bytes.
+   *
+   * @param {ArrayBufferView|Uint8Array} value Bytes to append.
+   * @returns {number} Offset the bytes were written at.
+   */
+  bytes(value) {
+    const source = value instanceof Uint8Array ? value : new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    const offset = this.#advance(source.byteLength);
+    this.#bytes.set(source, offset);
+    return offset;
+  }
+
+  /**
+   * Appends UTF-8 text without a terminator.
+   *
+   * @param {string} value Text to append.
+   * @returns {number} Offset the text was written at.
+   */
+  utf8(value) {
+    return this.bytes(textEncoder.encode(String(value)));
+  }
+
+  /**
+   * Appends a run of zero bytes and returns its offset, for later patching.
+   *
+   * @param {number} count Byte count to reserve.
+   * @returns {number} Offset of the reserved run.
+   */
+  reserve(count) {
+    if (!Number.isInteger(count) || count < 0) {
+      throw new CjsFormatWriteError("Reserve count must be a non-negative integer", {
+        count
+      });
+    }
+    const offset = this.#advance(count);
+    this.#bytes.fill(0, offset, offset + count);
+    return offset;
+  }
+
+  /**
+   * Overwrites a previously written unsigned 8-bit integer.
+   *
+   * @param {number} offset Target offset.
+   * @param {number} value Integer value.
+   */
+  patchU8(offset, value) {
+    this.#requireWritten(offset, 1);
+    this.#view.setUint8(offset, value & 0xff);
+  }
+
+  /**
+   * Overwrites a previously written little-endian unsigned 32-bit integer.
+   *
+   * @param {number} offset Target offset.
+   * @param {number} value Integer value.
+   */
+  patchU32(offset, value) {
+    this.#requireWritten(offset, 4);
+    this.#view.setUint32(offset, value >>> 0, true);
+  }
+
+  /**
+   * Overwrites a previously written byte range.
+   *
+   * @param {number} offset Target offset.
+   * @param {ArrayBufferView|Uint8Array} value Replacement bytes.
+   */
+  patchBytes(offset, value) {
+    const source = value instanceof Uint8Array ? value : new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    this.#requireWritten(offset, source.byteLength);
+    this.#bytes.set(source, offset);
+  }
+
+  /**
+   * Returns an owned copy of the written bytes.
+   *
+   * @returns {Uint8Array} Written payload.
+   */
+  toBytes() {
+    return this.#bytes.slice(0, this.#length);
+  }
+
+  /**
+   * Grows the buffer when a write would exceed capacity.
+   *
+   * @param {number} capacity Required total capacity.
+   */
+  #ensure(capacity) {
+    if (capacity <= this.#bytes.length) return;
+    let next = this.#bytes.length * 2;
+    while (next < capacity) next *= 2;
+    const grown = new Uint8Array(next);
+    grown.set(this.#bytes.subarray(0, this.#length));
+    this.#bytes = grown;
+    this.#view = new DataView(grown.buffer);
+  }
+
+  /**
+   * Reserves space for one append and returns the offset it starts at.
+   *
+   * @param {number} size Byte count for this append.
+   * @returns {number} Offset of the appended run.
+   */
+  #advance(size) {
+    const offset = this.#length;
+    this.#ensure(offset + size);
+    this.#length = offset + size;
+    return offset;
+  }
+
+  /**
+   * Rejects a patch that falls outside the bytes already written.
+   *
+   * @param {number} offset Target offset.
+   * @param {number} size Patch byte count.
+   */
+  #requireWritten(offset, size) {
+    if (!Number.isInteger(offset) || offset < 0 || offset + size > this.#length) {
+      throw new CjsFormatWriteError("Patch target is outside the written range", {
+        offset,
+        size,
+        length: this.#length
+      });
+    }
+  }
+}
+
+export { CjsByteWriter };
+//# sourceMappingURL=CjsByteWriter.js.map

package/dist/format/CjsByteWriter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CjsByteWriter.js","sources":["../../../src/format/CjsByteWriter.js"],"sourcesContent":["import { CjsFormatWriteError } from \"./CjsFormatError.js\";\n\nconst textEncoder = new TextEncoder();\n\n/**\n * Growable little-endian append cursor with reserve-and-patch support.\n *\n * `formats/cmf/core/writer.js` already has a growable buffer, but it is\n * patch-style throughout: every write takes an explicit offset produced by a\n * prior `reserve`. Container assembly wants the opposite default — append in\n * field order — with patching kept for the one case that needs it, an offset\n * table whose values are only known after the payload it points at has been\n * measured.\n *\n * Every append returns the offset it wrote at, so the reserve-and-patch case is\n * just \"keep the offset an append returned\".\n */\nexport class CjsByteWriter\n{\n    #bytes;\n    #view;\n    #length = 0;\n\n    /**\n     * Creates an empty writer with an initial capacity.\n     *\n     * @param {number} [initialCapacity] Starting buffer size in bytes.\n     */\n    constructor(initialCapacity = 1024)\n    {\n        const capacity = Number.isInteger(initialCapacity) && initialCapacity > 0 ? initialCapacity : 1024;\n        this.#bytes = new Uint8Array(capacity);\n        this.#view = new DataView(this.#bytes.buffer);\n    }\n\n    /**\n     * Returns the number of bytes written so far.\n     *\n     * @returns {number} Written byte count.\n     */\n    get length()\n    {\n        return this.#length;\n    }\n\n    /**\n     * Appends an unsigned 8-bit integer.\n     *\n     * @param {number} value Integer value.\n     * @returns {number} Offset the value was written at.\n     */\n    u8(value)\n    {\n        const offset = this.#advance(1);\n        this.#view.setUint8(offset, value & 0xff);\n        return offset;\n    }\n\n    /**\n     * Appends a little-endian unsigned 16-bit integer.\n     *\n     * @param {number} value Integer value.\n     * @returns {number} Offset the value was written at.\n     */\n    u16(value)\n    {\n        const offset = this.#advance(2);\n        this.#view.setUint16(offset, value & 0xffff, true);\n        return offset;\n    }\n\n    /**\n     * Appends a little-endian unsigned 32-bit integer.\n     *\n     * @param {number} value Integer value.\n     * @returns {number} Offset the value was written at.\n     */\n    u32(value)\n    {\n        const offset = this.#advance(4);\n        this.#view.setUint32(offset, value >>> 0, true);\n        return offset;\n    }\n\n    /**\n     * Appends a little-endian signed 32-bit integer.\n     *\n     * @param {number} value Integer value.\n     * @returns {number} Offset the value was written at.\n     */\n    i32(value)\n    {\n        const offset = this.#advance(4);\n        this.#view.setInt32(offset, value | 0, true);\n        return offset;\n    }\n\n    /**\n     * Appends a little-endian 32-bit float.\n     *\n     * @param {number} value Float value.\n     * @returns {number} Offset the value was written at.\n     */\n    f32(value)\n    {\n        const offset = this.#advance(4);\n        this.#view.setFloat32(offset, Number(value) || 0, true);\n        return offset;\n    }\n\n    /**\n     * Appends Carbon's byte-sized boolean encoding.\n     *\n     * @param {boolean} value Boolean value.\n     * @returns {number} Offset the value was written at.\n     */\n    bool(value)\n    {\n        return this.u8(value ? 1 : 0);\n    }\n\n    /**\n     * Appends raw bytes.\n     *\n     * @param {ArrayBufferView|Uint8Array} value Bytes to append.\n     * @returns {number} Offset the bytes were written at.\n     */\n    bytes(value)\n    {\n        const source = value instanceof Uint8Array\n            ? value\n            : new Uint8Array(value.buffer, value.byteOffset, value.byteLength);\n        const offset = this.#advance(source.byteLength);\n        this.#bytes.set(source, offset);\n        return offset;\n    }\n\n    /**\n     * Appends UTF-8 text without a terminator.\n     *\n     * @param {string} value Text to append.\n     * @returns {number} Offset the text was written at.\n     */\n    utf8(value)\n    {\n        return this.bytes(textEncoder.encode(String(value)));\n    }\n\n    /**\n     * Appends a run of zero bytes and returns its offset, for later patching.\n     *\n     * @param {number} count Byte count to reserve.\n     * @returns {number} Offset of the reserved run.\n     */\n    reserve(count)\n    {\n        if (!Number.isInteger(count) || count < 0)\n        {\n            throw new CjsFormatWriteError(\"Reserve count must be a non-negative integer\", { count });\n        }\n        const offset = this.#advance(count);\n        this.#bytes.fill(0, offset, offset + count);\n        return offset;\n    }\n\n    /**\n     * Overwrites a previously written unsigned 8-bit integer.\n     *\n     * @param {number} offset Target offset.\n     * @param {number} value Integer value.\n     */\n    patchU8(offset, value)\n    {\n        this.#requireWritten(offset, 1);\n        this.#view.setUint8(offset, value & 0xff);\n    }\n\n    /**\n     * Overwrites a previously written little-endian unsigned 32-bit integer.\n     *\n     * @param {number} offset Target offset.\n     * @param {number} value Integer value.\n     */\n    patchU32(offset, value)\n    {\n        this.#requireWritten(offset, 4);\n        this.#view.setUint32(offset, value >>> 0, true);\n    }\n\n    /**\n     * Overwrites a previously written byte range.\n     *\n     * @param {number} offset Target offset.\n     * @param {ArrayBufferView|Uint8Array} value Replacement bytes.\n     */\n    patchBytes(offset, value)\n    {\n        const source = value instanceof Uint8Array\n            ? value\n            : new Uint8Array(value.buffer, value.byteOffset, value.byteLength);\n        this.#requireWritten(offset, source.byteLength);\n        this.#bytes.set(source, offset);\n    }\n\n    /**\n     * Returns an owned copy of the written bytes.\n     *\n     * @returns {Uint8Array} Written payload.\n     */\n    toBytes()\n    {\n        return this.#bytes.slice(0, this.#length);\n    }\n\n    /**\n     * Grows the buffer when a write would exceed capacity.\n     *\n     * @param {number} capacity Required total capacity.\n     */\n    #ensure(capacity)\n    {\n        if (capacity <= this.#bytes.length) return;\n        let next = this.#bytes.length * 2;\n        while (next < capacity) next *= 2;\n        const grown = new Uint8Array(next);\n        grown.set(this.#bytes.subarray(0, this.#length));\n        this.#bytes = grown;\n        this.#view = new DataView(grown.buffer);\n    }\n\n    /**\n     * Reserves space for one append and returns the offset it starts at.\n     *\n     * @param {number} size Byte count for this append.\n     * @returns {number} Offset of the appended run.\n     */\n    #advance(size)\n    {\n        const offset = this.#length;\n        this.#ensure(offset + size);\n        this.#length = offset + size;\n        return offset;\n    }\n\n    /**\n     * Rejects a patch that falls outside the bytes already written.\n     *\n     * @param {number} offset Target offset.\n     * @param {number} size Patch byte count.\n     */\n    #requireWritten(offset, size)\n    {\n        if (!Number.isInteger(offset) || offset < 0 || offset + size > this.#length)\n        {\n            throw new CjsFormatWriteError(\"Patch target is outside the written range\", {\n                offset,\n                size,\n                length: this.#length\n            });\n        }\n    }\n}\n\nexport default CjsByteWriter;\n"],"names":["textEncoder","TextEncoder","CjsByteWriter","constructor","initialCapacity","capacity","Number","isInteger","Uint8Array","DataView","buffer","length","u8","value","offset","setUint8","u16","setUint16","u32","setUint32","i32","setInt32","f32","setFloat32","bool","bytes","source","byteOffset","byteLength","set","utf8","encode","String","reserve","count","CjsFormatWriteError","fill","patchU8","patchU32","patchBytes","toBytes","slice","#ensure","next","grown","subarray","#advance","size","#requireWritten"],"mappings":"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"}

package/dist/format/CjsFormatError.js

@@ -0,0 +1,41 @@
+/**
+ * Error raised when shared binary format bytes cannot be decoded safely.
+ *
+ * Format-specific readers substitute their own error class through the
+ * `ReadError` static on `CjsByteReader`, so this type is the fallback for
+ * readers that do not need a distinguishable name.
+ */
+class CjsFormatReadError extends Error {
+  /**
+   * Creates a read error with structured reader-state details.
+   *
+   * @param {string} message Human-readable failure reason.
+   * @param {object} [details] Extra reader state such as source, offset, or size.
+   */
+  constructor(message, details = {}) {
+    super(message);
+    this.name = "CjsFormatReadError";
+    this.details = details;
+  }
+}
+
+/**
+ * Error raised when shared binary format bytes cannot be encoded safely.
+ */
+class CjsFormatWriteError extends Error {
+  /**
+   * Creates a write error with structured writer-state details.
+   *
+   * @param {string} message Human-readable failure reason.
+   * @param {object} [details] Extra writer state such as offset or value.
+   */
+  constructor(message, details = {}) {
+    super(message);
+    this.name = "CjsFormatWriteError";
+    this.code = "CJS_FORMAT_WRITE_ERROR";
+    this.details = details;
+  }
+}
+
+export { CjsFormatReadError, CjsFormatWriteError };
+//# sourceMappingURL=CjsFormatError.js.map