@sachitv/avro-typescript 0.4.0

package/esm/internal/collections/circular_buffer.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 _CircularBuffer_instances, _CircularBuffer_buffer, _CircularBuffer_capacity, _CircularBuffer_windowStart, _CircularBuffer_windowEnd, _CircularBuffer_validateDataSize, _CircularBuffer_slideWindowIfNeeded, _CircularBuffer_addData, _CircularBuffer_validateGetParameters, _CircularBuffer_validateGetRange;
+/**
+ * A circular buffer implementation that maintains a rolling window of Uint8Array data.
+ * Uses copyWithin for efficient window sliding and provides memory-efficient random access.
+ */
+export class CircularBuffer {
+    /**
+     * Creates a new circular buffer with the specified capacity.
+     * @param capacity Maximum number of bytes the buffer can hold
+     * @throws RangeError if capacity is not positive
+     */
+    constructor(capacity) {
+        _CircularBuffer_instances.add(this);
+        _CircularBuffer_buffer.set(this, void 0);
+        _CircularBuffer_capacity.set(this, void 0);
+        _CircularBuffer_windowStart.set(this, void 0);
+        _CircularBuffer_windowEnd.set(this, void 0);
+        if (capacity <= 0) {
+            throw new RangeError("Capacity must be positive");
+        }
+        __classPrivateFieldSet(this, _CircularBuffer_capacity, capacity, "f");
+        __classPrivateFieldSet(this, _CircularBuffer_buffer, new Uint8Array(capacity), "f");
+        __classPrivateFieldSet(this, _CircularBuffer_windowStart, 0, "f");
+        __classPrivateFieldSet(this, _CircularBuffer_windowEnd, 0, "f");
+    }
+    /**
+     * Maximum capacity of the buffer in bytes.
+     */
+    capacity() {
+        return __classPrivateFieldGet(this, _CircularBuffer_capacity, "f");
+    }
+    /**
+     * Current number of bytes in the buffer.
+     */
+    length() {
+        return __classPrivateFieldGet(this, _CircularBuffer_windowEnd, "f") - __classPrivateFieldGet(this, _CircularBuffer_windowStart, "f");
+    }
+    /**
+     * Position in the overall data stream where the current window starts.
+     */
+    windowStart() {
+        return __classPrivateFieldGet(this, _CircularBuffer_windowStart, "f");
+    }
+    /**
+     * Position in the overall data stream where the current window ends (exclusive).
+     */
+    windowEnd() {
+        return __classPrivateFieldGet(this, _CircularBuffer_windowEnd, "f");
+    }
+    /**
+     * Clears the buffer, resetting the window to empty.
+     */
+    clear() {
+        __classPrivateFieldSet(this, _CircularBuffer_windowStart, 0, "f");
+        __classPrivateFieldSet(this, _CircularBuffer_windowEnd, 0, "f");
+    }
+    /**
+     * Adds data to the buffer, sliding the window if necessary.
+     * @param data Uint8Array to add
+     * @throws RangeError if data size exceeds buffer capacity
+     */
+    push(data) {
+        if (data.length === 0) {
+            return;
+        }
+        __classPrivateFieldGet(this, _CircularBuffer_instances, "m", _CircularBuffer_validateDataSize).call(this, data.length);
+        __classPrivateFieldGet(this, _CircularBuffer_instances, "m", _CircularBuffer_slideWindowIfNeeded).call(this, data.length);
+        __classPrivateFieldGet(this, _CircularBuffer_instances, "m", _CircularBuffer_addData).call(this, data);
+    }
+    /**
+     * Retrieves a contiguous sequence of bytes from the buffer.
+     * @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
+     */
+    get(start, size) {
+        __classPrivateFieldGet(this, _CircularBuffer_instances, "m", _CircularBuffer_validateGetParameters).call(this, start, size);
+        __classPrivateFieldGet(this, _CircularBuffer_instances, "m", _CircularBuffer_validateGetRange).call(this, start, size);
+        const bufferStart = start - __classPrivateFieldGet(this, _CircularBuffer_windowStart, "f");
+        return __classPrivateFieldGet(this, _CircularBuffer_buffer, "f").subarray(bufferStart, bufferStart + size);
+    }
+}
+_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")}`);
+    }
+}, _CircularBuffer_slideWindowIfNeeded = function _CircularBuffer_slideWindowIfNeeded(dataSize) {
+    const currentLength = this.length();
+    if (currentLength + dataSize > __classPrivateFieldGet(this, _CircularBuffer_capacity, "f")) {
+        const slideAmount = (currentLength + dataSize) - __classPrivateFieldGet(this, _CircularBuffer_capacity, "f");
+        const newWindowStart = __classPrivateFieldGet(this, _CircularBuffer_windowStart, "f") + slideAmount;
+        // Slide the window using copyWithin
+        const shift = newWindowStart - __classPrivateFieldGet(this, _CircularBuffer_windowStart, "f");
+        if (shift > 0 && shift <= currentLength) {
+            __classPrivateFieldGet(this, _CircularBuffer_buffer, "f").copyWithin(0, shift, currentLength);
+            __classPrivateFieldSet(this, _CircularBuffer_windowStart, newWindowStart, "f");
+            __classPrivateFieldSet(this, _CircularBuffer_windowEnd, __classPrivateFieldGet(this, _CircularBuffer_windowStart, "f") + (currentLength - shift), "f");
+        }
+    }
+}, _CircularBuffer_addData = function _CircularBuffer_addData(data) {
+    const bufferOffset = __classPrivateFieldGet(this, _CircularBuffer_windowEnd, "f") - __classPrivateFieldGet(this, _CircularBuffer_windowStart, "f");
+    __classPrivateFieldGet(this, _CircularBuffer_buffer, "f").set(data, bufferOffset);
+    __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")}`);
+    }
+    if (size < 0) {
+        throw new RangeError(`Size ${size} cannot be negative`);
+    }
+}, _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")}`);
+    }
+};

package/esm/internal/crypto/md5.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Computes MD5 hash from string.
+ * @param value The string to hash.
+ * @returns The MD5 hash as a Uint8Array.
+ */
+export declare function md5FromString(value: string): Uint8Array;
+/**
+ * Computes MD5 hash from Uint8Array.
+ * @param input The input bytes to hash.
+ * @returns The MD5 hash as a Uint8Array.
+ */
+export declare function md5(input: Uint8Array): Uint8Array;

package/esm/internal/crypto/md5.js

@@ -0,0 +1,158 @@
+const S = [
+    7,
+    12,
+    17,
+    22,
+    7,
+    12,
+    17,
+    22,
+    7,
+    12,
+    17,
+    22,
+    7,
+    12,
+    17,
+    22,
+    5,
+    9,
+    14,
+    20,
+    5,
+    9,
+    14,
+    20,
+    5,
+    9,
+    14,
+    20,
+    5,
+    9,
+    14,
+    20,
+    4,
+    11,
+    16,
+    23,
+    4,
+    11,
+    16,
+    23,
+    4,
+    11,
+    16,
+    23,
+    4,
+    11,
+    16,
+    23,
+    6,
+    10,
+    15,
+    21,
+    6,
+    10,
+    15,
+    21,
+    6,
+    10,
+    15,
+    21,
+    6,
+    10,
+    15,
+    21,
+];
+const K = new Uint32Array(64);
+for (let i = 0; i < 64; i++) {
+    K[i] = Math.floor(Math.abs(Math.sin(i + 1)) * 2 ** 32);
+}
+const textEncoder = new TextEncoder();
+/**
+ * Computes MD5 hash from string.
+ * @param value The string to hash.
+ * @returns The MD5 hash as a Uint8Array.
+ */
+export function md5FromString(value) {
+    return md5(textEncoder.encode(value));
+}
+/**
+ * Computes MD5 hash from Uint8Array.
+ * @param input The input bytes to hash.
+ * @returns The MD5 hash as a Uint8Array.
+ */
+export function md5(input) {
+    const data = pad(input);
+    let a = 0x67452301;
+    let b = 0xefcdab89;
+    let c = 0x98badcfe;
+    let d = 0x10325476;
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    for (let offset = 0; offset < data.byteLength; offset += 64) {
+        const chunk = new Uint32Array(16);
+        for (let i = 0; i < 16; i++) {
+            chunk[i] = view.getUint32(offset + i * 4, true);
+        }
+        let A = a;
+        let B = b;
+        let C = c;
+        let D = d;
+        for (let i = 0; i < 64; i++) {
+            let F;
+            let g;
+            if (i < 16) {
+                F = (B & C) | (~B & D);
+                g = i;
+            }
+            else if (i < 32) {
+                F = (D & B) | (~D & C);
+                g = (5 * i + 1) % 16;
+            }
+            else if (i < 48) {
+                F = B ^ C ^ D;
+                g = (3 * i + 5) % 16;
+            }
+            else {
+                F = C ^ (B | ~D);
+                g = (7 * i) % 16;
+            }
+            const temp = D;
+            D = C;
+            C = B;
+            const sum = (A + F + K[i] + chunk[g]) >>> 0;
+            const rotated = rotateLeft(sum, S[i]);
+            B = (B + rotated) >>> 0;
+            A = temp;
+        }
+        a = (a + A) >>> 0;
+        b = (b + B) >>> 0;
+        c = (c + C) >>> 0;
+        d = (d + D) >>> 0;
+    }
+    const result = new Uint8Array(16);
+    const resultView = new DataView(result.buffer);
+    resultView.setUint32(0, a, true);
+    resultView.setUint32(4, b, true);
+    resultView.setUint32(8, c, true);
+    resultView.setUint32(12, d, true);
+    return result;
+}
+function rotateLeft(value, shift) {
+    return ((value << shift) | (value >>> (32 - shift))) >>> 0;
+}
+function pad(input) {
+    const bitLength = BigInt(input.length) * 8n;
+    let paddingLength = 56 - (input.length + 1) % 64;
+    if (paddingLength < 0) {
+        paddingLength += 64;
+    }
+    const totalLength = input.length + 1 + paddingLength + 8;
+    const output = new Uint8Array(totalLength);
+    output.set(input, 0);
+    output[input.length] = 0x80;
+    const view = new DataView(output.buffer);
+    view.setUint32(totalLength - 8, Number(bitLength & 0xffffffffn), true);
+    view.setUint32(totalLength - 4, Number((bitLength >> 32n) & 0xffffffffn), true);
+    return output;
+}

package/esm/internal/varint.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculates the number of bytes required to encode a value as a zigzag varint.
+ * @param value The number or bigint to encode.
+ * @returns The size in bytes (1-10).
+ */
+export declare function calculateVarintSize(value: number | bigint): number;

package/esm/internal/varint.js

@@ -0,0 +1,30 @@
+/**
+ * Calculates the number of bytes required to encode a value as a zigzag varint.
+ * @param value The number or bigint to encode.
+ * @returns The size in bytes (1-10).
+ */
+export function calculateVarintSize(value) {
+    const val = typeof value === "number" ? BigInt(value) : value;
+    // Zigzag encoding: (val << 1) ^ (val >> 63)
+    const zigzag = (val << 1n) ^ (val >> 63n);
+    // Now calculate varint size for the unsigned zigzag value
+    if (zigzag < 128n)
+        return 1;
+    if (zigzag < 16384n)
+        return 2;
+    if (zigzag < 2097152n)
+        return 3;
+    if (zigzag < 268435456n)
+        return 4;
+    if (zigzag < 34359738368n)
+        return 5;
+    if (zigzag < 4398046511104n)
+        return 6;
+    if (zigzag < 562949953421312n)
+        return 7;
+    if (zigzag < 72057594037927936n)
+        return 8;
+    if (zigzag < 9223372036854775808n)
+        return 9;
+    return 10;
+}

package/esm/mod.d.ts

@@ -0,0 +1,77 @@
+import "./_dnt.polyfills.js";
+export { AvroReader } from "./avro_reader.js";
+export { AvroWriter } from "./avro_writer.js";
+export { createType } from "./type/create_type.js";
+export { Type } from "./schemas/type.js";
+export { BaseType } from "./schemas/base_type.js";
+export { PrimitiveType } from "./schemas/primitive/primitive_type.js";
+export { FixedSizeBaseType } from "./schemas/primitive/fixed_size_base_type.js";
+export { NamedType } from "./schemas/complex/named_type.js";
+export { LogicalType, NamedLogicalType, withLogicalTypeJSON, } from "./schemas/logical/logical_type.js";
+export { BooleanType } from "./schemas/primitive/boolean_type.js";
+export { IntType } from "./schemas/primitive/int_type.js";
+export { LongType } from "./schemas/primitive/long_type.js";
+export { FloatType } from "./schemas/primitive/float_type.js";
+export { DoubleType } from "./schemas/primitive/double_type.js";
+export { BytesType } from "./schemas/primitive/bytes_type.js";
+export { StringType } from "./schemas/primitive/string_type.js";
+export { NullType } from "./schemas/primitive/null_type.js";
+export { RecordType } from "./schemas/complex/record_type.js";
+export { ArrayType } from "./schemas/complex/array_type.js";
+export { MapType } from "./schemas/complex/map_type.js";
+export { UnionType } from "./schemas/complex/union_type.js";
+export { EnumType } from "./schemas/complex/enum_type.js";
+export { FixedType } from "./schemas/complex/fixed_type.js";
+export { UuidLogicalType } from "./schemas/logical/uuid_logical_type.js";
+export { DecimalLogicalType } from "./schemas/logical/decimal_logical_type.js";
+export { DurationLogicalType } from "./schemas/logical/duration_logical_type.js";
+export { DateLogicalType } from "./schemas/logical/temporal_logical_types.js";
+export { TimeMillisLogicalType } from "./schemas/logical/temporal_logical_types.js";
+export { TimeMicrosLogicalType } from "./schemas/logical/temporal_logical_types.js";
+export { TimestampMillisLogicalType } from "./schemas/logical/temporal_logical_types.js";
+export { TimestampMicrosLogicalType } from "./schemas/logical/temporal_logical_types.js";
+export { TimestampNanosLogicalType } from "./schemas/logical/temporal_logical_types.js";
+export { LocalTimestampMillisLogicalType } from "./schemas/logical/temporal_logical_types.js";
+export { LocalTimestampMicrosLogicalType } from "./schemas/logical/temporal_logical_types.js";
+export { LocalTimestampNanosLogicalType } from "./schemas/logical/temporal_logical_types.js";
+export { Resolver } from "./schemas/resolver.js";
+export { ValidationError } from "./schemas/error.js";
+export { safeStringify } from "./schemas/json.js";
+export type { AvroFileParserOptions, AvroHeader, ParsedAvroHeader, } from "./serialization/avro_file_parser.js";
+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 { BLOCK_TYPE, HEADER_TYPE, MAGIC_BYTES, } from "./serialization/avro_constants.js";
+export type { IReadableAndWritableBuffer, IReadableBuffer, IWritableBuffer, } from "./serialization/buffers/buffer.js";
+export { BlobReadableBuffer } from "./serialization/buffers/blob_readable_buffer.js";
+export { InMemoryReadableBuffer, InMemoryWritableBuffer, } from "./serialization/buffers/in_memory_buffer.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";
+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 type { Encoder } from "./serialization/encoders/encoder.js";
+export type { Decoder } from "./serialization/decoders/decoder.js";
+export { NullEncoder } from "./serialization/encoders/null_encoder.js";
+export { DeflateEncoder } from "./serialization/encoders/deflate_encoder.js";
+export { NullDecoder } from "./serialization/decoders/null_decoder.js";
+export { DeflateDecoder } from "./serialization/decoders/deflate_decoder.js";
+export type { ReadableTapLike, WritableTapLike } from "./serialization/tap.js";
+export { ReadableTap, WritableTap } from "./serialization/tap.js";
+export { decode, encode } from "./serialization/text_encoding.js";
+export { Protocol } from "./rpc/protocol_core.js";
+export { MessageEndpoint } from "./rpc/message_endpoint/base.js";
+export { MessageEmitter, StatelessEmitter, } from "./rpc/message_endpoint/emitter.js";
+export { MessageListener, StatelessListener, } from "./rpc/message_endpoint/listener.js";
+export type { CallRequestEnvelopeOptions, MessageDefinition, MessageTransportOptions, ProtocolDefinition, ProtocolHandlerContext, ProtocolInfo, ProtocolLike, ProtocolOptions, ResolverEntry, } from "./rpc/definitions/protocol_definitions.js";
+export { Message } from "./rpc/definitions/message_definition.js";
+export type { HandshakeRequestInit, HandshakeRequestMessage, HandshakeResponseInit, HandshakeResponseMessage, } from "./rpc/protocol/wire_format/handshake.js";
+export type { CallRequestEnvelope, CallRequestInit, CallRequestMessage, CallResponseEnvelope, CallResponseInit, CallResponseMessage, DecodeCallRequestOptions, DecodeCallResponseOptions, } from "./rpc/protocol/wire_format/messages.js";
+export type { DecodeFramedMessageOptions, DecodeFramedMessageResult, FrameMessageOptions, } from "./rpc/protocol/wire_format/framing.js";
+export type { BinaryDuplex, BinaryDuplexLike, BinaryReadable, BinaryWritable, FetchTransportOptions, WebSocketTransportOptions, } from "./rpc/protocol/transports/transport_helpers.js";
+export type { InMemoryTransportPair } from "./rpc/protocol/transports/in_memory.js";
+export { createFetchTransport } from "./rpc/protocol/transports/fetch.js";
+export { createWebSocketTransport } from "./rpc/protocol/transports/websocket.js";
+export { createInMemoryTransport, createInMemoryTransportPair, } from "./rpc/protocol/transports/in_memory.js";

package/esm/mod.js

@@ -0,0 +1,73 @@
+// Core Avro functionality
+import "./_dnt.polyfills.js";
+export { AvroReader } from "./avro_reader.js";
+export { AvroWriter } from "./avro_writer.js";
+export { createType } from "./type/create_type.js";
+// Schema types
+export { Type } from "./schemas/type.js";
+export { BaseType } from "./schemas/base_type.js";
+export { PrimitiveType } from "./schemas/primitive/primitive_type.js";
+export { FixedSizeBaseType } from "./schemas/primitive/fixed_size_base_type.js";
+export { NamedType } from "./schemas/complex/named_type.js";
+export { LogicalType, NamedLogicalType, withLogicalTypeJSON, } from "./schemas/logical/logical_type.js";
+// Primitive types
+export { BooleanType } from "./schemas/primitive/boolean_type.js";
+export { IntType } from "./schemas/primitive/int_type.js";
+export { LongType } from "./schemas/primitive/long_type.js";
+export { FloatType } from "./schemas/primitive/float_type.js";
+export { DoubleType } from "./schemas/primitive/double_type.js";
+export { BytesType } from "./schemas/primitive/bytes_type.js";
+export { StringType } from "./schemas/primitive/string_type.js";
+export { NullType } from "./schemas/primitive/null_type.js";
+// Complex types
+export { RecordType } from "./schemas/complex/record_type.js";
+export { ArrayType } from "./schemas/complex/array_type.js";
+export { MapType } from "./schemas/complex/map_type.js";
+export { UnionType } from "./schemas/complex/union_type.js";
+export { EnumType } from "./schemas/complex/enum_type.js";
+export { FixedType } from "./schemas/complex/fixed_type.js";
+// Logical types
+export { UuidLogicalType } from "./schemas/logical/uuid_logical_type.js";
+export { DecimalLogicalType } from "./schemas/logical/decimal_logical_type.js";
+export { DurationLogicalType } from "./schemas/logical/duration_logical_type.js";
+export { DateLogicalType } from "./schemas/logical/temporal_logical_types.js";
+export { TimeMillisLogicalType } from "./schemas/logical/temporal_logical_types.js";
+export { TimeMicrosLogicalType } from "./schemas/logical/temporal_logical_types.js";
+export { TimestampMillisLogicalType } from "./schemas/logical/temporal_logical_types.js";
+export { TimestampMicrosLogicalType } from "./schemas/logical/temporal_logical_types.js";
+export { TimestampNanosLogicalType } from "./schemas/logical/temporal_logical_types.js";
+export { LocalTimestampMillisLogicalType } from "./schemas/logical/temporal_logical_types.js";
+export { LocalTimestampMicrosLogicalType } from "./schemas/logical/temporal_logical_types.js";
+export { LocalTimestampNanosLogicalType } from "./schemas/logical/temporal_logical_types.js";
+// Schema utilities
+export { Resolver } from "./schemas/resolver.js";
+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 { 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 { 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 { NullEncoder } from "./serialization/encoders/null_encoder.js";
+export { DeflateEncoder } from "./serialization/encoders/deflate_encoder.js";
+export { NullDecoder } from "./serialization/decoders/null_decoder.js";
+export { DeflateDecoder } from "./serialization/decoders/deflate_decoder.js";
+export { ReadableTap, WritableTap } from "./serialization/tap.js";
+// Utilities
+export { decode, encode } from "./serialization/text_encoding.js";
+// RPC - Protocols
+export { Protocol } from "./rpc/protocol_core.js";
+// RPC - Message endpoints
+export { MessageEndpoint } from "./rpc/message_endpoint/base.js";
+export { MessageEmitter, StatelessEmitter, } from "./rpc/message_endpoint/emitter.js";
+export { MessageListener, StatelessListener, } from "./rpc/message_endpoint/listener.js";
+export { Message } from "./rpc/definitions/message_definition.js";
+export { createFetchTransport } from "./rpc/protocol/transports/fetch.js";
+export { createWebSocketTransport } from "./rpc/protocol/transports/websocket.js";
+export { createInMemoryTransport, createInMemoryTransportPair, } from "./rpc/protocol/transports/in_memory.js";

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/rpc/definitions/message_definition.d.ts

@@ -0,0 +1,34 @@
+import { type CreateTypeOptions } from "../../type/create_type.js";
+import type { RecordType } from "../../schemas/complex/record_type.js";
+import type { UnionType } from "../../schemas/complex/union_type.js";
+import type { Type } from "../../schemas/type.js";
+import type { MessageDefinition } from "./protocol_definitions.js";
+/**
+ * Schema-aware representation of an Avro RPC message definition including
+ * request, response, and error types.
+ */
+export declare class Message {
+    /** The name of the message. */
+    readonly name: string;
+    /** Optional documentation for the message. */
+    readonly doc?: string;
+    /** The record type representing the request parameters. */
+    readonly requestType: RecordType;
+    /** The type returned by the message (if not one-way). */
+    readonly responseType: Type;
+    /** The union type of possible errors. */
+    readonly errorType: UnionType;
+    /** Whether the message is one-way (no response). */
+    readonly oneWay: boolean;
+    /**
+     * Creates a new Message definition.
+     * @param name The name of the message.
+     * @param attrs The message attributes from the protocol definition.
+     * @param opts Options for creating types (namespace, registry).
+     */
+    constructor(name: string, attrs: MessageDefinition, opts: CreateTypeOptions);
+    /**
+     * Converts the message definition back to a JSON-compatible object.
+     */
+    toJSON(): Record<string, unknown>;
+}

package/esm/rpc/definitions/message_definition.js

@@ -0,0 +1,105 @@
+import { createType } from "../../type/create_type.js";
+import { NullType } from "../../schemas/primitive/null_type.js";
+/**
+ * Schema-aware representation of an Avro RPC message definition including
+ * request, response, and error types.
+ */
+export class Message {
+    /**
+     * Creates a new Message definition.
+     * @param name The name of the message.
+     * @param attrs The message attributes from the protocol definition.
+     * @param opts Options for creating types (namespace, registry).
+     */
+    constructor(name, attrs, opts) {
+        /** The name of the message. */
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Optional documentation for the message. */
+        Object.defineProperty(this, "doc", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The record type representing the request parameters. */
+        Object.defineProperty(this, "requestType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The type returned by the message (if not one-way). */
+        Object.defineProperty(this, "responseType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The union type of possible errors. */
+        Object.defineProperty(this, "errorType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Whether the message is one-way (no response). */
+        Object.defineProperty(this, "oneWay", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = name;
+        this.doc = attrs.doc;
+        this.requestType = createType({
+            name,
+            type: "request",
+            fields: attrs.request,
+        }, opts);
+        if (!attrs.response) {
+            throw new Error("missing response");
+        }
+        this.responseType = createType(attrs.response, opts);
+        const errors = attrs.errors ? attrs.errors.slice() : [];
+        errors.unshift("string");
+        this.errorType = createType(errors, opts);
+        this.oneWay = !!attrs["one-way"];
+        if (this.oneWay) {
+            if (!(this.responseType instanceof NullType)) {
+                throw new Error("one-way messages must return 'null'");
+            }
+            if (this.errorType.getTypes().length > 1) {
+                throw new Error("one-way messages cannot declare errors");
+            }
+        }
+    }
+    /**
+     * Converts the message definition back to a JSON-compatible object.
+     */
+    toJSON() {
+        const json = {
+            request: extractRequestFields(this.requestType),
+            response: this.responseType.toJSON(),
+        };
+        if (this.doc) {
+            json.doc = this.doc;
+        }
+        if (this.oneWay) {
+            json["one-way"] = true;
+        }
+        const errors = this.errorType.toJSON();
+        if (Array.isArray(errors) && errors.length > 1) {
+            json.errors = errors.slice(1);
+        }
+        return json;
+    }
+}
+function extractRequestFields(requestType) {
+    const json = requestType.toJSON();
+    return json.fields;
+}