@sachitv/avro-typescript 0.4.0

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

@@ -0,0 +1,52 @@
+import type { IReadableBuffer } from "../buffers/buffer.js";
+import type { IStreamReadableBuffer } from "./streams.js";
+import { CircularBuffer } from "../../internal/collections/circular_buffer.js";
+/**
+ * A limited buffer adapter that maintains a rolling window of stream data.
+ * This provides memory-efficient random access within a sliding window,
+ * but cannot access data that has been discarded from the window.
+ *
+ * Key features:
+ * - Rolling window: Maintains only a limited amount of data in memory
+ * - Forward access: Can read data ahead in the stream
+ * - Limited backward access: Can only access data within the current window
+ * - Memory efficient: Suitable for large streams where full buffering is impractical
+ *
+ * Limitations:
+ * - Cannot access data before the current window start
+ * - Window size determines maximum backward seek distance
+ */
+export declare class FixedSizeStreamReadableBufferAdapter implements IReadableBuffer {
+    #private;
+    /**
+     * Creates a new limited buffer adapter.
+     *
+     * @param streamBuffer The stream buffer to read from
+     * @param windowSize The size of the rolling window in bytes
+     * @param circularBuffer Optional circular buffer for testing
+     */
+    constructor(streamBuffer: IStreamReadableBuffer, windowSize: number, circularBuffer?: CircularBuffer);
+    /**
+     * Gets the total length of the buffer.
+     * For limited buffers, this returns the current buffer end position.
+     * Note: This may not represent the total stream length if not fully buffered.
+     *
+     * @returns The current buffer length in bytes
+     */
+    length(): Promise<number>;
+    /**
+     * Reads a sequence of bytes from the buffer starting at the specified offset.
+     * The offset is relative to the stream start.
+     *
+     * @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
+     */
+    read(offset: number, size: number): Promise<Uint8Array | undefined>;
+    /**
+     * 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): Promise<boolean>;
+}

package/esm/serialization/streams/fixed_size_stream_readable_buffer_adapter.js

@@ -0,0 +1,129 @@
+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 _FixedSizeStreamReadableBufferAdapter_instances, _FixedSizeStreamReadableBufferAdapter_streamBuffer, _FixedSizeStreamReadableBufferAdapter_windowSize, _FixedSizeStreamReadableBufferAdapter_circularBuffer, _FixedSizeStreamReadableBufferAdapter_eof, _FixedSizeStreamReadableBufferAdapter_extractFromBuffer, _FixedSizeStreamReadableBufferAdapter_fillBuffer;
+import { CircularBuffer } from "../../internal/collections/circular_buffer.js";
+/**
+ * A limited buffer adapter that maintains a rolling window of stream data.
+ * This provides memory-efficient random access within a sliding window,
+ * but cannot access data that has been discarded from the window.
+ *
+ * Key features:
+ * - Rolling window: Maintains only a limited amount of data in memory
+ * - Forward access: Can read data ahead in the stream
+ * - Limited backward access: Can only access data within the current window
+ * - Memory efficient: Suitable for large streams where full buffering is impractical
+ *
+ * Limitations:
+ * - Cannot access data before the current window start
+ * - Window size determines maximum backward seek distance
+ */
+export class FixedSizeStreamReadableBufferAdapter {
+    /**
+     * Creates a new limited buffer adapter.
+     *
+     * @param streamBuffer The stream buffer to read from
+     * @param windowSize The size of the rolling window in bytes
+     * @param circularBuffer Optional circular buffer for testing
+     */
+    constructor(streamBuffer, windowSize, circularBuffer) {
+        _FixedSizeStreamReadableBufferAdapter_instances.add(this);
+        _FixedSizeStreamReadableBufferAdapter_streamBuffer.set(this, void 0);
+        _FixedSizeStreamReadableBufferAdapter_windowSize.set(this, void 0);
+        _FixedSizeStreamReadableBufferAdapter_circularBuffer.set(this, void 0);
+        _FixedSizeStreamReadableBufferAdapter_eof.set(this, void 0);
+        if (windowSize <= 0) {
+            throw new RangeError("Window size must be positive");
+        }
+        __classPrivateFieldSet(this, _FixedSizeStreamReadableBufferAdapter_streamBuffer, streamBuffer, "f");
+        __classPrivateFieldSet(this, _FixedSizeStreamReadableBufferAdapter_windowSize, windowSize, "f");
+        __classPrivateFieldSet(this, _FixedSizeStreamReadableBufferAdapter_circularBuffer, circularBuffer ?? new CircularBuffer(windowSize), "f");
+        __classPrivateFieldSet(this, _FixedSizeStreamReadableBufferAdapter_eof, false, "f");
+    }
+    /**
+     * Gets the total length of the buffer.
+     * For limited buffers, this returns the current buffer end position.
+     * Note: This may not represent the total stream length if not fully buffered.
+     *
+     * @returns The current buffer length in bytes
+     */
+    // deno-lint-ignore require-await
+    async length() {
+        return __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_circularBuffer, "f").windowEnd();
+    }
+    /**
+     * Reads a sequence of bytes from the buffer starting at the specified offset.
+     * The offset is relative to the stream start.
+     *
+     * @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
+     */
+    async read(offset, size) {
+        if (offset < 0 || size < 0) {
+            return undefined;
+        }
+        // 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")}`);
+        }
+        // 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()}`);
+        }
+        // Check if data is already in cache
+        if (offset + size <= __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_circularBuffer, "f").windowEnd()) {
+            // Data is already cached, extract it directly
+            return __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_instances, "m", _FixedSizeStreamReadableBufferAdapter_extractFromBuffer).call(this, offset, size);
+        }
+        // Data is not in cache, wait until it's loaded
+        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;
+        }
+        // Extract data from buffer
+        return __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_instances, "m", _FixedSizeStreamReadableBufferAdapter_extractFromBuffer).call(this, 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.
+     */
+    async canReadMore(offset) {
+        const result = await this.read(offset, 1);
+        return result !== undefined;
+    }
+}
+_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) {
+    return __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_circularBuffer, "f").get(offset, size);
+}, _FixedSizeStreamReadableBufferAdapter_fillBuffer = 
+/**
+ * Fills the buffer with data from the stream until at least targetOffset is reached.
+ */
+async function _FixedSizeStreamReadableBufferAdapter_fillBuffer(targetOffset) {
+    while (!__classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_eof, "f") && __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_circularBuffer, "f").windowEnd() < targetOffset) {
+        const chunk = await __classPrivateFieldGet(this, _FixedSizeStreamReadableBufferAdapter_streamBuffer, "f").readNext();
+        if (chunk === undefined) {
+            __classPrivateFieldSet(this, _FixedSizeStreamReadableBufferAdapter_eof, true, "f");
+            break;
+        }
+        try {
+            __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}`);
+            }
+            throw error;
+        }
+    }
+};

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

@@ -0,0 +1,36 @@
+import type { IStreamReadableBuffer } from "./streams.js";
+import type { IReadableBuffer } from "../buffers/buffer.js";
+/**
+ * Adapter that wraps an IStreamReadableBuffer to provide forward-only reading.
+ * This adapter only allows forward sequential reads. Attempting to read backwards
+ * or seek forward will throw an error. The buffer grows as needed and shrinks
+ * by discarding consumed data to save memory.
+ */
+export declare class ForwardOnlyStreamReadableBufferAdapter implements IReadableBuffer {
+    #private;
+    /**
+     * Creates a new forward-only adapter from a stream readable buffer.
+     * Reads must be sequential from the current position.
+     *
+     * @param streamBuffer The stream buffer to adapt.
+     */
+    constructor(streamBuffer: IStreamReadableBuffer);
+    /**
+     * Reads a sequence of bytes from the buffer starting at the current position.
+     * Only sequential reads are allowed; attempting to read backwards or seek
+     * forward will throw an error. The read advances the current position.
+     *
+     * @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.
+     */
+    read(offset: number, size: number): Promise<Uint8Array | undefined>;
+    /**
+     * 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
+     */
+    canReadMore(offset: number): Promise<boolean>;
+}

package/esm/serialization/streams/forward_only_stream_readable_buffer_adapter.js

@@ -0,0 +1,114 @@
+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 _ForwardOnlyStreamReadableBufferAdapter_instances, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, _ForwardOnlyStreamReadableBufferAdapter_streamBuffer, _ForwardOnlyStreamReadableBufferAdapter_eof, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, _ForwardOnlyStreamReadableBufferAdapter_ensureBufferedUpTo;
+/**
+ * Adapter that wraps an IStreamReadableBuffer to provide forward-only reading.
+ * This adapter only allows forward sequential reads. Attempting to read backwards
+ * or seek forward will throw an error. The buffer grows as needed and shrinks
+ * by discarding consumed data to save memory.
+ */
+export class ForwardOnlyStreamReadableBufferAdapter {
+    /**
+     * Creates a new forward-only adapter from a stream readable buffer.
+     * Reads must be sequential from the current position.
+     *
+     * @param streamBuffer The stream buffer to adapt.
+     */
+    constructor(streamBuffer) {
+        _ForwardOnlyStreamReadableBufferAdapter_instances.add(this);
+        _ForwardOnlyStreamReadableBufferAdapter_bufferedData.set(this, null);
+        _ForwardOnlyStreamReadableBufferAdapter_streamBuffer.set(this, void 0);
+        _ForwardOnlyStreamReadableBufferAdapter_eof.set(this, false);
+        _ForwardOnlyStreamReadableBufferAdapter_currentPosition.set(this, 0);
+        __classPrivateFieldSet(this, _ForwardOnlyStreamReadableBufferAdapter_streamBuffer, streamBuffer, "f");
+    }
+    /**
+     * Reads a sequence of bytes from the buffer starting at the current position.
+     * Only sequential reads are allowed; attempting to read backwards or seek
+     * forward will throw an error. The read advances the current position.
+     *
+     * @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.
+     */
+    async read(offset, size) {
+        if (offset < 0 || size < 0) {
+            return undefined;
+        }
+        if (offset < __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f")) {
+            throw new Error("Cannot read backwards from current position");
+        }
+        if (offset > __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f")) {
+            throw new Error("Cannot seek forward; reads must be sequential");
+        }
+        // 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;
+        }
+        const result = __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, "f").slice(0, size);
+        // Advance position
+        __classPrivateFieldSet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f") + size, "f");
+        // Trim buffer to discard consumed data
+        // Split from size position onwards
+        __classPrivateFieldSet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, "f").slice(size), "f");
+        return result;
+    }
+    /**
+     * 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
+     */
+    async canReadMore(offset) {
+        if (offset < __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f")) {
+            throw new Error("Cannot read backwards from current position");
+        }
+        if (offset > __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f")) {
+            throw new Error("Cannot seek forward; reads must be sequential");
+        }
+        await __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_instances, "m", _ForwardOnlyStreamReadableBufferAdapter_ensureBufferedUpTo).call(this, __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f") + 1);
+        if (__classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, "f") === null) {
+            return false;
+        }
+        return __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, "f").length > 0;
+    }
+}
+_ForwardOnlyStreamReadableBufferAdapter_bufferedData = new WeakMap(), _ForwardOnlyStreamReadableBufferAdapter_streamBuffer = new WeakMap(), _ForwardOnlyStreamReadableBufferAdapter_eof = new WeakMap(), _ForwardOnlyStreamReadableBufferAdapter_currentPosition = new WeakMap(), _ForwardOnlyStreamReadableBufferAdapter_instances = new WeakSet(), _ForwardOnlyStreamReadableBufferAdapter_ensureBufferedUpTo = 
+/**
+ * Ensures data is buffered up to the specified target offset.
+ * Loads chunks progressively until the target is reached or EOF.
+ */
+async function _ForwardOnlyStreamReadableBufferAdapter_ensureBufferedUpTo(targetOffset) {
+    // Load chunks until we have enough data or reach EOF
+    while (!__classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_eof, "f") &&
+        (__classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, "f") === null ||
+            __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, "f").length + __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_currentPosition, "f") < targetOffset)) {
+        const chunk = await __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_streamBuffer, "f").readNext();
+        if (chunk === undefined) {
+            __classPrivateFieldSet(this, _ForwardOnlyStreamReadableBufferAdapter_eof, true, "f");
+            break;
+        }
+        // Expand buffer to accommodate new chunk
+        if (__classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, "f") === null) {
+            __classPrivateFieldSet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, chunk, "f");
+        }
+        else {
+            const currentLength = __classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, "f").length;
+            const newBuffer = new Uint8Array(currentLength + chunk.length);
+            newBuffer.set(__classPrivateFieldGet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, "f"));
+            newBuffer.set(chunk, currentLength);
+            __classPrivateFieldSet(this, _ForwardOnlyStreamReadableBufferAdapter_bufferedData, newBuffer, "f");
+        }
+    }
+};

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

@@ -0,0 +1,41 @@
+import type { IStreamReadableBuffer } from "./streams.js";
+/**
+ * A readable buffer implementation that reads data sequentially from a ReadableStream.
+ * This provides streaming read capabilities for large data sources.
+ *
+ * Key features:
+ * - Stream-backed: Reads data sequentially from a ReadableStream.
+ * - Memory efficient: Processes data in chunks without loading everything into memory.
+ * - Web standard: Uses the Web Streams API for broad compatibility.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch('large-file.avro');
+ * const stream = response.body!;
+ * const buffer = new StreamReadableBuffer(stream);
+ *
+ * let chunk;
+ * while ((chunk = await buffer.readNext()) !== undefined) {
+ *   // Process chunk
+ * }
+ * ```
+ */
+export declare class StreamReadableBuffer implements IStreamReadableBuffer {
+    #private;
+    /**
+     * Creates a new StreamReadableBuffer from the provided ReadableStream.
+     *
+     * @param stream The ReadableStream to read data from.
+     */
+    constructor(stream: ReadableStream<Uint8Array>);
+    /**
+     * Reads the next chunk of data from the stream.
+     *
+     * @returns A Promise that resolves to the next Uint8Array chunk, or undefined if the stream is exhausted.
+     */
+    readNext(): Promise<Uint8Array | undefined>;
+    /**
+     * Closes the stream and releases the reader lock.
+     */
+    close(): Promise<void>;
+}

package/esm/serialization/streams/stream_readable_buffer.js

@@ -0,0 +1,64 @@
+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 _StreamReadableBuffer_reader;
+/**
+ * A readable buffer implementation that reads data sequentially from a ReadableStream.
+ * This provides streaming read capabilities for large data sources.
+ *
+ * Key features:
+ * - Stream-backed: Reads data sequentially from a ReadableStream.
+ * - Memory efficient: Processes data in chunks without loading everything into memory.
+ * - Web standard: Uses the Web Streams API for broad compatibility.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch('large-file.avro');
+ * const stream = response.body!;
+ * const buffer = new StreamReadableBuffer(stream);
+ *
+ * let chunk;
+ * while ((chunk = await buffer.readNext()) !== undefined) {
+ *   // Process chunk
+ * }
+ * ```
+ */
+export class StreamReadableBuffer {
+    /**
+     * Creates a new StreamReadableBuffer from the provided ReadableStream.
+     *
+     * @param stream The ReadableStream to read data from.
+     */
+    constructor(stream) {
+        _StreamReadableBuffer_reader.set(this, void 0);
+        __classPrivateFieldSet(this, _StreamReadableBuffer_reader, stream.getReader(), "f");
+    }
+    /**
+     * Reads the next chunk of data from the stream.
+     *
+     * @returns A Promise that resolves to the next Uint8Array chunk, or undefined if the stream is exhausted.
+     */
+    async readNext() {
+        const { done, value } = await __classPrivateFieldGet(this, _StreamReadableBuffer_reader, "f").read();
+        if (done) {
+            return undefined;
+        }
+        return value;
+    }
+    /**
+     * Closes the stream and releases the reader lock.
+     */
+    // deno-lint-ignore require-await
+    async close() {
+        __classPrivateFieldGet(this, _StreamReadableBuffer_reader, "f").releaseLock();
+    }
+}
+_StreamReadableBuffer_reader = new WeakMap();

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

@@ -0,0 +1,38 @@
+import type { IReadableBuffer } from "../buffers/buffer.js";
+import type { IStreamReadableBuffer } from "./streams.js";
+/**
+ * Adapter that wraps an IStreamReadableBuffer to provide IReadableBuffer interface.
+ * This buffers stream content progressively to enable random access reads.
+ */
+export declare class StreamReadableBufferAdapter implements IReadableBuffer {
+    #private;
+    /**
+     * Creates a new adapter from a stream readable buffer.
+     * The entire stream will be buffered in memory for random access.
+     *
+     * @param streamBuffer The stream buffer to adapt.
+     */
+    constructor(streamBuffer: IStreamReadableBuffer);
+    /**
+     * Gets the total length of the buffer in bytes.
+     * This will buffer the entire stream if not already done.
+     *
+     * @returns The buffer length in bytes.
+     */
+    length(): Promise<number>;
+    /**
+     * Reads a sequence of bytes from the buffer starting at the specified offset.
+     * This will buffer 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 Promise that resolves to a new Uint8Array containing the read bytes, or undefined if the read would exceed buffer bounds.
+     */
+    read(offset: number, size: number): Promise<Uint8Array | undefined>;
+    /**
+     * 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): Promise<boolean>;
+}

package/esm/serialization/streams/stream_readable_buffer_adapter.js

@@ -0,0 +1,105 @@
+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 _StreamReadableBufferAdapter_instances, _StreamReadableBufferAdapter_bufferedData, _StreamReadableBufferAdapter_streamBuffer, _StreamReadableBufferAdapter_eof, _StreamReadableBufferAdapter_ensureBuffered, _StreamReadableBufferAdapter_ensureBufferedUpTo;
+/**
+ * Adapter that wraps an IStreamReadableBuffer to provide IReadableBuffer interface.
+ * This buffers stream content progressively to enable random access reads.
+ */
+export class StreamReadableBufferAdapter {
+    /**
+     * Creates a new adapter from a stream readable buffer.
+     * The entire stream will be buffered in memory for random access.
+     *
+     * @param streamBuffer The stream buffer to adapt.
+     */
+    constructor(streamBuffer) {
+        _StreamReadableBufferAdapter_instances.add(this);
+        _StreamReadableBufferAdapter_bufferedData.set(this, null);
+        _StreamReadableBufferAdapter_streamBuffer.set(this, void 0);
+        _StreamReadableBufferAdapter_eof.set(this, false);
+        __classPrivateFieldSet(this, _StreamReadableBufferAdapter_streamBuffer, streamBuffer, "f");
+    }
+    /**
+     * Gets the total length of the buffer in bytes.
+     * This will buffer the entire stream if not already done.
+     *
+     * @returns The buffer length in bytes.
+     */
+    async length() {
+        await __classPrivateFieldGet(this, _StreamReadableBufferAdapter_instances, "m", _StreamReadableBufferAdapter_ensureBuffered).call(this);
+        return __classPrivateFieldGet(this, _StreamReadableBufferAdapter_bufferedData, "f").length;
+    }
+    /**
+     * Reads a sequence of bytes from the buffer starting at the specified offset.
+     * This will buffer 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 Promise that resolves to a new Uint8Array containing the read bytes, or undefined if the read would exceed buffer bounds.
+     */
+    async read(offset, size) {
+        if (offset < 0 || size < 0) {
+            return undefined;
+        }
+        // Check if the section is already cached
+        if (__classPrivateFieldGet(this, _StreamReadableBufferAdapter_bufferedData, "f") !== null && offset + size <= __classPrivateFieldGet(this, _StreamReadableBufferAdapter_bufferedData, "f").length) {
+            return __classPrivateFieldGet(this, _StreamReadableBufferAdapter_bufferedData, "f").slice(offset, offset + size);
+        }
+        // Load chunks until the necessary data is available
+        await __classPrivateFieldGet(this, _StreamReadableBufferAdapter_instances, "m", _StreamReadableBufferAdapter_ensureBufferedUpTo).call(this, offset + size);
+        // 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;
+        }
+        return __classPrivateFieldGet(this, _StreamReadableBufferAdapter_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.
+     */
+    async canReadMore(offset) {
+        const result = await this.read(offset, 1);
+        return result !== undefined;
+    }
+}
+_StreamReadableBufferAdapter_bufferedData = new WeakMap(), _StreamReadableBufferAdapter_streamBuffer = new WeakMap(), _StreamReadableBufferAdapter_eof = new WeakMap(), _StreamReadableBufferAdapter_instances = new WeakSet(), _StreamReadableBufferAdapter_ensureBuffered = 
+/**
+ * Ensures the entire stream is buffered in memory.
+ */
+async function _StreamReadableBufferAdapter_ensureBuffered() {
+    await __classPrivateFieldGet(this, _StreamReadableBufferAdapter_instances, "m", _StreamReadableBufferAdapter_ensureBufferedUpTo).call(this, Infinity);
+}, _StreamReadableBufferAdapter_ensureBufferedUpTo = 
+/**
+ * Ensures data is buffered up to the specified target offset.
+ * Loads chunks progressively until the target is reached or EOF.
+ */
+async function _StreamReadableBufferAdapter_ensureBufferedUpTo(targetOffset) {
+    // Initialize buffer if needed
+    if (__classPrivateFieldGet(this, _StreamReadableBufferAdapter_bufferedData, "f") === null) {
+        __classPrivateFieldSet(this, _StreamReadableBufferAdapter_bufferedData, new Uint8Array(0), "f");
+    }
+    // Load chunks until we have enough data or reach EOF
+    while (!__classPrivateFieldGet(this, _StreamReadableBufferAdapter_eof, "f") && __classPrivateFieldGet(this, _StreamReadableBufferAdapter_bufferedData, "f").length < targetOffset) {
+        const chunk = await __classPrivateFieldGet(this, _StreamReadableBufferAdapter_streamBuffer, "f").readNext();
+        if (chunk === undefined) {
+            __classPrivateFieldSet(this, _StreamReadableBufferAdapter_eof, true, "f");
+            break;
+        }
+        // Expand buffer to accommodate new chunk
+        const currentLength = __classPrivateFieldGet(this, _StreamReadableBufferAdapter_bufferedData, "f").length;
+        const newBuffer = new Uint8Array(currentLength + chunk.length);
+        newBuffer.set(__classPrivateFieldGet(this, _StreamReadableBufferAdapter_bufferedData, "f"));
+        newBuffer.set(chunk, currentLength);
+        __classPrivateFieldSet(this, _StreamReadableBufferAdapter_bufferedData, newBuffer, "f");
+    }
+};

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

@@ -0,0 +1,42 @@
+import type { IStreamWritableBuffer } from "./streams.js";
+/**
+ * A writable buffer implementation that writes data sequentially to a WritableStream.
+ * This provides streaming write capabilities for large data outputs.
+ *
+ * Key features:
+ * - Stream-backed: Writes data sequentially to a WritableStream.
+ * - Memory efficient: Processes data in chunks without buffering everything in memory.
+ * - Web standard: Uses the Web Streams API for broad compatibility.
+ *
+ * @example
+ * ```typescript
+ * const stream = new WritableStream({
+ *   write(chunk) {
+ *     // Handle chunk
+ *   }
+ * });
+ * const buffer = new StreamWritableBuffer(stream);
+ *
+ * await buffer.writeBytes(new Uint8Array([1, 2, 3, 4]));
+ * await buffer.close();
+ * ```
+ */
+export declare class StreamWritableBuffer implements IStreamWritableBuffer {
+    #private;
+    /**
+     * Creates a new StreamWritableBuffer from the provided WritableStream.
+     *
+     * @param stream The WritableStream to write data to.
+     */
+    constructor(stream: WritableStream<Uint8Array>);
+    /**
+     * Writes bytes to the stream.
+     *
+     * @param data The bytes to write.
+     */
+    writeBytes(data: Uint8Array): Promise<void>;
+    /**
+     * Closes the stream and releases the writer lock.
+     */
+    close(): Promise<void>;
+}