@sachitv/avro-typescript 0.4.1 → 0.5.0

package/esm/serialization/counting_writable_tap.js

@@ -0,0 +1,90 @@
+import { TapBase } from "./tap.js";
+import { utf8ByteLength } from "./text_encoding.js";
+/**
+ * A writable tap that counts encoded bytes without allocating buffers.
+ *
+ * Used for two-pass serialization where the first pass calculates the
+ * exact buffer size needed, then the second pass writes to a pre-allocated
+ * buffer. This avoids buffer reallocations and copies.
+ *
+ * @example
+ * ```ts
+ * // Pass 1: Calculate size
+ * const countingTap = new CountingWritableTap();
+ * await type.write(countingTap, value);
+ * const size = countingTap.getPos();
+ *
+ * // Pass 2: Write to exact-size buffer
+ * const buffer = new ArrayBuffer(size);
+ * const tap = new WritableTap(buffer);
+ * await type.write(tap, value);
+ * ```
+ */
+export class CountingWritableTap extends TapBase {
+    /** Creates a new counting tap starting at position 0. */
+    constructor() {
+        super(0);
+    }
+    /** Returns whether the tap is valid (always true for counting tap). */
+    isValid() {
+        return Promise.resolve(true);
+    }
+    /** Counts a boolean value (1 byte). */
+    writeBoolean(_value) {
+        this.pos += 1;
+        return Promise.resolve();
+    }
+    /** Counts an integer value using varint encoding. */
+    writeInt(value) {
+        return this.writeLong(BigInt(value));
+    }
+    /** Counts a long value using zigzag + varint encoding. */
+    writeLong(value) {
+        // Calculate varint size for zigzag-encoded value
+        let n = value < 0n ? ((-value) << 1n) - 1n : value << 1n;
+        let size = 1;
+        while (n >= 0x80n) {
+            size++;
+            n >>= 7n;
+        }
+        this.pos += size;
+        return Promise.resolve();
+    }
+    /** Counts a float value (4 bytes). */
+    writeFloat(_value) {
+        this.pos += 4;
+        return Promise.resolve();
+    }
+    /** Counts a double value (8 bytes). */
+    writeDouble(_value) {
+        this.pos += 8;
+        return Promise.resolve();
+    }
+    /** Counts a fixed-length byte sequence. */
+    writeFixed(buf) {
+        this.pos += buf.length;
+        return Promise.resolve();
+    }
+    /** Counts a length-prefixed byte sequence. */
+    writeBytes(buf) {
+        const len = buf.length;
+        // Length prefix + data
+        return this.writeLong(BigInt(len)).then(() => {
+            this.pos += len;
+        });
+    }
+    /** Counts a length-prefixed UTF-8 string. */
+    writeString(str) {
+        // Calculate UTF-8 byte length
+        const len = utf8ByteLength(str);
+        return this.writeLong(BigInt(len)).then(() => {
+            this.pos += len;
+        });
+    }
+    /** Counts raw binary bytes without length prefix. */
+    writeBinary(_str, len) {
+        if (len > 0)
+            this.pos += len;
+        return Promise.resolve();
+    }
+}

package/esm/serialization/counting_writable_tap_sync.d.ts

@@ -0,0 +1,46 @@
+import { TapBase } from "./tap.js";
+import type { SyncWritableTapLike } from "./tap_sync.js";
+/**
+ * A synchronous writable tap that counts encoded bytes without allocating buffers.
+ *
+ * Used for two-pass serialization where the first pass calculates the
+ * exact buffer size needed, then the second pass writes to a pre-allocated
+ * buffer. This avoids buffer reallocations and copies.
+ *
+ * @example
+ * ```ts
+ * // Pass 1: Calculate size
+ * const countingTap = new SyncCountingWritableTap();
+ * type.writeSync(countingTap, value);
+ * const size = countingTap.getPos();
+ *
+ * // Pass 2: Write to exact-size buffer
+ * const buffer = new ArrayBuffer(size);
+ * const tap = new SyncWritableTap(buffer);
+ * type.writeSync(tap, value);
+ * ```
+ */
+export declare class SyncCountingWritableTap extends TapBase implements SyncWritableTapLike {
+    /** Creates a new counting tap starting at position 0. */
+    constructor();
+    /** Returns whether the tap is valid (always true for counting tap). */
+    isValid(): boolean;
+    /** Counts a boolean value (1 byte). */
+    writeBoolean(_value: boolean): void;
+    /** Counts an integer value using varint encoding. */
+    writeInt(value: number): void;
+    /** Counts a long value using zigzag + varint encoding. */
+    writeLong(value: bigint): void;
+    /** Counts a float value (4 bytes). */
+    writeFloat(_value: number): void;
+    /** Counts a double value (8 bytes). */
+    writeDouble(_value: number): void;
+    /** Counts a fixed-length byte sequence. */
+    writeFixed(buf: Uint8Array): void;
+    /** Counts a length-prefixed byte sequence. */
+    writeBytes(buf: Uint8Array): void;
+    /** Counts a length-prefixed UTF-8 string. */
+    writeString(str: string): void;
+    /** Counts raw binary bytes without length prefix. */
+    writeBinary(_str: string, len: number): void;
+}

package/esm/serialization/counting_writable_tap_sync.js

@@ -0,0 +1,87 @@
+import { TapBase } from "./tap.js";
+import { utf8ByteLength } from "./text_encoding.js";
+/**
+ * A synchronous writable tap that counts encoded bytes without allocating buffers.
+ *
+ * Used for two-pass serialization where the first pass calculates the
+ * exact buffer size needed, then the second pass writes to a pre-allocated
+ * buffer. This avoids buffer reallocations and copies.
+ *
+ * @example
+ * ```ts
+ * // Pass 1: Calculate size
+ * const countingTap = new SyncCountingWritableTap();
+ * type.writeSync(countingTap, value);
+ * const size = countingTap.getPos();
+ *
+ * // Pass 2: Write to exact-size buffer
+ * const buffer = new ArrayBuffer(size);
+ * const tap = new SyncWritableTap(buffer);
+ * type.writeSync(tap, value);
+ * ```
+ */
+export class SyncCountingWritableTap extends TapBase {
+    /** Creates a new counting tap starting at position 0. */
+    constructor() {
+        super(0);
+    }
+    /** Returns whether the tap is valid (always true for counting tap). */
+    isValid() {
+        return true;
+    }
+    /** Counts a boolean value (1 byte). */
+    writeBoolean(_value) {
+        this.pos += 1;
+    }
+    /** Counts an integer value using varint encoding. */
+    writeInt(value) {
+        // Calculate varint size for zigzag-encoded 32-bit int
+        let n = ((value << 1) ^ (value >> 31)) >>> 0;
+        let size = 1;
+        while (n > 0x7f) {
+            size++;
+            n >>>= 7;
+        }
+        this.pos += size;
+    }
+    /** Counts a long value using zigzag + varint encoding. */
+    writeLong(value) {
+        // Calculate varint size for zigzag-encoded value
+        let n = value < 0n ? ((-value) << 1n) - 1n : value << 1n;
+        let size = 1;
+        while (n >= 0x80n) {
+            size++;
+            n >>= 7n;
+        }
+        this.pos += size;
+    }
+    /** Counts a float value (4 bytes). */
+    writeFloat(_value) {
+        this.pos += 4;
+    }
+    /** Counts a double value (8 bytes). */
+    writeDouble(_value) {
+        this.pos += 8;
+    }
+    /** Counts a fixed-length byte sequence. */
+    writeFixed(buf) {
+        this.pos += buf.length;
+    }
+    /** Counts a length-prefixed byte sequence. */
+    writeBytes(buf) {
+        const len = buf.length;
+        this.writeLong(BigInt(len));
+        this.pos += len;
+    }
+    /** Counts a length-prefixed UTF-8 string. */
+    writeString(str) {
+        const len = utf8ByteLength(str);
+        this.writeLong(BigInt(len));
+        this.pos += len;
+    }
+    /** Counts raw binary bytes without length prefix. */
+    writeBinary(_str, len) {
+        if (len > 0)
+            this.pos += len;
+    }
+}

package/esm/serialization/decoders/decoder_null_sync.d.ts

@@ -0,0 +1,12 @@
+import type { SyncDecoder } from "./decoder_sync.js";
+/**
+ * Built-in sync null decoder that returns data unchanged.
+ */
+export declare class NullDecoderSync implements SyncDecoder {
+    /**
+     * Decodes data by returning the same buffer.
+     * @param compressedData The input data.
+     * @returns The same data buffer.
+     */
+    decode(compressedData: Uint8Array): Uint8Array;
+}

package/esm/serialization/decoders/decoder_null_sync.js

@@ -0,0 +1,13 @@
+/**
+ * Built-in sync null decoder that returns data unchanged.
+ */
+export class NullDecoderSync {
+    /**
+     * Decodes data by returning the same buffer.
+     * @param compressedData The input data.
+     * @returns The same data buffer.
+     */
+    decode(compressedData) {
+        return compressedData;
+    }
+}

package/esm/serialization/decoders/decoder_sync.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Interface for custom synchronous Avro codec decoders.
+ */
+export interface SyncDecoder {
+    /**
+     * Decompresses the compressed block synchronously.
+     * @param compressedData The compressed block data.
+     * @returns The decompressed bytes.
+     */
+    decode(compressedData: Uint8Array): Uint8Array;
+}
+/**
+ * Registry mapping codec names to synchronous decoder implementations.
+ */
+export type SyncDecoderRegistry = Record<string, SyncDecoder>;

package/esm/serialization/decoders/decoder_sync.js

@@ -0,0 +1 @@
+export {};

package/esm/serialization/encoders/encoder_null_sync.d.ts

@@ -0,0 +1,12 @@
+import type { SyncEncoder } from "./encoder_sync.js";
+/**
+ * Built-in sync null encoder (no compression).
+ */
+export declare class NullEncoderSync implements SyncEncoder {
+    /**
+     * Encodes data by returning the buffer unchanged.
+     * @param uncompressedData The data to encode.
+     * @returns The same data buffer.
+     */
+    encode(uncompressedData: Uint8Array): Uint8Array;
+}

package/esm/serialization/encoders/encoder_null_sync.js

@@ -0,0 +1,13 @@
+/**
+ * Built-in sync null encoder (no compression).
+ */
+export class NullEncoderSync {
+    /**
+     * Encodes data by returning the buffer unchanged.
+     * @param uncompressedData The data to encode.
+     * @returns The same data buffer.
+     */
+    encode(uncompressedData) {
+        return uncompressedData;
+    }
+}

package/esm/serialization/encoders/encoder_sync.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Interface for custom synchronous Avro codec encoders.
+ */
+export interface SyncEncoder {
+    /**
+     * Compresses the data synchronously using the codec's algorithm.
+     * @param uncompressedData Raw block data to compress.
+     * @returns The compressed result.
+     */
+    encode(uncompressedData: Uint8Array): Uint8Array;
+}
+/**
+ * Registry of codec names to sync encoder implementations.
+ */
+export type SyncEncoderRegistry = Record<string, SyncEncoder>;

package/esm/serialization/encoders/encoder_sync.js

@@ -0,0 +1 @@
+export {};

package/esm/serialization/streams/fixed_size_stream_readable_buffer_adapter.d.ts

@@ -40,9 +40,10 @@ export declare class FixedSizeStreamReadableBufferAdapter implements IReadableBu
      *
      * @param offset The byte offset to start reading from (0-based, stream-relative)
      * @param size The number of bytes to read
-     * @returns A Promise that resolves to a new Uint8Array containing the read bytes, or undefined if the read would exceed buffer bounds
+     * @returns A Promise that resolves to a new Uint8Array containing the read bytes.
+     * @throws ReadBufferError if the requested range is out of bounds.
      */
-    read(offset: number, size: number): Promise<Uint8Array | undefined>;
+    read(offset: number, size: number): Promise<Uint8Array>;
     /**
      * Checks if more data can be read starting at the given offset.
      * @param offset The byte offset to check.

package/esm/serialization/streams/fixed_size_stream_readable_buffer_adapter.js

@@ -10,6 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _FixedSizeStreamReadableBufferAdapter_instances, _FixedSizeStreamReadableBufferAdapter_streamBuffer, _FixedSizeStreamReadableBufferAdapter_windowSize, _FixedSizeStreamReadableBufferAdapter_circularBuffer, _FixedSizeStreamReadableBufferAdapter_eof, _FixedSizeStreamReadableBufferAdapter_extractFromBuffer, _FixedSizeStreamReadableBufferAdapter_fillBuffer;
+import { ReadBufferError } from "../buffers/buffer_error.js";
 import { CircularBuffer } from "../../internal/collections/circular_buffer.js";
 /**
  * A limited buffer adapter that maintains a rolling window of stream data.
@@ -65,19 +66,20 @@ export class FixedSizeStreamReadableBufferAdapter {
      *
      * @param offset The byte offset to start reading from (0-based, stream-relative)
      * @param size The number of bytes to read
-     * @returns A Promise that resolves to a new Uint8Array containing the read bytes, or undefined if the read would exceed buffer bounds
+     * @returns A Promise that resolves to a new Uint8Array containing the read bytes.
+     * @throws ReadBufferError if the requested range is out of bounds.
      */
     async read(offset, size) {
         if (offset < 0 || size < 0) {
-            return undefined;
+            throw new ReadBufferError(`Offset and size must be non-negative. Got offset=${offset}, size=${size}`, offset, size, __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_circularBuffer, "f").windowEnd());
         }
         // Check if requested size exceeds window size - throw error immediately
         if (size > __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_windowSize, "f")) {
-            throw new RangeError(`Requested size ${size} exceeds window size ${__classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_windowSize, "f")}`);
+            throw new ReadBufferError(`Requested size ${size} exceeds window size ${__classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_windowSize, "f")}`, offset, size, __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_windowSize, "f"));
         }
         // Check if offset is before the current window start - raise error
         if (offset < __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_circularBuffer, "f").windowStart()) {
-            throw new RangeError(`Cannot read data before window start. Offset ${offset} is before window start ${__classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_circularBuffer, "f").windowStart()}`);
+            throw new ReadBufferError(`Cannot read data before window start. Offset ${offset} is before window start ${__classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_circularBuffer, "f").windowStart()}`, offset, size, __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_circularBuffer, "f").windowEnd());
         }
         // Check if data is already in cache
         if (offset + size <= __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_circularBuffer, "f").windowEnd()) {
@@ -88,7 +90,7 @@ export class FixedSizeStreamReadableBufferAdapter {
         await __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_instances, "m", _FixedSizeStreamReadableBufferAdapter_fillBuffer).call(this, offset + size);
         // Check if the requested range is available after filling
         if (offset + size > __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_circularBuffer, "f").windowEnd()) {
-            return undefined;
+            throw new ReadBufferError(`Operation exceeds buffer bounds. offset=${offset}, size=${size}, bufferLength=${__classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_circularBuffer, "f").windowEnd()}`, offset, size, __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_circularBuffer, "f").windowEnd());
         }
         // Extract data from buffer
         return __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_instances, "m", _FixedSizeStreamReadableBufferAdapter_extractFromBuffer).call(this, offset, size);
@@ -99,8 +101,16 @@ export class FixedSizeStreamReadableBufferAdapter {
      * @returns True if at least one byte can be read from the offset.
      */
     async canReadMore(offset) {
-        const result = await this.read(offset, 1);
-        return result !== undefined;
+        try {
+            await this.read(offset, 1);
+            return true;
+        }
+        catch (err) {
+            if (err instanceof ReadBufferError) {
+                return false;
+            }
+            throw err;
+        }
     }
 }
 _FixedSizeStreamReadableBufferAdapter_streamBuffer = new WeakMap(), _FixedSizeStreamReadableBufferAdapter_windowSize = new WeakMap(), _FixedSizeStreamReadableBufferAdapter_circularBuffer = new WeakMap(), _FixedSizeStreamReadableBufferAdapter_eof = new WeakMap(), _FixedSizeStreamReadableBufferAdapter_instances = new WeakSet(), _FixedSizeStreamReadableBufferAdapter_extractFromBuffer = function _FixedSizeStreamReadableBufferAdapter_extractFromBuffer(offset, size) {
@@ -120,8 +130,8 @@ async function _FixedSizeStreamReadableBufferAdapter_fillBuffer(targetOffset) {
             __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_circularBuffer, "f").push(chunk);
         }
         catch (error) {
-            if (error instanceof RangeError) {
-                throw new RangeError(`Cannot buffer chunk of size ${chunk.length}: ${error.message}`);
+            if (error instanceof ReadBufferError) {
+                throw new ReadBufferError(`Cannot buffer chunk of size ${chunk.length}: ${error.message}`, __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_circularBuffer, "f").windowEnd(), chunk.length, __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_windowSize, "f"));
             }
             throw error;
         }

package/esm/serialization/streams/fixed_size_stream_reader_sync.d.ts

@@ -0,0 +1,25 @@
+import type { ISyncStreamReadableBuffer } from "./streams_sync.js";
+/**
+ * Simple synchronous stream reader backed by a fixed-size Uint8Array.
+ * Data is delivered sequentially in fixed-size chunks until the buffer is exhausted.
+ */
+export declare class SyncFixedSizeStreamReader implements ISyncStreamReadableBuffer {
+    #private;
+    /**
+     * Creates a new fixed-size reader.
+     *
+     * @param source The source data to read from.
+     * @param chunkSize The maximum chunk size to return per readNext call.
+     */
+    constructor(source: Uint8Array, chunkSize: number);
+    /**
+     * Reads the next chunk of data from the underlying source.
+     *
+     * @returns The next Uint8Array chunk, or undefined if the stream is exhausted or closed.
+     */
+    readNext(): Uint8Array | undefined;
+    /**
+     * Closes the reader and prevents further reads.
+     */
+    close(): void;
+}

package/esm/serialization/streams/fixed_size_stream_reader_sync.js

@@ -0,0 +1,63 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SyncFixedSizeStreamReader_source, _SyncFixedSizeStreamReader_chunkSize, _SyncFixedSizeStreamReader_offset, _SyncFixedSizeStreamReader_isClosed;
+/**
+ * Simple synchronous stream reader backed by a fixed-size Uint8Array.
+ * Data is delivered sequentially in fixed-size chunks until the buffer is exhausted.
+ */
+export class SyncFixedSizeStreamReader {
+    /**
+     * Creates a new fixed-size reader.
+     *
+     * @param source The source data to read from.
+     * @param chunkSize The maximum chunk size to return per readNext call.
+     */
+    constructor(source, chunkSize) {
+        _SyncFixedSizeStreamReader_source.set(this, void 0);
+        _SyncFixedSizeStreamReader_chunkSize.set(this, void 0);
+        _SyncFixedSizeStreamReader_offset.set(this, 0);
+        _SyncFixedSizeStreamReader_isClosed.set(this, false);
+        if (chunkSize <= 0) {
+            throw new RangeError("chunkSize must be positive");
+        }
+        __classPrivateFieldSet(this, _SyncFixedSizeStreamReader_source, source, "f");
+        __classPrivateFieldSet(this, _SyncFixedSizeStreamReader_chunkSize, chunkSize, "f");
+    }
+    /**
+     * Reads the next chunk of data from the underlying source.
+     *
+     * @returns The next Uint8Array chunk, or undefined if the stream is exhausted or closed.
+     */
+    readNext() {
+        if (__classPrivateFieldGet(this, _SyncFixedSizeStreamReader_isClosed, "f") || __classPrivateFieldGet(this, _SyncFixedSizeStreamReader_offset, "f") >= __classPrivateFieldGet(this, _SyncFixedSizeStreamReader_source, "f").length) {
+            return undefined;
+        }
+        const remaining = __classPrivateFieldGet(this, _SyncFixedSizeStreamReader_source, "f").length - __classPrivateFieldGet(this, _SyncFixedSizeStreamReader_offset, "f");
+        const size = Math.min(__classPrivateFieldGet(this, _SyncFixedSizeStreamReader_chunkSize, "f"), remaining);
+        const chunk = __classPrivateFieldGet(this, _SyncFixedSizeStreamReader_source, "f").slice(__classPrivateFieldGet(this, _SyncFixedSizeStreamReader_offset, "f"), __classPrivateFieldGet(this, _SyncFixedSizeStreamReader_offset, "f") + size);
+        __classPrivateFieldSet(this, _SyncFixedSizeStreamReader_offset, __classPrivateFieldGet(this, _SyncFixedSizeStreamReader_offset, "f") + size, "f");
+        return chunk;
+    }
+    /**
+     * Closes the reader and prevents further reads.
+     */
+    close() {
+        __classPrivateFieldSet(this, _SyncFixedSizeStreamReader_isClosed, true, "f");
+    }
+    /**
+     * @internal test helper exposing the current read offset.
+     */
+    _testOnlyOffset() {
+        return __classPrivateFieldGet(this, _SyncFixedSizeStreamReader_offset, "f");
+    }
+}
+_SyncFixedSizeStreamReader_source = new WeakMap(), _SyncFixedSizeStreamReader_chunkSize = new WeakMap(), _SyncFixedSizeStreamReader_offset = new WeakMap(), _SyncFixedSizeStreamReader_isClosed = new WeakMap();

package/esm/serialization/streams/fixed_size_stream_writer_sync.d.ts

@@ -0,0 +1,45 @@
+import type { ISyncStreamWritableBuffer } from "./streams_sync.js";
+/**
+ * Simple synchronous stream writer backed by a fixed-size Uint8Array.
+ * Writes append sequentially until the buffer reaches capacity.
+ */
+export declare class SyncFixedSizeStreamWriter implements ISyncStreamWritableBuffer {
+    #private;
+    /**
+     * Creates a new fixed-size writer.
+     *
+     * @param target The target buffer to write into.
+     */
+    constructor(target: Uint8Array);
+    /**
+     * Writes bytes to the underlying target buffer.
+     *
+     * @param data The bytes to write.
+     * @throws WriteBufferError If the write would exceed the buffer capacity.
+     * @throws Error If the writer has been closed.
+     */
+    writeBytes(data: Uint8Array): void;
+    /**
+     * Writes a slice of bytes to the underlying target buffer.
+     *
+     * @param data The source bytes.
+     * @param offset The starting offset in data.
+     * @param length The number of bytes to write.
+     * @throws RangeError If the source range parameters are invalid.
+     * @throws WriteBufferError If the write would exceed the buffer capacity.
+     * @throws Error If the writer has been closed.
+     */
+    writeBytesFrom(data: Uint8Array, offset: number, length: number): void;
+    /**
+     * Closes the writer and prevents further writes.
+     */
+    close(): void;
+    /**
+     * Returns a copy of the bytes written to the underlying target buffer.
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Returns the remaining capacity of the writer.
+     */
+    remaining(): number;
+}

package/esm/serialization/streams/fixed_size_stream_writer_sync.js

@@ -0,0 +1,98 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SyncFixedSizeStreamWriter_target, _SyncFixedSizeStreamWriter_offset, _SyncFixedSizeStreamWriter_isClosed;
+import { WriteBufferError } from "../buffers/buffer_sync.js";
+/**
+ * Simple synchronous stream writer backed by a fixed-size Uint8Array.
+ * Writes append sequentially until the buffer reaches capacity.
+ */
+export class SyncFixedSizeStreamWriter {
+    /**
+     * Creates a new fixed-size writer.
+     *
+     * @param target The target buffer to write into.
+     */
+    constructor(target) {
+        _SyncFixedSizeStreamWriter_target.set(this, void 0);
+        _SyncFixedSizeStreamWriter_offset.set(this, 0);
+        _SyncFixedSizeStreamWriter_isClosed.set(this, false);
+        __classPrivateFieldSet(this, _SyncFixedSizeStreamWriter_target, target, "f");
+    }
+    /**
+     * Writes bytes to the underlying target buffer.
+     *
+     * @param data The bytes to write.
+     * @throws WriteBufferError If the write would exceed the buffer capacity.
+     * @throws Error If the writer has been closed.
+     */
+    writeBytes(data) {
+        if (__classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_isClosed, "f")) {
+            throw new Error("Cannot write to a closed writer");
+        }
+        if (data.length === 0) {
+            return;
+        }
+        if (__classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_offset, "f") + data.length > __classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_target, "f").length) {
+            throw new WriteBufferError("Write operation exceeds buffer capacity", __classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_offset, "f"), data.length, __classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_target, "f").length);
+        }
+        __classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_target, "f").set(data, __classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_offset, "f"));
+        __classPrivateFieldSet(this, _SyncFixedSizeStreamWriter_offset, __classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_offset, "f") + data.length, "f");
+    }
+    /**
+     * Writes a slice of bytes to the underlying target buffer.
+     *
+     * @param data The source bytes.
+     * @param offset The starting offset in data.
+     * @param length The number of bytes to write.
+     * @throws RangeError If the source range parameters are invalid.
+     * @throws WriteBufferError If the write would exceed the buffer capacity.
+     * @throws Error If the writer has been closed.
+     */
+    writeBytesFrom(data, offset, length) {
+        if (__classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_isClosed, "f")) {
+            throw new Error("Cannot write to a closed writer");
+        }
+        if (length === 0) {
+            return;
+        }
+        if (!Number.isInteger(offset) || !Number.isInteger(length) ||
+            offset < 0 || length < 0 || offset + length > data.length) {
+            throw new RangeError(`Invalid source range offset=${offset} length=${length} for dataSize=${data.length}`);
+        }
+        if (__classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_offset, "f") + length > __classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_target, "f").length) {
+            throw new WriteBufferError("Write operation exceeds buffer capacity", __classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_offset, "f"), length, __classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_target, "f").length);
+        }
+        for (let i = 0; i < length; i++) {
+            __classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_target, "f")[__classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_offset, "f") + i] = data[offset + i];
+        }
+        __classPrivateFieldSet(this, _SyncFixedSizeStreamWriter_offset, __classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_offset, "f") + length, "f");
+    }
+    /**
+     * Closes the writer and prevents further writes.
+     */
+    close() {
+        __classPrivateFieldSet(this, _SyncFixedSizeStreamWriter_isClosed, true, "f");
+    }
+    /**
+     * Returns a copy of the bytes written to the underlying target buffer.
+     */
+    toUint8Array() {
+        return __classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_target, "f").slice(0, __classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_offset, "f"));
+    }
+    /**
+     * Returns the remaining capacity of the writer.
+     */
+    remaining() {
+        return __classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_target, "f").length - __classPrivateFieldGet(this, _SyncFixedSizeStreamWriter_offset, "f");
+    }
+}
+_SyncFixedSizeStreamWriter_target = new WeakMap(), _SyncFixedSizeStreamWriter_offset = new WeakMap(), _SyncFixedSizeStreamWriter_isClosed = new WeakMap();