@sachitv/avro-typescript 0.4.2 → 0.5.0

package/esm/avro_reader_sync.d.ts

@@ -0,0 +1,48 @@
+import type { ISyncReadable } from "./serialization/buffers/buffer_sync.js";
+import { type SyncAvroFileParserOptions } from "./serialization/avro_file_parser_sync.js";
+import type { ParsedAvroHeader } from "./serialization/avro_file_parser.js";
+import type { SyncDecoderRegistry } from "./serialization/decoders/decoder_sync.js";
+import type { ISyncStreamReadableBuffer } from "./serialization/streams/streams_sync.js";
+/**
+ * Options shared by all SyncAvroReader factories.
+ */
+export interface SyncReaderSchemaOptions {
+    /** Optional reader schema used to resolve records written with a different schema. */
+    readerSchema?: SyncAvroFileParserOptions["readerSchema"];
+    /** Custom codec decoders. Cannot include "null" as it is built-in. */
+    decoders?: SyncDecoderRegistry;
+    /** Optional hook to call when closing the reader. */
+    closeHook?: () => void;
+}
+/**
+ * Options accepted by {@link SyncAvroReader.fromBuffer}.
+ */
+export type SyncFromBufferOptions = SyncReaderSchemaOptions;
+/**
+ * Options accepted by {@link SyncAvroReader.fromStream}.
+ */
+export type SyncFromStreamOptions = SyncReaderSchemaOptions;
+/**
+ * Interface exposed by SyncAvroReader instances.
+ */
+export interface SyncAvroReaderInstance {
+    /** Returns the parsed Avro file header. */
+    getHeader(): ParsedAvroHeader;
+    /** Closes the reader and releases any resources. */
+    close(): void;
+    /** Returns an iterator over the Avro records. */
+    iterRecords(): IterableIterator<unknown>;
+}
+/**
+ * Public API for reading Avro object container files synchronously.
+ */
+export declare class SyncAvroReader {
+    /**
+     * Creates a reader from any synchronous readable buffer.
+     */
+    static fromBuffer(buffer: ISyncReadable, options?: SyncFromBufferOptions): SyncAvroReaderInstance;
+    /**
+     * Creates a reader from a synchronous stream buffer by adapting it to ISyncReadable.
+     */
+    static fromStream(stream: ISyncStreamReadableBuffer, options?: SyncFromStreamOptions): SyncAvroReaderInstance;
+}

package/esm/avro_reader_sync.js

@@ -0,0 +1,79 @@
+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 _SyncAvroReaderInstanceImpl_parser, _SyncAvroReaderInstanceImpl_records, _SyncAvroReaderInstanceImpl_closeHook, _SyncAvroReaderInstanceImpl_closed;
+import { SyncAvroFileParser, } from "./serialization/avro_file_parser_sync.js";
+import { SyncStreamReadableBufferAdapter, } from "./serialization/streams/stream_readable_buffer_adapter_sync.js";
+class SyncAvroReaderInstanceImpl {
+    constructor(parser, closeHook) {
+        _SyncAvroReaderInstanceImpl_parser.set(this, void 0);
+        _SyncAvroReaderInstanceImpl_records.set(this, void 0);
+        _SyncAvroReaderInstanceImpl_closeHook.set(this, void 0);
+        _SyncAvroReaderInstanceImpl_closed.set(this, false);
+        __classPrivateFieldSet(this, _SyncAvroReaderInstanceImpl_parser, parser, "f");
+        __classPrivateFieldSet(this, _SyncAvroReaderInstanceImpl_records, parser.iterRecords(), "f");
+        __classPrivateFieldSet(this, _SyncAvroReaderInstanceImpl_closeHook, closeHook, "f");
+    }
+    getHeader() {
+        return __classPrivateFieldGet(this, _SyncAvroReaderInstanceImpl_parser, "f").getHeader();
+    }
+    iterRecords() {
+        return __classPrivateFieldGet(this, _SyncAvroReaderInstanceImpl_records, "f");
+    }
+    close() {
+        if (__classPrivateFieldGet(this, _SyncAvroReaderInstanceImpl_closed, "f")) {
+            return;
+        }
+        if (__classPrivateFieldGet(this, _SyncAvroReaderInstanceImpl_closeHook, "f")) {
+            try {
+                __classPrivateFieldGet(this, _SyncAvroReaderInstanceImpl_closeHook, "f").call(this);
+            }
+            catch {
+                // Ignore close hook errors to keep shutdown best-effort.
+            }
+            __classPrivateFieldSet(this, _SyncAvroReaderInstanceImpl_closeHook, undefined, "f");
+        }
+        __classPrivateFieldSet(this, _SyncAvroReaderInstanceImpl_closed, true, "f");
+    }
+}
+_SyncAvroReaderInstanceImpl_parser = new WeakMap(), _SyncAvroReaderInstanceImpl_records = new WeakMap(), _SyncAvroReaderInstanceImpl_closeHook = new WeakMap(), _SyncAvroReaderInstanceImpl_closed = new WeakMap();
+/**
+ * Public API for reading Avro object container files synchronously.
+ */
+export class SyncAvroReader {
+    /**
+     * Creates a reader from any synchronous readable buffer.
+     */
+    static fromBuffer(buffer, options) {
+        const parser = new SyncAvroFileParser(buffer, {
+            readerSchema: options?.readerSchema,
+            decoders: options?.decoders,
+        });
+        return new SyncAvroReaderInstanceImpl(parser, options?.closeHook);
+    }
+    /**
+     * Creates a reader from a synchronous stream buffer by adapting it to ISyncReadable.
+     */
+    static fromStream(stream, options) {
+        const adapter = new SyncStreamReadableBufferAdapter(stream);
+        const combinedCloseHook = options?.closeHook
+            ? () => {
+                adapter.close();
+                options.closeHook?.();
+            }
+            : () => adapter.close();
+        return SyncAvroReader.fromBuffer(adapter, {
+            readerSchema: options?.readerSchema,
+            decoders: options?.decoders,
+            closeHook: combinedCloseHook,
+        });
+    }
+}

package/esm/avro_writer_sync.d.ts

@@ -0,0 +1,28 @@
+import type { ISyncWritable } from "./serialization/buffers/buffer_sync.js";
+import { type SyncAvroWriterOptions } from "./serialization/avro_file_writer_sync.js";
+import type { ISyncStreamWritableBuffer } from "./serialization/streams/streams_sync.js";
+export type { SyncAvroWriterOptions } from "./serialization/avro_file_writer_sync.js";
+/**
+ * Interface exposed by synchronous Avro writer instances.
+ */
+export interface SyncAvroWriterInstance {
+    /** Appends a record to the Avro container. */
+    append(record: unknown): void;
+    /** Forces the current batch of pending records to flush into a block. */
+    flushBlock(): void;
+    /** Flushes pending data and closes the writer. */
+    close(): void;
+}
+/**
+ * Public API for writing Avro object container files synchronously.
+ */
+export declare class SyncAvroWriter {
+    /**
+     * Creates a writer targeting any synchronous writable buffer.
+     */
+    static toBuffer(buffer: ISyncWritable, options: SyncAvroWriterOptions): SyncAvroWriterInstance;
+    /**
+     * Creates a writer that pushes bytes to a synchronous stream sink.
+     */
+    static toStream(stream: ISyncStreamWritableBuffer, options: SyncAvroWriterOptions): SyncAvroWriterInstance;
+}

package/esm/avro_writer_sync.js

@@ -0,0 +1,63 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SyncAvroWriterInstanceImpl_writer, _SyncAvroWriterInstanceImpl_closeHook, _SyncAvroWriterInstanceImpl_closed;
+import { SyncAvroFileWriter, } from "./serialization/avro_file_writer_sync.js";
+import { SyncStreamWritableBufferAdapter, } from "./serialization/streams/stream_writable_buffer_adapter_sync.js";
+class SyncAvroWriterInstanceImpl {
+    constructor(writer, closeHook) {
+        _SyncAvroWriterInstanceImpl_writer.set(this, void 0);
+        _SyncAvroWriterInstanceImpl_closeHook.set(this, void 0);
+        _SyncAvroWriterInstanceImpl_closed.set(this, false);
+        __classPrivateFieldSet(this, _SyncAvroWriterInstanceImpl_writer, writer, "f");
+        __classPrivateFieldSet(this, _SyncAvroWriterInstanceImpl_closeHook, closeHook, "f");
+    }
+    append(record) {
+        __classPrivateFieldGet(this, _SyncAvroWriterInstanceImpl_writer, "f").append(record);
+    }
+    flushBlock() {
+        __classPrivateFieldGet(this, _SyncAvroWriterInstanceImpl_writer, "f").flushBlock();
+    }
+    close() {
+        if (__classPrivateFieldGet(this, _SyncAvroWriterInstanceImpl_closed, "f")) {
+            return;
+        }
+        __classPrivateFieldGet(this, _SyncAvroWriterInstanceImpl_writer, "f").close();
+        if (__classPrivateFieldGet(this, _SyncAvroWriterInstanceImpl_closeHook, "f")) {
+            __classPrivateFieldGet(this, _SyncAvroWriterInstanceImpl_closeHook, "f").call(this);
+            __classPrivateFieldSet(this, _SyncAvroWriterInstanceImpl_closeHook, undefined, "f");
+        }
+        __classPrivateFieldSet(this, _SyncAvroWriterInstanceImpl_closed, true, "f");
+    }
+}
+_SyncAvroWriterInstanceImpl_writer = new WeakMap(), _SyncAvroWriterInstanceImpl_closeHook = new WeakMap(), _SyncAvroWriterInstanceImpl_closed = new WeakMap();
+/**
+ * Public API for writing Avro object container files synchronously.
+ */
+export class SyncAvroWriter {
+    /**
+     * Creates a writer targeting any synchronous writable buffer.
+     */
+    static toBuffer(buffer, options) {
+        const writer = new SyncAvroFileWriter(buffer, options);
+        return new SyncAvroWriterInstanceImpl(writer);
+    }
+    /**
+     * Creates a writer that pushes bytes to a synchronous stream sink.
+     */
+    static toStream(stream, options) {
+        const adapter = new SyncStreamWritableBufferAdapter(stream);
+        const writer = new SyncAvroFileWriter(adapter, options);
+        return new SyncAvroWriterInstanceImpl(writer, () => {
+            adapter.close();
+        });
+    }
+}

package/esm/internal/collections/circular_buffer.d.ts

@@ -33,7 +33,7 @@ export declare class CircularBuffer {
     /**
      * Adds data to the buffer, sliding the window if necessary.
      * @param data Uint8Array to add
-     * @throws RangeError if data size exceeds buffer capacity
+     * @throws ReadBufferError if data size exceeds buffer capacity
      */
     push(data: Uint8Array): void;
     /**
@@ -41,8 +41,9 @@ export declare class CircularBuffer {
      * @param start Start position relative to the overall data stream
      * @param size Number of bytes to retrieve
      * @returns Readonly view of the requested bytes (shallow copy, no allocation)
-     * @throws RangeError if start is before window start or size is negative
-     * @throws RangeError if requested range extends beyond window end
+     * @throws ReadBufferError if start is before window start
+     * @throws RangeError if size is negative
+     * @throws ReadBufferError if requested range extends beyond window end
      */
     get(start: number, size: number): Readonly<Uint8Array>;
 }

package/esm/internal/collections/circular_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 _CircularBuffer_instances, _CircularBuffer_buffer, _CircularBuffer_capacity, _CircularBuffer_windowStart, _CircularBuffer_windowEnd, _CircularBuffer_validateDataSize, _CircularBuffer_slideWindowIfNeeded, _CircularBuffer_addData, _CircularBuffer_validateGetParameters, _CircularBuffer_validateGetRange;
+import { ReadBufferError } from "../../serialization/buffers/buffer_error.js";
 /**
  * A circular buffer implementation that maintains a rolling window of Uint8Array data.
  * Uses copyWithin for efficient window sliding and provides memory-efficient random access.
@@ -68,7 +69,7 @@ export class CircularBuffer {
     /**
      * Adds data to the buffer, sliding the window if necessary.
      * @param data Uint8Array to add
-     * @throws RangeError if data size exceeds buffer capacity
+     * @throws ReadBufferError if data size exceeds buffer capacity
      */
     push(data) {
         if (data.length === 0) {
@@ -83,8 +84,9 @@ export class CircularBuffer {
      * @param start Start position relative to the overall data stream
      * @param size Number of bytes to retrieve
      * @returns Readonly view of the requested bytes (shallow copy, no allocation)
-     * @throws RangeError if start is before window start or size is negative
-     * @throws RangeError if requested range extends beyond window end
+     * @throws ReadBufferError if start is before window start
+     * @throws RangeError if size is negative
+     * @throws ReadBufferError if requested range extends beyond window end
      */
     get(start, size) {
         __classPrivateFieldGet(this, _CircularBuffer_instances, "m", _CircularBuffer_validateGetParameters).call(this, start, size);
@@ -95,7 +97,7 @@ export class CircularBuffer {
 }
 _CircularBuffer_buffer = new WeakMap(), _CircularBuffer_capacity = new WeakMap(), _CircularBuffer_windowStart = new WeakMap(), _CircularBuffer_windowEnd = new WeakMap(), _CircularBuffer_instances = new WeakSet(), _CircularBuffer_validateDataSize = function _CircularBuffer_validateDataSize(dataSize) {
     if (dataSize > __classPrivateFieldGet(this, _CircularBuffer_capacity, "f")) {
-        throw new RangeError(`Data size ${dataSize} exceeds buffer capacity ${__classPrivateFieldGet(this, _CircularBuffer_capacity, "f")}`);
+        throw new ReadBufferError(`Data size ${dataSize} exceeds buffer capacity ${__classPrivateFieldGet(this, _CircularBuffer_capacity, "f")}`, __classPrivateFieldGet(this, _CircularBuffer_windowEnd, "f"), dataSize, __classPrivateFieldGet(this, _CircularBuffer_capacity, "f"));
     }
 }, _CircularBuffer_slideWindowIfNeeded = function _CircularBuffer_slideWindowIfNeeded(dataSize) {
     const currentLength = this.length();
@@ -116,7 +118,7 @@ _CircularBuffer_buffer = new WeakMap(), _CircularBuffer_capacity = new WeakMap()
     __classPrivateFieldSet(this, _CircularBuffer_windowEnd, __classPrivateFieldGet(this, _CircularBuffer_windowEnd, "f") + data.length, "f");
 }, _CircularBuffer_validateGetParameters = function _CircularBuffer_validateGetParameters(start, size) {
     if (start < __classPrivateFieldGet(this, _CircularBuffer_windowStart, "f")) {
-        throw new RangeError(`Start position ${start} is before window start ${__classPrivateFieldGet(this, _CircularBuffer_windowStart, "f")}`);
+        throw new ReadBufferError(`Start position ${start} is before window start ${__classPrivateFieldGet(this, _CircularBuffer_windowStart, "f")}`, start, size, __classPrivateFieldGet(this, _CircularBuffer_windowEnd, "f"));
     }
     if (size < 0) {
         throw new RangeError(`Size ${size} cannot be negative`);
@@ -124,6 +126,6 @@ _CircularBuffer_buffer = new WeakMap(), _CircularBuffer_capacity = new WeakMap()
 }, _CircularBuffer_validateGetRange = function _CircularBuffer_validateGetRange(start, size) {
     const end = start + size;
     if (end > __classPrivateFieldGet(this, _CircularBuffer_windowEnd, "f")) {
-        throw new RangeError(`Requested range [${start}, ${end}) extends beyond window end ${__classPrivateFieldGet(this, _CircularBuffer_windowEnd, "f")}`);
+        throw new ReadBufferError(`Requested range [${start}, ${end}) extends beyond window end ${__classPrivateFieldGet(this, _CircularBuffer_windowEnd, "f")}`, start, size, __classPrivateFieldGet(this, _CircularBuffer_windowEnd, "f"));
     }
 };

package/esm/mod.d.ts

@@ -1,6 +1,8 @@
 import "./_dnt.polyfills.js";
 export { AvroReader } from "./avro_reader.js";
 export { AvroWriter } from "./avro_writer.js";
+export { SyncAvroReader } from "./avro_reader_sync.js";
+export { SyncAvroWriter } from "./avro_writer_sync.js";
 export { createType } from "./type/create_type.js";
 export { Type } from "./schemas/type.js";
 export { BaseType } from "./schemas/base_type.js";
@@ -41,10 +43,16 @@ export type { AvroFileParserOptions, AvroHeader, ParsedAvroHeader, } from "./ser
 export type { AvroWriterOptions } from "./serialization/avro_file_writer.js";
 export { AvroFileParser } from "./serialization/avro_file_parser.js";
 export { AvroFileWriter } from "./serialization/avro_file_writer.js";
+export type { SyncAvroFileParserOptions } from "./serialization/avro_file_parser_sync.js";
+export type { SyncAvroWriterOptions } from "./serialization/avro_file_writer_sync.js";
+export { SyncAvroFileParser } from "./serialization/avro_file_parser_sync.js";
+export { SyncAvroFileWriter } from "./serialization/avro_file_writer_sync.js";
 export { BLOCK_TYPE, HEADER_TYPE, MAGIC_BYTES, } from "./serialization/avro_constants.js";
 export type { IReadableAndWritableBuffer, IReadableBuffer, IWritableBuffer, } from "./serialization/buffers/buffer.js";
+export type { ISyncReadable, ISyncWritable, } from "./serialization/buffers/buffer_sync.js";
 export { BlobReadableBuffer } from "./serialization/buffers/blob_readable_buffer.js";
 export { InMemoryReadableBuffer, InMemoryWritableBuffer, } from "./serialization/buffers/in_memory_buffer.js";
+export { SyncInMemoryReadableBuffer, SyncInMemoryWritableBuffer, } from "./serialization/buffers/in_memory_buffer_sync.js";
 export type { IStreamReadableBuffer, IStreamWritableBuffer, } from "./serialization/streams/streams.js";
 export { StreamReadableBuffer } from "./serialization/streams/stream_readable_buffer.js";
 export { StreamWritableBuffer } from "./serialization/streams/stream_writable_buffer.js";
@@ -52,12 +60,21 @@ export { StreamReadableBufferAdapter } from "./serialization/streams/stream_read
 export { StreamWritableBufferAdapter } from "./serialization/streams/stream_writable_buffer_adapter.js";
 export { FixedSizeStreamReadableBufferAdapter } from "./serialization/streams/fixed_size_stream_readable_buffer_adapter.js";
 export { ForwardOnlyStreamReadableBufferAdapter } from "./serialization/streams/forward_only_stream_readable_buffer_adapter.js";
+export type { ISyncStreamReadableBuffer, ISyncStreamWritableBuffer, } from "./serialization/streams/streams_sync.js";
+export { SyncStreamReadableBufferAdapter } from "./serialization/streams/stream_readable_buffer_adapter_sync.js";
+export { SyncStreamWritableBufferAdapter } from "./serialization/streams/stream_writable_buffer_adapter_sync.js";
+export { SyncFixedSizeStreamReader } from "./serialization/streams/fixed_size_stream_reader_sync.js";
+export { SyncFixedSizeStreamWriter } from "./serialization/streams/fixed_size_stream_writer_sync.js";
 export type { Encoder } from "./serialization/encoders/encoder.js";
+export type { SyncEncoder, SyncEncoderRegistry, } from "./serialization/encoders/encoder_sync.js";
 export type { Decoder } from "./serialization/decoders/decoder.js";
+export type { SyncDecoder, SyncDecoderRegistry, } from "./serialization/decoders/decoder_sync.js";
 export { NullEncoder } from "./serialization/encoders/null_encoder.js";
 export { DeflateEncoder } from "./serialization/encoders/deflate_encoder.js";
+export { NullEncoderSync } from "./serialization/encoders/encoder_null_sync.js";
 export { NullDecoder } from "./serialization/decoders/null_decoder.js";
 export { DeflateDecoder } from "./serialization/decoders/deflate_decoder.js";
+export { NullDecoderSync } from "./serialization/decoders/decoder_null_sync.js";
 export type { ReadableTapLike, WritableTapLike } from "./serialization/tap.js";
 export { ReadableTap, WritableTap } from "./serialization/tap.js";
 export { decode, encode } from "./serialization/text_encoding.js";

package/esm/mod.js

@@ -2,6 +2,8 @@
 import "./_dnt.polyfills.js";
 export { AvroReader } from "./avro_reader.js";
 export { AvroWriter } from "./avro_writer.js";
+export { SyncAvroReader } from "./avro_reader_sync.js";
+export { SyncAvroWriter } from "./avro_writer_sync.js";
 export { createType } from "./type/create_type.js";
 // Schema types
 export { Type } from "./schemas/type.js";
@@ -45,19 +47,28 @@ export { ValidationError } from "./schemas/error.js";
 export { safeStringify } from "./schemas/json.js";
 export { AvroFileParser } from "./serialization/avro_file_parser.js";
 export { AvroFileWriter } from "./serialization/avro_file_writer.js";
+export { SyncAvroFileParser } from "./serialization/avro_file_parser_sync.js";
+export { SyncAvroFileWriter } from "./serialization/avro_file_writer_sync.js";
 export { BLOCK_TYPE, HEADER_TYPE, MAGIC_BYTES, } from "./serialization/avro_constants.js";
 export { BlobReadableBuffer } from "./serialization/buffers/blob_readable_buffer.js";
 export { InMemoryReadableBuffer, InMemoryWritableBuffer, } from "./serialization/buffers/in_memory_buffer.js";
+export { SyncInMemoryReadableBuffer, SyncInMemoryWritableBuffer, } from "./serialization/buffers/in_memory_buffer_sync.js";
 export { StreamReadableBuffer } from "./serialization/streams/stream_readable_buffer.js";
 export { StreamWritableBuffer } from "./serialization/streams/stream_writable_buffer.js";
 export { StreamReadableBufferAdapter } from "./serialization/streams/stream_readable_buffer_adapter.js";
 export { StreamWritableBufferAdapter } from "./serialization/streams/stream_writable_buffer_adapter.js";
 export { FixedSizeStreamReadableBufferAdapter } from "./serialization/streams/fixed_size_stream_readable_buffer_adapter.js";
 export { ForwardOnlyStreamReadableBufferAdapter } from "./serialization/streams/forward_only_stream_readable_buffer_adapter.js";
+export { SyncStreamReadableBufferAdapter } from "./serialization/streams/stream_readable_buffer_adapter_sync.js";
+export { SyncStreamWritableBufferAdapter } from "./serialization/streams/stream_writable_buffer_adapter_sync.js";
+export { SyncFixedSizeStreamReader } from "./serialization/streams/fixed_size_stream_reader_sync.js";
+export { SyncFixedSizeStreamWriter } from "./serialization/streams/fixed_size_stream_writer_sync.js";
 export { NullEncoder } from "./serialization/encoders/null_encoder.js";
 export { DeflateEncoder } from "./serialization/encoders/deflate_encoder.js";
+export { NullEncoderSync } from "./serialization/encoders/encoder_null_sync.js";
 export { NullDecoder } from "./serialization/decoders/null_decoder.js";
 export { DeflateDecoder } from "./serialization/decoders/deflate_decoder.js";
+export { NullDecoderSync } from "./serialization/decoders/decoder_null_sync.js";
 export { ReadableTap, WritableTap } from "./serialization/tap.js";
 // Utilities
 export { decode, encode } from "./serialization/text_encoding.js";

package/esm/schemas/base_type.d.ts

@@ -19,6 +19,8 @@ export type IsValidOptions = {
  * Subclasses must implement the remaining abstract methods.
  */
 export declare abstract class BaseType<T = unknown> extends Type<T> {
+    /** Creates a new BaseType instance. */
+    protected constructor(validate?: boolean);
     /**
      * Deserializes an ArrayBuffer into a value using the schema.
      * @param buffer The ArrayBuffer to deserialize.
@@ -38,4 +40,10 @@ export declare abstract class BaseType<T = unknown> extends Type<T> {
      * @returns A resolver for reading the writer type as this type.
      */
     createResolver(writerType: Type): Resolver;
+    /**
+     * Deserializes an ArrayBuffer into a value synchronously using the schema.
+     * @param buffer The ArrayBuffer to deserialize.
+     * @returns The deserialized value.
+     */
+    fromSyncBuffer(buffer: ArrayBuffer): T;
 }

package/esm/schemas/base_type.js

@@ -1,4 +1,5 @@
 import { ReadableTap } from "../serialization/tap.js";
+import { SyncReadableTap, } from "../serialization/tap_sync.js";
 import { Type } from "./type.js";
 import { Resolver } from "./resolver.js";
 import { safeStringify } from "./json.js";
@@ -7,6 +8,10 @@ import { safeStringify } from "./json.js";
  * Subclasses must implement the remaining abstract methods.
  */
 export class BaseType extends Type {
+    /** Creates a new BaseType instance. */
+    constructor(validate = true) {
+        super(validate);
+    }
     /**
      * Deserializes an ArrayBuffer into a value using the schema.
      * @param buffer The ArrayBuffer to deserialize.
@@ -40,10 +45,26 @@ export class BaseType extends Type {
                 async read(tap) {
                     return await this.readerType.read(tap);
                 }
+                readSync(tap) {
+                    return this.readerType.readSync(tap);
+                }
             }(this);
         }
         else {
             throw new Error(`Schema evolution not supported from writer type: ${safeStringify(writerType.toJSON())} to reader type: ${safeStringify(this.toJSON())}`);
         }
     }
+    /**
+     * Deserializes an ArrayBuffer into a value synchronously using the schema.
+     * @param buffer The ArrayBuffer to deserialize.
+     * @returns The deserialized value.
+     */
+    fromSyncBuffer(buffer) {
+        const tap = new SyncReadableTap(buffer);
+        const value = this.readSync(tap);
+        if (!tap.isValid() || tap.getPos() !== buffer.byteLength) {
+            throw new Error("Insufficient data for type");
+        }
+        return value;
+    }
 }

package/esm/schemas/complex/array_type.d.ts

@@ -1,8 +1,9 @@
-import { type ReadableTapLike, type WritableTapLike } from "../../serialization/tap.js";
+import type { ReadableTapLike, WritableTapLike } from "../../serialization/tap.js";
 import { BaseType } from "../base_type.js";
 import { Resolver } from "../resolver.js";
 import type { JSONType, Type } from "../type.js";
-import { type ErrorHook } from "../error.js";
+import type { ErrorHook } from "../error.js";
+import type { SyncReadableTapLike, SyncWritableTapLike } from "../../serialization/tap_sync.js";
 /**
  * Helper function to read an array from a tap.
  * @param tap The tap to read from.
@@ -10,12 +11,21 @@ import { type ErrorHook } from "../error.js";
  * @param collect Function to collect each read element.
  */
 export declare function readArrayInto<T>(tap: ReadableTapLike, readElement: (tap: ReadableTapLike) => Promise<T>, collect: (value: T) => void): Promise<void>;
+/**
+ * Synchronous helper function to read an array from a tap.
+ * @param tap The tap to read from.
+ * @param readElement Function to read a single element.
+ * @param collect Function to collect each read element.
+ */
+export declare function readArrayIntoSync<T>(tap: SyncReadableTapLike, readElement: (tap: SyncReadableTapLike) => T, collect: (value: T) => void): void;
 /**
  * Parameters for creating an ArrayType.
  */
 export interface ArrayTypeParams<T> {
     /** The type of items in the array. */
     items: Type<T>;
+    /** Whether to validate during writes. Defaults to true. */
+    validate?: boolean;
 }
 /**
  * Avro `array` type for homogeneous collections of items described by a schema.
@@ -40,16 +50,22 @@ export declare class ArrayType<T = unknown> extends BaseType<T[]> {
      */
     check(value: unknown, errorHook?: ErrorHook, path?: string[]): boolean;
     /**
-     * Overrides the base write method to serialize an array.
-     * @param tap The tap to write to.
-     * @param value The array to write.
+     * Writes array without validation.
+     */
+    writeUnchecked(tap: WritableTapLike, value: T[]): Promise<void>;
+    /**
+     * Writes array without validation synchronously.
      */
-    write(tap: WritableTapLike, value: T[]): Promise<void>;
+    writeSyncUnchecked(tap: SyncWritableTapLike, value: T[]): void;
     /**
      * Overrides the base skip method to skip over an array in the tap.
      * @param tap The tap to skip from.
      */
     skip(tap: ReadableTapLike): Promise<void>;
+    /**
+     * Advances the sync tap past the encoded array without decoding elements.
+     */
+    skipSync(tap: SyncReadableTapLike): void;
     /**
      * Overrides the base read method to deserialize an array.
      * @param tap The tap to read from.
@@ -57,11 +73,12 @@ export declare class ArrayType<T = unknown> extends BaseType<T[]> {
      */
     read(tap: ReadableTapLike): Promise<T[]>;
     /**
-     * Overrides the base toBuffer method to serialize an array to a buffer.
-     * @param value The array to serialize.
-     * @returns The serialized buffer.
+     * Reads the entire array synchronously from the tap.
+     */
+    /**
+     * Reads resolved elements synchronously through the item resolver.
      */
-    toBuffer(value: T[]): Promise<ArrayBuffer>;
+    readSync(tap: SyncReadableTapLike): T[];
     /**
      * Overrides the base cloneFromValue method to clone an array.
      * @param value The value to clone.
@@ -91,6 +108,10 @@ export declare class ArrayType<T = unknown> extends BaseType<T[]> {
      * @returns A negative number if tap1 < tap2, zero if equal, positive if tap1 > tap2.
      */
     match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+    /**
+     * Compares two sync taps that encode arrays for ordering.
+     */
+    matchSync(tap1: SyncReadableTapLike, tap2: SyncReadableTapLike): number;
     /**
      * Creates a resolver for schema evolution between array types.
      * @param writerType The writer's array type.