@sachitv/avro-typescript 0.4.2 → 0.5.0

package/esm/serialization/buffers/buffer.js

@@ -1 +1,4 @@
+/**
+ * Interface describing a random-access readable buffer.
+ */
 export {};

package/esm/serialization/buffers/buffer_error.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared error types for buffer implementations.
+ *
+ * These errors are shared between the async and sync buffer implementations so
+ * that callers can rely on consistent error shapes.
+ */
+/** Error thrown when a readable buffer operation fails. */
+export declare class ReadBufferError extends Error {
+    /** The offset where the read operation failed. */
+    readonly offset: number;
+    /** The size requested for the read operation. */
+    readonly size: number;
+    /** The total buffer length (or best-effort upper bound). */
+    readonly bufferLength: number;
+    /** Creates a new ReadBufferError. */
+    constructor(message: string, offset: number, size: number, bufferLength: number);
+}
+/** Error thrown when a writable buffer operation fails. */
+export declare class WriteBufferError extends Error {
+    /** The offset where the write operation failed. */
+    readonly offset: number;
+    /** The size of data being written. */
+    readonly dataSize: number;
+    /** The total buffer length (or best-effort upper bound). */
+    readonly bufferLength: number;
+    /** Creates a new WriteBufferError. */
+    constructor(message: string, offset: number, dataSize: number, bufferLength: number);
+}

package/esm/serialization/buffers/buffer_error.js

@@ -0,0 +1,70 @@
+/**
+ * Shared error types for buffer implementations.
+ *
+ * These errors are shared between the async and sync buffer implementations so
+ * that callers can rely on consistent error shapes.
+ */
+/** Error thrown when a readable buffer operation fails. */
+export class ReadBufferError extends Error {
+    /** Creates a new ReadBufferError. */
+    constructor(message, offset, size, bufferLength) {
+        super(message);
+        /** The offset where the read operation failed. */
+        Object.defineProperty(this, "offset", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The size requested for the read operation. */
+        Object.defineProperty(this, "size", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The total buffer length (or best-effort upper bound). */
+        Object.defineProperty(this, "bufferLength", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "ReadBufferError";
+        this.offset = offset;
+        this.size = size;
+        this.bufferLength = bufferLength;
+    }
+}
+/** Error thrown when a writable buffer operation fails. */
+export class WriteBufferError extends Error {
+    /** Creates a new WriteBufferError. */
+    constructor(message, offset, dataSize, bufferLength) {
+        super(message);
+        /** The offset where the write operation failed. */
+        Object.defineProperty(this, "offset", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The size of data being written. */
+        Object.defineProperty(this, "dataSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The total buffer length (or best-effort upper bound). */
+        Object.defineProperty(this, "bufferLength", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "WriteBufferError";
+        this.offset = offset;
+        this.dataSize = dataSize;
+        this.bufferLength = bufferLength;
+    }
+}

package/esm/serialization/buffers/buffer_sync.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Synchronous interfaces for readable and writable buffers.
+ */
+export { ReadBufferError, WriteBufferError } from "./buffer_error.js";
+/**
+ * Interface describing a random-access readable buffer (synchronous).
+ */
+export interface ISyncReadable {
+    /**
+     * Reads a portion of the buffer starting at offset with the given size.
+     *
+     * @throws ReadBufferError when the requested range is invalid or exceeds the
+     * available bounds.
+     */
+    read(offset: number, size: number): Uint8Array;
+    /**
+     * Checks if more data can be read starting at the given offset.
+     */
+    canReadMore(offset: number): boolean;
+}
+/**
+ * Interface describing an append-only writable buffer (synchronous).
+ */
+export interface ISyncWritable {
+    /**
+     * Appends bytes to the buffer, advancing its internal write cursor when the
+     * operation succeeds.
+     *
+     * @throws WriteBufferError when the buffer cannot accept the requested bytes.
+     */
+    appendBytes(data: Uint8Array): void;
+    /**
+     * Appends a slice of bytes to the buffer without requiring callers to create
+     * a subarray view.
+     */
+    appendBytesFrom(data: Uint8Array, offset: number, length: number): void;
+    /**
+     * Returns whether the buffer can continue accepting writes. Implementations
+     * should flip this to `false` after a write would exceed capacity so callers
+     * can detect the overflow condition.
+     */
+    isValid(): boolean;
+    /**
+     * Checks if the buffer can accept appending the given number of bytes.
+     */
+    canAppendMore(size: number): boolean;
+}
+/**
+ * Convenience type for buffers capable of both read and write operations.
+ */
+export type ISyncReadableAndWritable = ISyncReadable & ISyncWritable;

package/esm/serialization/buffers/buffer_sync.js

@@ -0,0 +1,4 @@
+/**
+ * Synchronous interfaces for readable and writable buffers.
+ */
+export { ReadBufferError, WriteBufferError } from "./buffer_error.js";

package/esm/serialization/buffers/in_memory_buffer.d.ts

@@ -87,6 +87,7 @@ export declare class InMemoryWritableBuffer extends InMemoryBufferBase implement
      * Creates a new writable buffer with the specified ArrayBuffer and initial offset.
      * @param buf The underlying ArrayBuffer to write to.
      * @param offset The starting offset within the buffer (default: 0).
+     * @throws WriteBufferError If the initial offset is invalid.
      */
     constructor(buf: ArrayBuffer, offset?: number);
     /**

package/esm/serialization/buffers/in_memory_buffer.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 _InMemoryWritableBuffer_offset, _InMemoryWritableBuffer_initialOffset;
+import { ReadBufferError, WriteBufferError } from "./buffer_error.js";
 /**
  * Shared strict in-memory buffer base with common functionality.
  */
@@ -67,10 +68,10 @@ export class InMemoryReadableBuffer extends InMemoryBufferBase {
      */
     checkBounds(offset, size) {
         if (offset < 0 || size < 0) {
-            throw new RangeError(`Offset and size must be non-negative. Got offset=${offset}, size=${size}`);
+            throw new ReadBufferError(`Offset and size must be non-negative. Got offset=${offset}, size=${size}`, offset, size, this.view.length);
         }
         if (offset + size > this.view.length) {
-            throw new RangeError(`Operation exceeds buffer bounds. offset=${offset}, size=${size}, bufferLength=${this.view.length}`);
+            throw new ReadBufferError(`Operation exceeds buffer bounds. offset=${offset}, size=${size}, bufferLength=${this.view.length}`, offset, size, this.view.length);
         }
     }
     /**
@@ -127,13 +128,14 @@ export class InMemoryWritableBuffer extends InMemoryBufferBase {
      * Creates a new writable buffer with the specified ArrayBuffer and initial offset.
      * @param buf The underlying ArrayBuffer to write to.
      * @param offset The starting offset within the buffer (default: 0).
+     * @throws WriteBufferError If the initial offset is invalid.
      */
     constructor(buf, offset = 0) {
         super(buf);
         _InMemoryWritableBuffer_offset.set(this, void 0);
         _InMemoryWritableBuffer_initialOffset.set(this, void 0);
         if (offset < 0 || offset > this.view.length) {
-            throw new RangeError(`Initial offset must be within buffer bounds. Got offset=${offset}, bufferLength=${this.view.length}`);
+            throw new WriteBufferError(`Initial offset must be within buffer bounds. Got offset=${offset}, bufferLength=${this.view.length}`, offset, 0, this.view.length);
         }
         __classPrivateFieldSet(this, _InMemoryWritableBuffer_initialOffset, offset, "f");
         __classPrivateFieldSet(this, _InMemoryWritableBuffer_offset, offset, "f");
@@ -146,10 +148,10 @@ export class InMemoryWritableBuffer extends InMemoryBufferBase {
      */
     checkWriteBounds(offset, data) {
         if (offset < 0) {
-            throw new RangeError(`Offset must be non-negative. Got offset=${offset}`);
+            throw new WriteBufferError(`Offset must be non-negative. Got offset=${offset}`, offset, data.length, this.view.length);
         }
         if (offset + data.length > this.view.length) {
-            throw new RangeError(`Write operation exceeds buffer bounds. offset=${offset}, dataSize=${data.length}, bufferLength=${this.view.length}`);
+            throw new WriteBufferError(`Write operation exceeds buffer bounds. offset=${offset}, dataSize=${data.length}, bufferLength=${this.view.length}`, offset, data.length, this.view.length);
         }
     }
     /**

package/esm/serialization/buffers/in_memory_buffer_sync.d.ts

@@ -0,0 +1,133 @@
+import type { ISyncReadable, ISyncWritable } from "./buffer_sync.js";
+/**
+ * Shared strict in-memory buffer base with common functionality.
+ */
+export declare abstract class SyncInMemoryBufferBase {
+    /** The underlying Uint8Array view of the buffer. */
+    protected readonly view: Uint8Array;
+    /**
+     * Constructs a SyncInMemoryBufferBase with the given ArrayBuffer.
+     * @param buf The ArrayBuffer to create the view from.
+     */
+    constructor(buf: ArrayBuffer);
+    /**
+     * Returns the length of the buffer in bytes.
+     * @returns The length of the buffer.
+     */
+    length(): number;
+}
+/**
+ * Strict read-only in-memory buffer for serialization reads (synchronous).
+ * Throws errors on all out-of-bounds operations.
+ *
+ * Key features:
+ * - Fixed size: The buffer size is determined at construction and cannot be resized.
+ * - Random access: Supports reading at arbitrary byte offsets.
+ * - Strict bounds checking: Operations that exceed buffer bounds throw ReadBufferError.
+ * - Efficient: Uses Uint8Array for fast byte-level operations.
+ *
+ * @example
+ * ```typescript
+ * const arrayBuffer = new ArrayBuffer(1024);
+ * const buffer = new SyncInMemoryReadableBuffer(arrayBuffer);
+ *
+ * // Read some data
+ * const data = buffer.read(0, 4); // Returns Uint8Array of 4 bytes
+ *
+ * // This will throw:
+ * buffer.read(1020, 10); // ReadBufferError: Operation exceeds buffer bounds
+ * ```
+ */
+export declare class SyncInMemoryReadableBuffer extends SyncInMemoryBufferBase implements ISyncReadable {
+    /**
+     * Checks if the offset and size are within buffer bounds.
+     * @param offset The starting offset.
+     * @param size The number of bytes to check.
+     */
+    private checkBounds;
+    /**
+     * Reads a portion of the buffer.
+     * @param offset The starting offset.
+     * @param size The number of bytes to read.
+     * @returns A Uint8Array containing the read bytes.
+     */
+    read(offset: number, size: number): Uint8Array;
+    /**
+     * Checks if more data can be read starting at the given offset.
+     * @param offset The byte offset to check.
+     * @returns True if at least one byte can be read from the offset.
+     */
+    canReadMore(offset: number): boolean;
+}
+/**
+ * Strict write-only in-memory buffer for serialization writes (synchronous).
+ * Throws errors when attempting to write beyond buffer bounds.
+ *
+ * Key features:
+ * - Fixed size: The buffer size is determined at construction and cannot be resized.
+ * - Sequential writes: Maintains an internal offset that advances with each write.
+ * - Strict bounds checking: Throws WriteBufferError when write would exceed buffer capacity.
+ * - Efficient: Uses Uint8Array for fast byte-level operations.
+ *
+ * @example
+ * ```typescript
+ * const arrayBuffer = new ArrayBuffer(1024);
+ * const buffer = new SyncInMemoryWritableBuffer(arrayBuffer);
+ *
+ * // Write some data
+ * buffer.appendBytes(new Uint8Array([1, 2, 3, 4]));
+ *
+ * // This will throw if buffer is full:
+ * buffer.appendBytes(new Uint8Array(2000)); // WriteBufferError: Write operation exceeds buffer bounds
+ * ```
+ */
+export declare class SyncInMemoryWritableBuffer extends SyncInMemoryBufferBase implements ISyncWritable {
+    #private;
+    /**
+     * Creates a new writable buffer with the specified ArrayBuffer and initial offset.
+     * @param buf The underlying ArrayBuffer to write to.
+     * @param offset The starting offset within the buffer (default: 0).
+     */
+    constructor(buf: ArrayBuffer, offset?: number);
+    /**
+     * Checks if writing the given data at the specified offset would exceed buffer bounds.
+     * Throws a WriteBufferError if the operation would exceed bounds.
+     * @param offset The offset to write at.
+     * @param data The data to write.
+     */
+    protected checkWriteBounds(offset: number, data: Uint8Array): void;
+    /**
+     * Checks if writing the given number of bytes at the specified offset would exceed buffer bounds.
+     * Throws a WriteBufferError if the operation would exceed bounds.
+     * @param offset The offset to write at.
+     * @param size The number of bytes to write.
+     */
+    protected checkWriteBoundsSize(offset: number, size: number): void;
+    /**
+     * Appends the given bytes to the buffer at the current offset and advances the offset.
+     * @param data The bytes to append.
+     */
+    appendBytes(data: Uint8Array): void;
+    /**
+     * Appends a slice of bytes to the buffer at the current offset and advances the offset.
+     * This avoids allocating subarray views in higher-level hot paths.
+     */
+    appendBytesFrom(data: Uint8Array, offset: number, length: number): void;
+    /**
+     * Checks if the buffer is in a valid state.
+     * Always returns true as this buffer throws on overflow instead of becoming invalid.
+     * @returns Always true.
+     */
+    isValid(): boolean;
+    /**
+     * Checks if the buffer can accept appending the given number of bytes.
+     * @param size The number of bytes to check.
+     * @returns True if the buffer can accept the append.
+     */
+    canAppendMore(_size: number): boolean;
+    /**
+     * Gets a copy of the buffer containing only the bytes written to the buffer.
+     * @returns An ArrayBuffer containing only the written data.
+     */
+    getBufferCopy(): ArrayBuffer;
+}

package/esm/serialization/buffers/in_memory_buffer_sync.js

@@ -0,0 +1,259 @@
+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 _SyncInMemoryWritableBuffer_offset, _SyncInMemoryWritableBuffer_initialOffset;
+import { ReadBufferError, WriteBufferError } from "./buffer_sync.js";
+/**
+ * Shared strict in-memory buffer base with common functionality.
+ */
+export class SyncInMemoryBufferBase {
+    /**
+     * Constructs a SyncInMemoryBufferBase with the given ArrayBuffer.
+     * @param buf The ArrayBuffer to create the view from.
+     */
+    constructor(buf) {
+        /** The underlying Uint8Array view of the buffer. */
+        Object.defineProperty(this, "view", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.view = new Uint8Array(buf);
+    }
+    /**
+     * Returns the length of the buffer in bytes.
+     * @returns The length of the buffer.
+     */
+    length() {
+        return this.view.length;
+    }
+    /**
+     * @internal Test-only function to get the underlying ArrayBuffer.
+     */
+    _testOnlyBuffer() {
+        return this.view.buffer;
+    }
+}
+/**
+ * Strict read-only in-memory buffer for serialization reads (synchronous).
+ * Throws errors on all out-of-bounds operations.
+ *
+ * Key features:
+ * - Fixed size: The buffer size is determined at construction and cannot be resized.
+ * - Random access: Supports reading at arbitrary byte offsets.
+ * - Strict bounds checking: Operations that exceed buffer bounds throw ReadBufferError.
+ * - Efficient: Uses Uint8Array for fast byte-level operations.
+ *
+ * @example
+ * ```typescript
+ * const arrayBuffer = new ArrayBuffer(1024);
+ * const buffer = new SyncInMemoryReadableBuffer(arrayBuffer);
+ *
+ * // Read some data
+ * const data = buffer.read(0, 4); // Returns Uint8Array of 4 bytes
+ *
+ * // This will throw:
+ * buffer.read(1020, 10); // ReadBufferError: Operation exceeds buffer bounds
+ * ```
+ */
+export class SyncInMemoryReadableBuffer extends SyncInMemoryBufferBase {
+    /**
+     * Checks if the offset and size are within buffer bounds.
+     * @param offset The starting offset.
+     * @param size The number of bytes to check.
+     */
+    checkBounds(offset, size) {
+        if (offset < 0 || size < 0) {
+            throw new ReadBufferError(`Offset and size must be non-negative. Got offset=${offset}, size=${size}`, offset, size, this.view.length);
+        }
+        if (offset + size > this.view.length) {
+            throw new ReadBufferError(`Operation exceeds buffer bounds. offset=${offset}, size=${size}, bufferLength=${this.view.length}`, offset, size, this.view.length);
+        }
+    }
+    /**
+     * Reads a portion of the buffer.
+     * @param offset The starting offset.
+     * @param size The number of bytes to read.
+     * @returns A Uint8Array containing the read bytes.
+     */
+    read(offset, size) {
+        this.checkBounds(offset, size);
+        return this.view.slice(offset, offset + size);
+    }
+    /**
+     * Checks if more data can be read starting at the given offset.
+     * @param offset The byte offset to check.
+     * @returns True if at least one byte can be read from the offset.
+     */
+    canReadMore(offset) {
+        try {
+            this.checkBounds(offset, 1);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * @internal Test-only function to get the underlying ArrayBuffer.
+     */
+    _testOnlyBuffer() {
+        return this.view.buffer;
+    }
+}
+/**
+ * Strict write-only in-memory buffer for serialization writes (synchronous).
+ * Throws errors when attempting to write beyond buffer bounds.
+ *
+ * Key features:
+ * - Fixed size: The buffer size is determined at construction and cannot be resized.
+ * - Sequential writes: Maintains an internal offset that advances with each write.
+ * - Strict bounds checking: Throws WriteBufferError when write would exceed buffer capacity.
+ * - Efficient: Uses Uint8Array for fast byte-level operations.
+ *
+ * @example
+ * ```typescript
+ * const arrayBuffer = new ArrayBuffer(1024);
+ * const buffer = new SyncInMemoryWritableBuffer(arrayBuffer);
+ *
+ * // Write some data
+ * buffer.appendBytes(new Uint8Array([1, 2, 3, 4]));
+ *
+ * // This will throw if buffer is full:
+ * buffer.appendBytes(new Uint8Array(2000)); // WriteBufferError: Write operation exceeds buffer bounds
+ * ```
+ */
+export class SyncInMemoryWritableBuffer extends SyncInMemoryBufferBase {
+    /**
+     * Creates a new writable buffer with the specified ArrayBuffer and initial offset.
+     * @param buf The underlying ArrayBuffer to write to.
+     * @param offset The starting offset within the buffer (default: 0).
+     */
+    constructor(buf, offset = 0) {
+        super(buf);
+        _SyncInMemoryWritableBuffer_offset.set(this, void 0);
+        _SyncInMemoryWritableBuffer_initialOffset.set(this, void 0);
+        if (offset < 0 || offset > this.view.length) {
+            throw new WriteBufferError(`Initial offset must be within buffer bounds. Got offset=${offset}, bufferLength=${this.view.length}`, offset, 0, this.view.length);
+        }
+        __classPrivateFieldSet(this, _SyncInMemoryWritableBuffer_initialOffset, offset, "f");
+        __classPrivateFieldSet(this, _SyncInMemoryWritableBuffer_offset, offset, "f");
+    }
+    /**
+     * Checks if writing the given data at the specified offset would exceed buffer bounds.
+     * Throws a WriteBufferError if the operation would exceed bounds.
+     * @param offset The offset to write at.
+     * @param data The data to write.
+     */
+    checkWriteBounds(offset, data) {
+        this.checkWriteBoundsSize(offset, data.length);
+    }
+    /**
+     * Checks if writing the given number of bytes at the specified offset would exceed buffer bounds.
+     * Throws a WriteBufferError if the operation would exceed bounds.
+     * @param offset The offset to write at.
+     * @param size The number of bytes to write.
+     */
+    checkWriteBoundsSize(offset, size) {
+        if (offset < 0) {
+            throw new WriteBufferError(`Offset must be non-negative. Got offset=${offset}`, offset, size, this.view.length);
+        }
+        if (offset + size > this.view.length) {
+            throw new WriteBufferError(`Write operation exceeds buffer bounds. offset=${offset}, dataSize=${size}, bufferLength=${this.view.length}`, offset, size, this.view.length);
+        }
+    }
+    /**
+     * Appends the given bytes to the buffer at the current offset and advances the offset.
+     * @param data The bytes to append.
+     */
+    appendBytes(data) {
+        this.checkWriteBounds(__classPrivateFieldGet(this, _SyncInMemoryWritableBuffer_offset, "f"), data);
+        if (data.length === 0) {
+            return;
+        }
+        this.view.set(data, __classPrivateFieldGet(this, _SyncInMemoryWritableBuffer_offset, "f"));
+        __classPrivateFieldSet(this, _SyncInMemoryWritableBuffer_offset, __classPrivateFieldGet(this, _SyncInMemoryWritableBuffer_offset, "f") + data.length, "f");
+    }
+    /**
+     * Appends a slice of bytes to the buffer at the current offset and advances the offset.
+     * This avoids allocating subarray views in higher-level hot paths.
+     */
+    appendBytesFrom(data, offset, length) {
+        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}`);
+        }
+        this.checkWriteBoundsSize(__classPrivateFieldGet(this, _SyncInMemoryWritableBuffer_offset, "f"), length);
+        for (let i = 0; i < length; i++) {
+            this.view[__classPrivateFieldGet(this, _SyncInMemoryWritableBuffer_offset, "f") + i] = data[offset + i];
+        }
+        __classPrivateFieldSet(this, _SyncInMemoryWritableBuffer_offset, __classPrivateFieldGet(this, _SyncInMemoryWritableBuffer_offset, "f") + length, "f");
+    }
+    /**
+     * Checks if the buffer is in a valid state.
+     * Always returns true as this buffer throws on overflow instead of becoming invalid.
+     * @returns Always true.
+     */
+    isValid() {
+        return true; // Always valid since we throw on overflow instead of marking as invalid
+    }
+    /**
+     * Checks if the buffer can accept appending the given number of bytes.
+     * @param size The number of bytes to check.
+     * @returns True if the buffer can accept the append.
+     */
+    canAppendMore(_size) {
+        return this.isValid();
+    }
+    /**
+     * @internal Test-only function to get the current write offset position.
+     */
+    _testOnlyOffset() {
+        return __classPrivateFieldGet(this, _SyncInMemoryWritableBuffer_offset, "f");
+    }
+    /**
+     * @internal Test-only function to get the underlying ArrayBuffer.
+     */
+    _testOnlyBuffer() {
+        return this.view.buffer;
+    }
+    /**
+     * @internal Test-only function to get the remaining space in the buffer.
+     */
+    _testOnlyRemaining() {
+        return this.view.length - __classPrivateFieldGet(this, _SyncInMemoryWritableBuffer_offset, "f");
+    }
+    /**
+     * Gets a copy of the buffer containing only the bytes written to the buffer.
+     * @returns An ArrayBuffer containing only the written data.
+     */
+    getBufferCopy() {
+        const sliced = this.view.slice(__classPrivateFieldGet(this, _SyncInMemoryWritableBuffer_initialOffset, "f"), __classPrivateFieldGet(this, _SyncInMemoryWritableBuffer_offset, "f"));
+        return sliced.buffer.slice(sliced.byteOffset, sliced.byteOffset + sliced.length);
+    }
+    /**
+     * @internal Test-only method to check write bounds with arbitrary offset.
+     */
+    _testCheckWriteBounds(offset, data) {
+        this.checkWriteBounds(offset, data);
+    }
+    /**
+     * @internal Test-only method to check write bounds with arbitrary offset and size.
+     */
+    _testCheckWriteBoundsSize(offset, size) {
+        this.checkWriteBoundsSize(offset, size);
+    }
+}
+_SyncInMemoryWritableBuffer_offset = new WeakMap(), _SyncInMemoryWritableBuffer_initialOffset = new WeakMap();

package/esm/serialization/counting_writable_tap.d.ts

@@ -0,0 +1,45 @@
+import { TapBase, type WritableTapLike } from "./tap.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 declare class CountingWritableTap extends TapBase implements WritableTapLike {
+    /** Creates a new counting tap starting at position 0. */
+    constructor();
+    /** Returns whether the tap is valid (always true for counting tap). */
+    isValid(): Promise<boolean>;
+    /** Counts a boolean value (1 byte). */
+    writeBoolean(_value: boolean): Promise<void>;
+    /** Counts an integer value using varint encoding. */
+    writeInt(value: number): Promise<void>;
+    /** Counts a long value using zigzag + varint encoding. */
+    writeLong(value: bigint): Promise<void>;
+    /** Counts a float value (4 bytes). */
+    writeFloat(_value: number): Promise<void>;
+    /** Counts a double value (8 bytes). */
+    writeDouble(_value: number): Promise<void>;
+    /** Counts a fixed-length byte sequence. */
+    writeFixed(buf: Uint8Array): Promise<void>;
+    /** Counts a length-prefixed byte sequence. */
+    writeBytes(buf: Uint8Array): Promise<void>;
+    /** Counts a length-prefixed UTF-8 string. */
+    writeString(str: string): Promise<void>;
+    /** Counts raw binary bytes without length prefix. */
+    writeBinary(_str: string, len: number): Promise<void>;
+}