@sachitv/avro-typescript 0.4.2 → 0.5.0

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

@@ -22,15 +22,17 @@ export declare class ForwardOnlyStreamReadableBufferAdapter implements IReadable
      *
      * @param offset The byte offset to start reading from (must be current position).
      * @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.
-     * @throws Error if attempting to read backwards or seek forward.
+     * @returns A Promise that resolves to a new Uint8Array containing the read bytes.
+     * @throws ReadBufferError when the requested range is invalid or exceeds buffered bounds.
+     * @throws ReadBufferError if attempting to read backwards or seek forward.
      */
-    read(offset: number, size: number): Promise<Uint8Array | undefined>;
+    read(offset: number, size: number): Promise<Uint8Array>;
     /**
      * Checks if more data can be read at the specified offset.
      * Only allows reading at the current position; throws errors for backward or forward seeking.
      * @param offset - The offset to check for readability
      * @returns Promise resolving to true if data is available at the current position, false otherwise
+     * @throws ReadBufferError if attempting to read backwards or seek forward
      */
     canReadMore(offset: number): Promise<boolean>;
 }

package/esm/serialization/streams/forward_only_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 _ForwardOnlyStreamReadableBufferAdapter_instances, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, _ForwardOnlyStreamReadableBufferAdapter_streamBuffer, _ForwardOnlyStreamReadableBufferAdapter_eof, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, _ForwardOnlyStreamReadableBufferAdapter_ensureBufferedUpTo;
+import { ReadBufferError } from "../buffers/buffer_error.js";
 /**
  * Adapter that wraps an IStreamReadableBuffer to provide forward-only reading.
  * This adapter only allows forward sequential reads. Attempting to read backwards
@@ -38,23 +39,28 @@ export class ForwardOnlyStreamReadableBufferAdapter {
      *
      * @param offset The byte offset to start reading from (must be current position).
      * @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.
-     * @throws Error if attempting to read backwards or seek forward.
+     * @returns A Promise that resolves to a new Uint8Array containing the read bytes.
+     * @throws ReadBufferError when the requested range is invalid or exceeds buffered bounds.
+     * @throws ReadBufferError if attempting to read backwards or seek forward.
      */
     async read(offset, size) {
+        // Validate parameters
         if (offset < 0 || size < 0) {
-            return undefined;
+            throw new ReadBufferError("Offset and size must be non-negative", offset, size, __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f") + (__classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, "f")?.length ?? 0));
         }
+        const bufferedLength = __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, "f")?.length ?? 0;
         if (offset < __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f")) {
-            throw new Error("Cannot read backwards from current position");
+            const bufferEnd = __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f") + bufferedLength;
+            throw new ReadBufferError("Cannot read backwards from current position", offset, size, bufferEnd);
         }
         if (offset > __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f")) {
-            throw new Error("Cannot seek forward; reads must be sequential");
+            const bufferEnd = __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f") + bufferedLength;
+            throw new ReadBufferError("Cannot seek forward; reads must be sequential", offset, size, bufferEnd);
         }
         // At this point, offset must equal currentPosition due to the checks above
         await __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_instances, "m", _ForwardOnlyStreamReadableBufferAdapter_ensureBufferedUpTo).call(this, __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f") + size);
         if (__classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, "f") === null || size > __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, "f").length) {
-            return undefined;
+            throw new ReadBufferError("Operation exceeds buffer bounds", offset, size, __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f") + (__classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, "f")?.length ?? 0));
         }
         const result = __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, "f").slice(0, size);
         // Advance position
@@ -69,13 +75,17 @@ export class ForwardOnlyStreamReadableBufferAdapter {
      * Only allows reading at the current position; throws errors for backward or forward seeking.
      * @param offset - The offset to check for readability
      * @returns Promise resolving to true if data is available at the current position, false otherwise
+     * @throws ReadBufferError if attempting to read backwards or seek forward
      */
     async canReadMore(offset) {
+        const bufferedLength = __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, "f")?.length ?? 0;
         if (offset < __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f")) {
-            throw new Error("Cannot read backwards from current position");
+            const bufferEnd = __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f") + bufferedLength;
+            throw new ReadBufferError("Cannot read backwards from current position", offset, 1, bufferEnd);
         }
         if (offset > __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f")) {
-            throw new Error("Cannot seek forward; reads must be sequential");
+            const bufferEnd = __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f") + bufferedLength;
+            throw new ReadBufferError("Cannot seek forward; reads must be sequential", offset, 1, bufferEnd);
         }
         await __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_instances, "m", _ForwardOnlyStreamReadableBufferAdapter_ensureBufferedUpTo).call(this, __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f") + 1);
         if (__classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, "f") === null) {

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

@@ -26,9 +26,10 @@ export declare class StreamReadableBufferAdapter implements IReadableBuffer {
      *
      * @param offset The byte offset to start reading from (0-based).
      * @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/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 _StreamReadableBufferAdapter_instances, _StreamReadableBufferAdapter_bufferedData, _StreamReadableBufferAdapter_streamBuffer, _StreamReadableBufferAdapter_eof, _StreamReadableBufferAdapter_ensureBuffered, _StreamReadableBufferAdapter_ensureBufferedUpTo;
+import { ReadBufferError } from "../buffers/buffer_error.js";
 /**
  * Adapter that wraps an IStreamReadableBuffer to provide IReadableBuffer interface.
  * This buffers stream content progressively to enable random access reads.
@@ -44,11 +45,12 @@ export class StreamReadableBufferAdapter {
      *
      * @param offset The byte offset to start reading from (0-based).
      * @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, _StreamReadableBufferAdapter_bufferedData, "f")?.length ?? 0);
         }
         // Check if the section is already cached
         if (__classPrivateFieldGet(this, _StreamReadableBufferAdapter_bufferedData, "f") !== null && offset + size <= __classPrivateFieldGet(this, _StreamReadableBufferAdapter_bufferedData, "f").length) {
@@ -56,9 +58,12 @@ export class StreamReadableBufferAdapter {
         }
         // Load chunks until the necessary data is available
         await __classPrivateFieldGet(this, _StreamReadableBufferAdapter_instances, "m", _StreamReadableBufferAdapter_ensureBufferedUpTo).call(this, offset + size);
+        // bufferData is guaranteed to be non-null after ensureBufferedUpTo
+        const bufLen = __classPrivateFieldGet(this, _StreamReadableBufferAdapter_bufferedData, "f").length;
         // Check if we have enough data after buffering
-        if (__classPrivateFieldGet(this, _StreamReadableBufferAdapter_bufferedData, "f") === null || offset + size > __classPrivateFieldGet(this, _StreamReadableBufferAdapter_bufferedData, "f").length) {
-            return undefined;
+        if (offset + size > bufLen) {
+            const msg = `Operation exceeds buffer bounds. offset=${offset}, size=${size}, bufferLength=${bufLen}`;
+            throw new ReadBufferError(msg, offset, size, bufLen);
         }
         return __classPrivateFieldGet(this, _StreamReadableBufferAdapter_bufferedData, "f").slice(offset, offset + size);
     }
@@ -68,8 +73,16 @@ export class StreamReadableBufferAdapter {
      * @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;
+        }
     }
 }
 _StreamReadableBufferAdapter_bufferedData = new WeakMap(), _StreamReadableBufferAdapter_streamBuffer = new WeakMap(), _StreamReadableBufferAdapter_eof = new WeakMap(), _StreamReadableBufferAdapter_instances = new WeakSet(), _StreamReadableBufferAdapter_ensureBuffered = 

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

@@ -0,0 +1,36 @@
+import { type ISyncReadable } from "../buffers/buffer_sync.js";
+import type { ISyncStreamReadableBuffer } from "./streams_sync.js";
+/**
+ * Adapter that wraps an ISyncStreamReadableBuffer to provide the ISyncReadable interface.
+ * The adapter buffers stream content progressively to enable random-access reads.
+ */
+export declare class SyncStreamReadableBufferAdapter implements ISyncReadable {
+    #private;
+    /**
+     * Creates a new adapter from a synchronous stream readable buffer.
+     *
+     * @param streamBuffer The stream buffer to adapt.
+     */
+    constructor(streamBuffer: ISyncStreamReadableBuffer);
+    /**
+     * Reads a sequence of bytes from the buffer starting at the specified offset.
+     * This buffers stream data as needed to satisfy the read request.
+     *
+     * @param offset The byte offset to start reading from (0-based).
+     * @param size The number of bytes to read.
+     * @returns A Uint8Array containing the requested bytes.
+     * @throws ReadBufferError If the requested range is invalid or exceeds available data.
+     */
+    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;
+    /**
+     * Closes the underlying stream buffer.
+     */
+    close(): void;
+}

package/esm/serialization/streams/stream_readable_buffer_adapter_sync.js

@@ -0,0 +1,93 @@
+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 _SyncStreamReadableBufferAdapter_instances, _SyncStreamReadableBufferAdapter_streamBuffer, _SyncStreamReadableBufferAdapter_bufferedData, _SyncStreamReadableBufferAdapter_eof, _SyncStreamReadableBufferAdapter_validateParameters, _SyncStreamReadableBufferAdapter_ensureBufferedUpTo;
+import { ReadBufferError } from "../buffers/buffer_sync.js";
+/**
+ * Adapter that wraps an ISyncStreamReadableBuffer to provide the ISyncReadable interface.
+ * The adapter buffers stream content progressively to enable random-access reads.
+ */
+export class SyncStreamReadableBufferAdapter {
+    /**
+     * Creates a new adapter from a synchronous stream readable buffer.
+     *
+     * @param streamBuffer The stream buffer to adapt.
+     */
+    constructor(streamBuffer) {
+        _SyncStreamReadableBufferAdapter_instances.add(this);
+        _SyncStreamReadableBufferAdapter_streamBuffer.set(this, void 0);
+        _SyncStreamReadableBufferAdapter_bufferedData.set(this, new Uint8Array(0));
+        _SyncStreamReadableBufferAdapter_eof.set(this, false);
+        __classPrivateFieldSet(this, _SyncStreamReadableBufferAdapter_streamBuffer, streamBuffer, "f");
+    }
+    /**
+     * Reads a sequence of bytes from the buffer starting at the specified offset.
+     * This buffers stream data as needed to satisfy the read request.
+     *
+     * @param offset The byte offset to start reading from (0-based).
+     * @param size The number of bytes to read.
+     * @returns A Uint8Array containing the requested bytes.
+     * @throws ReadBufferError If the requested range is invalid or exceeds available data.
+     */
+    read(offset, size) {
+        __classPrivateFieldGet(this, _SyncStreamReadableBufferAdapter_instances, "m", _SyncStreamReadableBufferAdapter_validateParameters).call(this, offset, size);
+        __classPrivateFieldGet(this, _SyncStreamReadableBufferAdapter_instances, "m", _SyncStreamReadableBufferAdapter_ensureBufferedUpTo).call(this, offset + size);
+        if (offset + size > __classPrivateFieldGet(this, _SyncStreamReadableBufferAdapter_bufferedData, "f").length) {
+            throw new ReadBufferError(`Requested range exceeds buffered data. offset=${offset}, size=${size}, bufferLength=${__classPrivateFieldGet(this, _SyncStreamReadableBufferAdapter_bufferedData, "f").length}`, offset, size, __classPrivateFieldGet(this, _SyncStreamReadableBufferAdapter_bufferedData, "f").length);
+        }
+        return __classPrivateFieldGet(this, _SyncStreamReadableBufferAdapter_bufferedData, "f").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.read(offset, 1);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof ReadBufferError) {
+                return false;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Closes the underlying stream buffer.
+     */
+    close() {
+        __classPrivateFieldGet(this, _SyncStreamReadableBufferAdapter_streamBuffer, "f").close();
+    }
+}
+_SyncStreamReadableBufferAdapter_streamBuffer = new WeakMap(), _SyncStreamReadableBufferAdapter_bufferedData = new WeakMap(), _SyncStreamReadableBufferAdapter_eof = new WeakMap(), _SyncStreamReadableBufferAdapter_instances = new WeakSet(), _SyncStreamReadableBufferAdapter_validateParameters = function _SyncStreamReadableBufferAdapter_validateParameters(offset, size) {
+    if (offset < 0 || size < 0) {
+        throw new ReadBufferError(`Offset and size must be non-negative. Got offset=${offset}, size=${size}`, offset, size, __classPrivateFieldGet(this, _SyncStreamReadableBufferAdapter_bufferedData, "f").length);
+    }
+}, _SyncStreamReadableBufferAdapter_ensureBufferedUpTo = function _SyncStreamReadableBufferAdapter_ensureBufferedUpTo(targetOffset) {
+    while (!__classPrivateFieldGet(this, _SyncStreamReadableBufferAdapter_eof, "f") && __classPrivateFieldGet(this, _SyncStreamReadableBufferAdapter_bufferedData, "f").length < targetOffset) {
+        const chunk = __classPrivateFieldGet(this, _SyncStreamReadableBufferAdapter_streamBuffer, "f").readNext();
+        if (chunk === undefined) {
+            __classPrivateFieldSet(this, _SyncStreamReadableBufferAdapter_eof, true, "f");
+            break;
+        }
+        if (chunk.length === 0) {
+            continue;
+        }
+        const currentLength = __classPrivateFieldGet(this, _SyncStreamReadableBufferAdapter_bufferedData, "f").length;
+        const newBuffer = new Uint8Array(currentLength + chunk.length);
+        newBuffer.set(__classPrivateFieldGet(this, _SyncStreamReadableBufferAdapter_bufferedData, "f"));
+        newBuffer.set(chunk, currentLength);
+        __classPrivateFieldSet(this, _SyncStreamReadableBufferAdapter_bufferedData, newBuffer, "f");
+    }
+};

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

@@ -0,0 +1,45 @@
+import type { ISyncWritable } from "../buffers/buffer_sync.js";
+import type { ISyncStreamWritableBuffer } from "./streams_sync.js";
+/**
+ * Adapter that wraps an ISyncStreamWritableBuffer to provide the ISyncWritable interface.
+ * Writes are passed through to the underlying stream sink.
+ */
+export declare class SyncStreamWritableBufferAdapter implements ISyncWritable {
+    #private;
+    /**
+     * Creates a new adapter from a synchronous stream writable buffer.
+     *
+     * @param streamBuffer The stream buffer to adapt.
+     */
+    constructor(streamBuffer: ISyncStreamWritableBuffer);
+    /**
+     * Appends bytes to the buffer, advancing its internal write cursor when the
+     * operation succeeds.
+     */
+    appendBytes(data: Uint8Array): void;
+    /**
+     * Appends a slice of bytes to the buffer.
+     *
+     * @param data The source bytes.
+     * @param offset The starting offset in data.
+     * @param length The number of bytes to write.
+     */
+    appendBytesFrom(data: Uint8Array, offset: number, length: number): void;
+    /**
+     * Returns whether the buffer can continue accepting writes.
+     * Stream buffers can always accept writes until explicitly closed.
+     */
+    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;
+    /**
+     * Closes the underlying stream buffer.
+     * After calling this, further writes will be ignored.
+     */
+    close(): void;
+}

package/esm/serialization/streams/stream_writable_buffer_adapter_sync.js

@@ -0,0 +1,78 @@
+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 _SyncStreamWritableBufferAdapter_streamBuffer, _SyncStreamWritableBufferAdapter_isClosed;
+/**
+ * Adapter that wraps an ISyncStreamWritableBuffer to provide the ISyncWritable interface.
+ * Writes are passed through to the underlying stream sink.
+ */
+export class SyncStreamWritableBufferAdapter {
+    /**
+     * Creates a new adapter from a synchronous stream writable buffer.
+     *
+     * @param streamBuffer The stream buffer to adapt.
+     */
+    constructor(streamBuffer) {
+        _SyncStreamWritableBufferAdapter_streamBuffer.set(this, void 0);
+        _SyncStreamWritableBufferAdapter_isClosed.set(this, false);
+        __classPrivateFieldSet(this, _SyncStreamWritableBufferAdapter_streamBuffer, streamBuffer, "f");
+    }
+    /**
+     * Appends bytes to the buffer, advancing its internal write cursor when the
+     * operation succeeds.
+     */
+    appendBytes(data) {
+        if (__classPrivateFieldGet(this, _SyncStreamWritableBufferAdapter_isClosed, "f") || data.length === 0) {
+            return;
+        }
+        __classPrivateFieldGet(this, _SyncStreamWritableBufferAdapter_streamBuffer, "f").writeBytes(data);
+    }
+    /**
+     * Appends a slice of bytes to the buffer.
+     *
+     * @param data The source bytes.
+     * @param offset The starting offset in data.
+     * @param length The number of bytes to write.
+     */
+    appendBytesFrom(data, offset, length) {
+        if (__classPrivateFieldGet(this, _SyncStreamWritableBufferAdapter_isClosed, "f") || length === 0) {
+            return;
+        }
+        __classPrivateFieldGet(this, _SyncStreamWritableBufferAdapter_streamBuffer, "f").writeBytesFrom(data, offset, length);
+    }
+    /**
+     * Returns whether the buffer can continue accepting writes.
+     * Stream buffers can always accept writes until explicitly closed.
+     */
+    isValid() {
+        return !__classPrivateFieldGet(this, _SyncStreamWritableBufferAdapter_isClosed, "f");
+    }
+    /**
+     * 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();
+    }
+    /**
+     * Closes the underlying stream buffer.
+     * After calling this, further writes will be ignored.
+     */
+    close() {
+        if (!__classPrivateFieldGet(this, _SyncStreamWritableBufferAdapter_isClosed, "f")) {
+            __classPrivateFieldSet(this, _SyncStreamWritableBufferAdapter_isClosed, true, "f");
+            __classPrivateFieldGet(this, _SyncStreamWritableBufferAdapter_streamBuffer, "f").close();
+        }
+    }
+}
+_SyncStreamWritableBufferAdapter_streamBuffer = new WeakMap(), _SyncStreamWritableBufferAdapter_isClosed = new WeakMap();

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

@@ -0,0 +1,36 @@
+/**
+ * Interfaces describing synchronous stream-backed readable and writable buffers.
+ */
+/**
+ * Interface describing a readable buffer backed by a synchronous stream-like source.
+ * This provides sequential access to byte chunks without relying on async primitives.
+ */
+export interface ISyncStreamReadableBuffer {
+    /**
+     * Reads the next chunk of data from the stream.
+     * Returns undefined when the stream is exhausted.
+     */
+    readNext(): Uint8Array | undefined;
+    /**
+     * Closes the stream and releases any held resources.
+     */
+    close(): void;
+}
+/**
+ * Interface describing a writable buffer backed by a synchronous stream-like sink.
+ * This provides sequential writing capabilities.
+ */
+export interface ISyncStreamWritableBuffer {
+    /**
+     * Writes bytes to the stream.
+     */
+    writeBytes(data: Uint8Array): void;
+    /**
+     * Writes a slice of bytes to the stream without requiring a subarray view.
+     */
+    writeBytesFrom(data: Uint8Array, offset: number, length: number): void;
+    /**
+     * Closes the stream and releases any held resources.
+     */
+    close(): void;
+}

package/esm/serialization/streams/streams_sync.js

@@ -0,0 +1,4 @@
+/**
+ * Interfaces describing synchronous stream-backed readable and writable buffers.
+ */
+export {};

package/esm/serialization/tap.d.ts

@@ -13,7 +13,7 @@ export interface ReadableTapLike {
     canReadMore(): Promise<boolean>;
     /**
      * Returns the buffer contents from the start up to the current cursor.
-     * @throws RangeError if the cursor has advanced past the buffer length.
+     * @throws ReadBufferError if the cursor has advanced past the buffer length.
      */
     getValue(): Promise<Uint8Array>;
     /**
@@ -42,7 +42,7 @@ export interface ReadableTapLike {
     skipLong(): Promise<void>;
     /**
      * Reads a 32-bit little-endian floating point number.
-     * @throws RangeError if the read would exceed the buffer.
+     * @throws ReadBufferError if the read would exceed the buffer.
      */
     readFloat(): Promise<number>;
     /**
@@ -51,7 +51,7 @@ export interface ReadableTapLike {
     skipFloat(): void;
     /**
      * Reads a 64-bit little-endian floating point number.
-     * @throws RangeError if the read would exceed the buffer.
+     * @throws ReadBufferError if the read would exceed the buffer.
      */
     readDouble(): Promise<number>;
     /**
@@ -61,7 +61,7 @@ export interface ReadableTapLike {
     /**
      * Reads a fixed-length byte sequence into a new buffer.
      * @param len Number of bytes to read.
-     * @throws RangeError if the read exceeds the buffer.
+     * @throws ReadBufferError if the read exceeds the buffer.
      */
     readFixed(len: number): Promise<Uint8Array>;
     /**
@@ -71,7 +71,7 @@ export interface ReadableTapLike {
     skipFixed(len: number): void;
     /**
      * Reads a length-prefixed byte sequence.
-     * @throws RangeError if insufficient data remains.
+     * @throws ReadBufferError if insufficient data remains.
      */
     readBytes(): Promise<Uint8Array>;
     /**
@@ -80,7 +80,7 @@ export interface ReadableTapLike {
     skipBytes(): Promise<void>;
     /**
      * Reads a length-prefixed UTF-8 string.
-     * @throws RangeError when the buffer is exhausted prematurely.
+     * @throws ReadBufferError when the buffer is exhausted prematurely.
      */
     readString(): Promise<string>;
     /**
@@ -127,8 +127,6 @@ export interface ReadableTapLike {
     matchBytes(tap: ReadableTapLike): Promise<number>;
     /** Matches a string value. */
     matchString(tap: ReadableTapLike): Promise<number>;
-    /** Unpacks a long-encoded byte array. */
-    unpackLongBytes(): Promise<Uint8Array>;
 }
 /**
  * Interface for writable tap operations compatible with Avro binary serialization.
@@ -166,9 +164,8 @@ export interface WritableTapLike {
     /**
      * Writes a fixed-length byte sequence from the provided buffer.
      * @param buf Source buffer to copy from.
-     * @param len Optional number of bytes to write; defaults to the buffer length.
      */
-    writeFixed(buf: Uint8Array, len?: number): Promise<void>;
+    writeFixed(buf: Uint8Array): Promise<void>;
     /**
      * Writes a length-prefixed byte sequence backed by the provided buffer.
      * @param buf The bytes to write.
@@ -185,11 +182,6 @@ export interface WritableTapLike {
      * @param len Number of bytes from the string to write.
      */
     writeBinary(str: string, len: number): Promise<void>;
-    /**
-     * Encodes an 8-byte two's complement integer into zig-zag encoded varint bytes.
-     * @param arr Buffer containing the 8-byte value to encode; reused during processing.
-     */
-    packLongBytes(arr: Uint8Array): Promise<void>;
 }
 /** Abstract base class for tap implementations that manage buffer position. */
 export declare abstract class TapBase {
@@ -229,7 +221,7 @@ export declare class ReadableTap extends TapBase implements ReadableTapLike {
     _testOnlyBuf(): Promise<Uint8Array>;
     /**
      * Returns the buffer contents from the start up to the current cursor.
-     * @throws RangeError if the cursor has advanced past the buffer length.
+     * @throws ReadBufferError if the cursor has advanced past the buffer length.
      */
     getValue(): Promise<Uint8Array>;
     /** Retrieves the byte at the specified position in the buffer. */
@@ -260,7 +252,7 @@ export declare class ReadableTap extends TapBase implements ReadableTapLike {
     skipLong(): Promise<void>;
     /**
      * Reads a 32-bit little-endian floating point number.
-     * @throws RangeError if the read would exceed the buffer.
+     * @throws ReadBufferError if the read would exceed the buffer.
      */
     readFloat(): Promise<number>;
     /**
@@ -269,7 +261,7 @@ export declare class ReadableTap extends TapBase implements ReadableTapLike {
     skipFloat(): void;
     /**
      * Reads a 64-bit little-endian floating point number.
-     * @throws RangeError if the read would exceed the buffer.
+     * @throws ReadBufferError if the read would exceed the buffer.
      */
     readDouble(): Promise<number>;
     /**
@@ -279,7 +271,7 @@ export declare class ReadableTap extends TapBase implements ReadableTapLike {
     /**
      * Reads a fixed-length byte sequence into a new buffer.
      * @param len Number of bytes to read.
-     * @throws RangeError if the read exceeds the buffer.
+     * @throws ReadBufferError if the read exceeds the buffer.
      */
     readFixed(len: number): Promise<Uint8Array>;
     /**
@@ -289,7 +281,7 @@ export declare class ReadableTap extends TapBase implements ReadableTapLike {
     skipFixed(len: number): void;
     /**
      * Reads a length-prefixed byte sequence.
-     * @throws RangeError if insufficient data remains.
+     * @throws ReadBufferError if insufficient data remains.
      */
     readBytes(): Promise<Uint8Array>;
     /**
@@ -302,7 +294,7 @@ export declare class ReadableTap extends TapBase implements ReadableTapLike {
     skipString(): Promise<void>;
     /**
      * Reads a length-prefixed UTF-8 string.
-     * @throws RangeError when the buffer is exhausted prematurely.
+     * @throws ReadBufferError when the buffer is exhausted prematurely.
      */
     readString(): Promise<string>;
     /**
@@ -348,10 +340,6 @@ export declare class ReadableTap extends TapBase implements ReadableTapLike {
      * @returns Comparison result using -1/0/1 semantics.
      */
     matchString(tap: ReadableTapLike): Promise<number>;
-    /**
-     * Decodes the next zig-zag encoded long into an 8-byte two's complement buffer.
-     */
-    unpackLongBytes(): Promise<Uint8Array>;
 }
 /**
  * Binary tap that exposes Avro-compatible write helpers on top of a writable buffer.
@@ -379,6 +367,7 @@ export declare class WritableTap extends TapBase implements WritableTapLike {
     writeBoolean(value: boolean): Promise<void>;
     /**
      * Writes a zig-zag encoded 32-bit signed integer.
+     * Uses a 32-bit zig-zag + varint path to avoid BigInt casts for performance.
      * @param n Integer value to write.
      */
     writeInt(n: number): Promise<void>;
@@ -400,9 +389,8 @@ export declare class WritableTap extends TapBase implements WritableTapLike {
     /**
      * Writes a fixed-length byte sequence from the provided buffer.
      * @param buf Source buffer to copy from.
-     * @param len Optional number of bytes to write; defaults to the buffer length.
      */
-    writeFixed(buf: Uint8Array, len?: number): Promise<void>;
+    writeFixed(buf: Uint8Array): Promise<void>;
     /**
      * Writes a length-prefixed byte sequence backed by the provided buffer.
      * @param buf Bytes to write.
@@ -419,9 +407,4 @@ export declare class WritableTap extends TapBase implements WritableTapLike {
      * @param len Number of bytes from the string to write.
      */
     writeBinary(str: string, len: number): Promise<void>;
-    /**
-     * Encodes an 8-byte two's complement integer into zig-zag encoded varint bytes.
-     * @param arr Buffer containing the 8-byte value to encode; reused during processing.
-     */
-    packLongBytes(arr: Uint8Array): Promise<void>;
 }