@sachitv/avro-typescript 0.4.0

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

@@ -0,0 +1,197 @@
+import type { CreateTypeOptions, SchemaLike } from "../../type/create_type.js";
+import type { MetadataMap } from "../protocol/wire_format/metadata.js";
+import type { CallRequestEnvelope } from "../protocol/wire_format/messages.js";
+import type { Resolver } from "../../schemas/resolver.js";
+import type { Type } from "../../schemas/type.js";
+import type { Message } from "./message_definition.js";
+/**
+ * Represents the definition of an Avro protocol, which includes the protocol name, optional namespace,
+ * optional custom types, and a map of message definitions.
+ */
+export interface ProtocolDefinition {
+    /** The name of the protocol. */
+    protocol: string;
+    /** Optional namespace for the protocol. */
+    namespace?: string;
+    /** Optional array of custom schema types defined in the protocol. */
+    types?: SchemaLike[];
+    /** Optional record of message names to their definitions. */
+    messages?: Record<string, MessageDefinition>;
+}
+/**
+ * Defines a message within an Avro protocol, specifying the request parameters, response type,
+ * possible errors, and whether it's one-way.
+ */
+export interface MessageDefinition {
+    /** Optional documentation for the message. */
+    doc?: string;
+    /** Array of schemas for the request parameters. */
+    request: SchemaLike[];
+    /** Schema for the response. */
+    response: SchemaLike;
+    /** Optional array of schemas for possible error types. */
+    errors?: SchemaLike[];
+    /** Optional flag indicating if the message is one-way (no response expected). */
+    "one-way"?: boolean;
+}
+/**
+ * Options for creating protocol types, extending CreateTypeOptions.
+ */
+export interface ProtocolOptions extends CreateTypeOptions {
+}
+/**
+ * Options for configuring message transport behavior in RPC communications.
+ * These options control aspects such as buffering, framing, transport mode,
+ * and protocol exposure for schema discovery.
+ */
+export interface MessageTransportOptions {
+    /**
+     * The size of the buffer used for reading/writing data. When undefined,
+     * the transport implementation determines the buffer size, often defaulting
+     * to a reasonable value or unlimited capacity.
+     */
+    bufferSize?: number;
+    /**
+     * The maximum size of each frame in the message stream. Defaults to 8192.
+     */
+    frameSize?: number;
+    /**
+     * The transport mode: "stateless" for request-response (e.g., HTTP),
+     * or "stateful" for persistent connections (e.g., WebSockets). Defaults to "stateless".
+     */
+    mode?: "stateless" | "stateful";
+    /**
+     * Custom decoder for call request envelopes. Defaults to decodeCallRequestEnvelope.
+     */
+    requestDecoder?: CallRequestEnvelopeDecoder;
+    /**
+     * When enabled, allows clients to discover the server's protocol schema
+     * even when their protocol hash is unknown. This facilitates schema evolution
+     * and interoperability by providing the server protocol in handshake responses.
+     * Enable this option to support server schema discovery in development or
+     * trusted environments. Defaults to false.
+     */
+    exposeProtocol?: boolean;
+    /**
+     * Maximum size in bytes for incoming request payloads. This prevents DoS attacks
+     * by limiting memory usage. Defaults to 10MB (10 * 1024 * 1024).
+     */
+    maxRequestSize?: number;
+    /**
+     * Timeout in milliseconds for processing a single request. This prevents
+     * resource exhaustion from hanging connections. Defaults to 30000 (30 seconds).
+     */
+    requestTimeout?: number;
+}
+/**
+ * Context provided to message handlers during RPC processing.
+ */
+export interface ProtocolHandlerContext {
+    /** Metadata map associated with the message. */
+    metadata: MetadataMap;
+}
+/**
+ * Options for decoding call request envelopes.
+ */
+export interface CallRequestEnvelopeOptions {
+    /** Whether to expect a handshake in the envelope. */
+    expectHandshake?: boolean;
+}
+/**
+ * Function type for decoding call request envelopes from a buffer.
+ */
+export type CallRequestEnvelopeDecoder = (buffer: ArrayBuffer, options?: CallRequestEnvelopeOptions) => Promise<CallRequestEnvelope>;
+/**
+ * Interface for a message listener in the RPC system.
+ */
+export interface MessageListener {
+    /**
+     * Protocol that produced this listener so handlers can inspect it.
+     */
+    readonly protocol: ProtocolLike;
+}
+/**
+ * Function type for handling incoming messages.
+ */
+export type MessageHandler = (request: unknown, listener: MessageListener, context: ProtocolHandlerContext) => Promise<unknown> | unknown;
+/**
+ * Entry containing resolvers for request, response, and error schemas.
+ */
+export interface ResolverEntry {
+    /** Optional resolver for the response schema. */
+    response?: Resolver;
+    /** Optional resolver for error schemas. */
+    error?: Resolver;
+    /** Optional resolver for the request schema. */
+    request?: Resolver;
+}
+/**
+ * Represents an Avro RPC protocol instance, providing access to message definitions,
+ * handlers, resolvers for schema compatibility, and protocol metadata.
+ */
+export interface ProtocolLike {
+    /** The unique hash key identifying this protocol for compatibility checks. */
+    hashKey: string;
+    /** Returns the hash bytes used for protocol identification. */
+    getHashBytes(): Uint8Array;
+    /**
+     * Return a shallow copy of the protocol messages map. Mutating the returned
+     * map has no effect on the owning protocol.
+     */
+    getMessages(): ReadonlyMap<string, Message>;
+    /**
+     * Returns the message definition for `name`. The exposed message remains
+     * immutable from the protocol's perspective.
+     */
+    getMessage(name: string): Message | undefined;
+    /**
+     * Returns a fresh array of message names to prevent external consumers from
+     * mutating the internal tracking array.
+     */
+    getMessageNames(): readonly string[];
+    /** Retrieves the message definition for the given message name. */
+    getMessageDefinition(name: string): MessageDefinition | undefined;
+    /** Gets the handler function for the specified message name. */
+    getHandler(name: string): MessageHandler | undefined;
+    /** Checks if resolvers are available for listening to messages from a protocol with the given hash key. */
+    hasListenerResolvers(hashKey: string): boolean;
+    /** Checks if resolvers are available for emitting messages to a protocol with the given hash key. */
+    hasEmitterResolvers(hashKey: string): boolean;
+    /** Ensures that resolvers for emitting messages to the remote protocol are set up. */
+    ensureEmitterResolvers(hashKey: string, remote: ProtocolLike): void;
+    /** Ensures that resolvers for listening to messages from the emitter protocol are set up. */
+    ensureListenerResolvers(hashKey: string, emitterProtocol: ProtocolLike): void;
+    /** Retrieves resolvers for emitting the specified message to a protocol with the given hash key. */
+    getEmitterResolvers(hashKey: string, messageName: string): ResolverEntry | undefined;
+    /** Retrieves resolvers for listening to the specified message from a protocol with the given hash key. */
+    getListenerResolvers(hashKey: string, messageName: string): ResolverEntry | undefined;
+    /** Returns a string representation of the protocol. */
+    toString(): string;
+    /** Gets the name of the protocol. */
+    getName(): string;
+    /** Returns an array of named types defined in the protocol. */
+    getNamedTypes(): Type[];
+    /** Retrieves metadata information about the protocol. */
+    getProtocolInfo(): ProtocolInfo;
+}
+/**
+ * Metadata information about an Avro RPC protocol.
+ */
+export interface ProtocolInfo {
+    /** The name of the protocol. */
+    name: string;
+    /** Optional namespace for the protocol. */
+    namespace?: string;
+    /** The unique hash key for the protocol. */
+    hashKey: string;
+    /** The hash bytes for protocol identification. */
+    hashBytes: Uint8Array;
+    /**
+     * Fresh array to guarantee the caller can't mutate the recorded list.
+     */
+    messageNames: readonly string[];
+}
+/**
+ * A factory function type for creating a ProtocolLike instance from a protocol definition.
+ */
+export type ProtocolFactory<T extends ProtocolLike = ProtocolLike> = (definition: ProtocolDefinition) => T;

package/esm/rpc/definitions/protocol_definitions.js

@@ -0,0 +1 @@
+export {};

package/esm/rpc/message_endpoint/base.d.ts

@@ -0,0 +1,43 @@
+import type { HandshakeRequestInit, HandshakeRequestMessage, HandshakeResponseInit, HandshakeResponseMessage } from "../protocol/wire_format/handshake.js";
+import type { MessageTransportOptions, ProtocolLike } from "../definitions/protocol_definitions.js";
+/**
+ * Abstract base class for message endpoints in Avro RPC.
+ * Extends EventTarget to dispatch events like errors, handshakes, and end-of-transmission.
+ */
+export declare abstract class MessageEndpoint extends EventTarget {
+    /**
+     * The Avro protocol definition that this endpoint adheres to.
+     */
+    readonly protocol: ProtocolLike;
+    /**
+     * The size of the internal buffer used for reading and writing messages.
+     */
+    protected readonly bufferSize: number;
+    /**
+     * The maximum size of individual frames in the message transport protocol.
+     */
+    protected readonly frameSize: number;
+    /**
+     * Initializes the endpoint with protocol and transport options.
+     * @param protocol The Avro protocol definition.
+     * @param opts Transport configuration options.
+     */
+    protected constructor(protocol: ProtocolLike, opts: MessageTransportOptions);
+    /**
+     * Dispatches an error event with the given error.
+     * Converts non-Error values to Error instances and uses ErrorEvent if available.
+     * @param err The error to dispatch.
+     */
+    protected dispatchError(err: unknown): void;
+    /**
+     * Dispatches a handshake event with request and response details.
+     * @param request The handshake request data.
+     * @param response The handshake response data.
+     */
+    protected dispatchHandshake(request: HandshakeRequestInit | HandshakeRequestMessage, response: HandshakeResponseInit | HandshakeResponseMessage): void;
+    /**
+     * Dispatches an end-of-transmission event with the number of pending operations.
+     * @param pending The number of pending operations.
+     */
+    protected dispatchEot(pending: number): void;
+}

package/esm/rpc/message_endpoint/base.js

@@ -0,0 +1,81 @@
+/**
+ * Abstract base class for message endpoints in Avro RPC.
+ * Extends EventTarget to dispatch events like errors, handshakes, and end-of-transmission.
+ */
+export class MessageEndpoint extends EventTarget {
+    /**
+     * Initializes the endpoint with protocol and transport options.
+     * @param protocol The Avro protocol definition.
+     * @param opts Transport configuration options.
+     */
+    constructor(protocol, opts) {
+        super();
+        /**
+         * The Avro protocol definition that this endpoint adheres to.
+         */
+        Object.defineProperty(this, "protocol", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * The size of the internal buffer used for reading and writing messages.
+         */
+        Object.defineProperty(this, "bufferSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * The maximum size of individual frames in the message transport protocol.
+         */
+        Object.defineProperty(this, "frameSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.protocol = protocol;
+        this.bufferSize = opts.bufferSize ?? 2048;
+        this.frameSize = opts.frameSize ?? 2048;
+    }
+    /**
+     * Dispatches an error event with the given error.
+     * Converts non-Error values to Error instances and uses ErrorEvent if available.
+     * @param err The error to dispatch.
+     */
+    dispatchError(err) {
+        let error;
+        if (err instanceof Error) {
+            error = err;
+        }
+        else {
+            error = new Error(String(err));
+        }
+        if (typeof ErrorEvent === "function") {
+            this.dispatchEvent(new ErrorEvent("error", { error }));
+        }
+        else {
+            this.dispatchEvent(new CustomEvent("error", { detail: error }));
+        }
+    }
+    /**
+     * Dispatches a handshake event with request and response details.
+     * @param request The handshake request data.
+     * @param response The handshake response data.
+     */
+    dispatchHandshake(request, response) {
+        this.dispatchEvent(new CustomEvent("handshake", {
+            detail: { request, response },
+        }));
+    }
+    /**
+     * Dispatches an end-of-transmission event with the number of pending operations.
+     * @param pending The number of pending operations.
+     */
+    dispatchEot(pending) {
+        this.dispatchEvent(new CustomEvent("eot", { detail: { pending } }));
+    }
+}

package/esm/rpc/message_endpoint/emitter.d.ts

@@ -0,0 +1,96 @@
+import type { HandshakeRequestInit, HandshakeResponseMessage } from "../protocol/wire_format/handshake.js";
+import type { MessageTransportOptions, ProtocolFactory, ProtocolLike } from "../definitions/protocol_definitions.js";
+import { MessageEndpoint } from "./base.js";
+import type { Message } from "../definitions/message_definition.js";
+import type { BinaryDuplexLike } from "../protocol/transports/transport_helpers.js";
+/**
+ * Abstract base class for message emitters in Avro RPC.
+ * Manages server hash, destruction state, and handshake protocol for RPC communication.
+ */
+export declare abstract class MessageEmitter extends MessageEndpoint {
+    #private;
+    /**
+     * Initializes the emitter with protocol and options, setting initial server hash.
+     * @param protocol The Avro protocol.
+     * @param opts Transport options.
+     */
+    protected constructor(protocol: ProtocolLike, opts: MessageTransportOptions);
+    /**
+     * Gets whether the emitter has been destroyed.
+     */
+    get destroyed(): boolean;
+    /**
+     * Destroys the emitter, marking it as destroyed and dispatching end-of-transmission.
+     */
+    destroy(): void;
+    /**
+     * Gets the current server hash bytes.
+     */
+    protected get serverHash(): Uint8Array;
+    /**
+     * Updates the server hash with new bytes and recomputes the hex key.
+     * @param bytes The new server hash bytes.
+     */
+    protected updateServerHash(bytes: Uint8Array): void;
+    /**
+     * Gets the current server hash as a hex string key.
+     */
+    protected get serverHashKey(): string;
+    /**
+     * Builds a handshake request object with client/server hashes and optional protocol.
+     * @param omitProtocol Whether to omit the client protocol string.
+     * @returns The handshake request data.
+     */
+    protected buildHandshakeRequest(omitProtocol: boolean): {
+        clientHash: Uint8Array;
+        clientProtocol: string | null;
+        serverHash: Uint8Array;
+    };
+    /**
+     * Finalizes the handshake by dispatching events, handling errors, and determining retry.
+     * Updates server hash if provided and checks for protocol mismatches.
+     * @param request The handshake request.
+     * @param response The handshake response.
+     * @returns Object indicating if retry is needed and the server hash.
+     */
+    protected finalizeHandshake(request: HandshakeRequestInit, response: HandshakeResponseMessage): {
+        retry: boolean;
+        serverHash: Uint8Array;
+    };
+    /**
+     * Sends an RPC message with the given request data.
+     * @param message The message definition.
+     * @param request The request payload.
+     * @returns Promise resolving to the response or undefined for one-way calls.
+     */
+    abstract send(message: Message, request: unknown): Promise<unknown>;
+}
+/**
+ * Stateless implementation of MessageEmitter for Avro RPC.
+ * Creates a new transport connection for each RPC call, enabling stateless communication.
+ * Handles encoding requests, performing handshakes, decoding responses, and tracking pending calls.
+ */
+export declare class StatelessEmitter extends MessageEmitter {
+    #private;
+    /**
+     * Initializes the stateless emitter with protocol, transport factory, options, and protocol factory.
+     * @param protocol The Avro protocol.
+     * @param transportFactory Factory function to create binary duplex transports.
+     * @param opts Transport options.
+     * @param protocolFactory Factory to create protocols from JSON.
+     */
+    constructor(protocol: ProtocolLike, transportFactory: () => Promise<BinaryDuplexLike>, opts: MessageTransportOptions, protocolFactory: ProtocolFactory);
+    /**
+     * Destroys the emitter, rejecting all pending calls and clearing the set.
+     */
+    destroy(): void;
+    /**
+     * Sends an RPC message, handling one-way and request-response calls.
+     * For one-way calls, performs the call and returns undefined.
+     * For request-response, tracks the pending call and returns the result.
+     * @param message The message to send.
+     * @param request The request data.
+     * @returns Promise resolving to response or undefined.
+     */
+    send(message: Message, request: unknown): Promise<unknown>;
+}

package/esm/rpc/message_endpoint/emitter.js

@@ -0,0 +1,245 @@
+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 _MessageEmitter_serverHash, _MessageEmitter_serverHashKey, _MessageEmitter_destroyed, _StatelessEmitter_instances, _StatelessEmitter_transportFactory, _StatelessEmitter_pending, _StatelessEmitter_nextId, _StatelessEmitter_protocolFactory, _StatelessEmitter_trackPending, _StatelessEmitter_performCall;
+import { decodeCallResponseEnvelope, encodeCallRequest, } from "../protocol/wire_format/messages.js";
+import { frameMessage } from "../protocol/wire_format/framing.js";
+import { bytesToHex, metadataWithId, toArrayBuffer, } from "../protocol/protocol_helpers.js";
+import { MessageEndpoint } from "./base.js";
+import { toBinaryDuplex } from "../protocol/transports/transport_helpers.js";
+import { readResponsePayload } from "./helpers.js";
+import { drainReadable, readSingleMessage } from "./helpers.js";
+/**
+ * Abstract base class for message emitters in Avro RPC.
+ * Manages server hash, destruction state, and handshake protocol for RPC communication.
+ */
+export class MessageEmitter extends MessageEndpoint {
+    /**
+     * Initializes the emitter with protocol and options, setting initial server hash.
+     * @param protocol The Avro protocol.
+     * @param opts Transport options.
+     */
+    constructor(protocol, opts) {
+        super(protocol, opts);
+        _MessageEmitter_serverHash.set(this, void 0);
+        _MessageEmitter_serverHashKey.set(this, void 0);
+        _MessageEmitter_destroyed.set(this, false);
+        __classPrivateFieldSet(this, _MessageEmitter_serverHash, protocol.getHashBytes(), "f");
+        __classPrivateFieldSet(this, _MessageEmitter_serverHashKey, protocol.hashKey, "f");
+    }
+    /**
+     * Gets whether the emitter has been destroyed.
+     */
+    get destroyed() {
+        return __classPrivateFieldGet(this, _MessageEmitter_destroyed, "f");
+    }
+    /**
+     * Destroys the emitter, marking it as destroyed and dispatching end-of-transmission.
+     */
+    destroy() {
+        if (!__classPrivateFieldGet(this, _MessageEmitter_destroyed, "f")) {
+            __classPrivateFieldSet(this, _MessageEmitter_destroyed, true, "f");
+            this.dispatchEot(0);
+        }
+    }
+    /**
+     * Gets the current server hash bytes.
+     */
+    get serverHash() {
+        return __classPrivateFieldGet(this, _MessageEmitter_serverHash, "f");
+    }
+    /**
+     * Updates the server hash with new bytes and recomputes the hex key.
+     * @param bytes The new server hash bytes.
+     */
+    updateServerHash(bytes) {
+        __classPrivateFieldSet(this, _MessageEmitter_serverHash, bytes.slice(), "f");
+        __classPrivateFieldSet(this, _MessageEmitter_serverHashKey, bytesToHex(bytes), "f");
+    }
+    /**
+     * Gets the current server hash as a hex string key.
+     */
+    get serverHashKey() {
+        return __classPrivateFieldGet(this, _MessageEmitter_serverHashKey, "f");
+    }
+    /**
+     * Builds a handshake request object with client/server hashes and optional protocol.
+     * @param omitProtocol Whether to omit the client protocol string.
+     * @returns The handshake request data.
+     */
+    buildHandshakeRequest(omitProtocol) {
+        return {
+            clientHash: this.protocol.getHashBytes(),
+            clientProtocol: omitProtocol ? null : this.protocol.toString(),
+            serverHash: __classPrivateFieldGet(this, _MessageEmitter_serverHash, "f"),
+        };
+    }
+    /**
+     * Finalizes the handshake by dispatching events, handling errors, and determining retry.
+     * Updates server hash if provided and checks for protocol mismatches.
+     * @param request The handshake request.
+     * @param response The handshake response.
+     * @returns Object indicating if retry is needed and the server hash.
+     */
+    finalizeHandshake(request, response) {
+        this.dispatchHandshake(request, response);
+        if (response.match === "NONE") {
+            const reason = response.meta?.get("error");
+            if (reason) {
+                throw new Error(new TextDecoder().decode(reason));
+            }
+        }
+        if (!response.serverHash) {
+            return { retry: false, serverHash: __classPrivateFieldGet(this, _MessageEmitter_serverHash, "f") };
+        }
+        this.updateServerHash(response.serverHash);
+        let retry = false;
+        if (response.match === "NONE" && request.clientProtocol === null) {
+            retry = true;
+        }
+        return {
+            retry,
+            serverHash: response.serverHash,
+        };
+    }
+}
+_MessageEmitter_serverHash = new WeakMap(), _MessageEmitter_serverHashKey = new WeakMap(), _MessageEmitter_destroyed = new WeakMap();
+/**
+ * Stateless implementation of MessageEmitter for Avro RPC.
+ * Creates a new transport connection for each RPC call, enabling stateless communication.
+ * Handles encoding requests, performing handshakes, decoding responses, and tracking pending calls.
+ */
+export class StatelessEmitter extends MessageEmitter {
+    /**
+     * Initializes the stateless emitter with protocol, transport factory, options, and protocol factory.
+     * @param protocol The Avro protocol.
+     * @param transportFactory Factory function to create binary duplex transports.
+     * @param opts Transport options.
+     * @param protocolFactory Factory to create protocols from JSON.
+     */
+    constructor(protocol, transportFactory, opts, protocolFactory) {
+        super(protocol, opts);
+        _StatelessEmitter_instances.add(this);
+        _StatelessEmitter_transportFactory.set(this, void 0);
+        _StatelessEmitter_pending.set(this, new Set());
+        _StatelessEmitter_nextId.set(this, 1);
+        _StatelessEmitter_protocolFactory.set(this, void 0);
+        __classPrivateFieldSet(this, _StatelessEmitter_transportFactory, transportFactory, "f");
+        __classPrivateFieldSet(this, _StatelessEmitter_protocolFactory, protocolFactory, "f");
+    }
+    /**
+     * Destroys the emitter, rejecting all pending calls and clearing the set.
+     */
+    destroy() {
+        if (this.destroyed) {
+            return;
+        }
+        for (const pending of __classPrivateFieldGet(this, _StatelessEmitter_pending, "f")) {
+            pending.reject(new Error("emitter destroyed"));
+        }
+        __classPrivateFieldGet(this, _StatelessEmitter_pending, "f").clear();
+        super.destroy();
+    }
+    /**
+     * Sends an RPC message, handling one-way and request-response calls.
+     * For one-way calls, performs the call and returns undefined.
+     * For request-response, tracks the pending call and returns the result.
+     * @param message The message to send.
+     * @param request The request data.
+     * @returns Promise resolving to response or undefined.
+     */
+    async send(message, request) {
+        if (this.destroyed) {
+            throw new Error("emitter destroyed");
+        }
+        if (message.oneWay) {
+            await __classPrivateFieldGet(this, _StatelessEmitter_instances, "m", _StatelessEmitter_performCall).call(this, message, request, true);
+            return undefined;
+        }
+        const promise = __classPrivateFieldGet(this, _StatelessEmitter_instances, "m", _StatelessEmitter_performCall).call(this, message, request, false);
+        return await __classPrivateFieldGet(this, _StatelessEmitter_instances, "m", _StatelessEmitter_trackPending).call(this, promise);
+    }
+}
+_StatelessEmitter_transportFactory = new WeakMap(), _StatelessEmitter_pending = new WeakMap(), _StatelessEmitter_nextId = new WeakMap(), _StatelessEmitter_protocolFactory = new WeakMap(), _StatelessEmitter_instances = new WeakSet(), _StatelessEmitter_trackPending = 
+/**
+ * Tracks a pending call by wrapping it in a new promise and managing resolve/reject.
+ * Adds to pending set and removes on completion.
+ * @param promise The call promise to track.
+ * @returns Wrapped promise that resolves/rejects based on the original.
+ */
+async function _StatelessEmitter_trackPending(promise) {
+    let resolve;
+    let reject;
+    const wrapped = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    const pending = { resolve, reject };
+    __classPrivateFieldGet(this, _StatelessEmitter_pending, "f").add(pending);
+    promise
+        .then((value) => {
+        if (__classPrivateFieldGet(this, _StatelessEmitter_pending, "f").delete(pending)) {
+            pending.resolve(value);
+        }
+    })
+        .catch((err) => {
+        if (__classPrivateFieldGet(this, _StatelessEmitter_pending, "f").delete(pending)) {
+            pending.reject(err);
+        }
+    });
+    return await wrapped;
+}, _StatelessEmitter_performCall = 
+/**
+ * Performs the actual RPC call by creating transport, encoding request, handshaking, and decoding response.
+ * Retries on handshake failure if needed.
+ * @param message The RPC message.
+ * @param request The request payload.
+ * @param oneWay Whether this is a one-way call.
+ * @returns Promise resolving to response payload or undefined for one-way.
+ */
+async function _StatelessEmitter_performCall(message, request, oneWay) {
+    var _a, _b;
+    let omitProtocol = true;
+    while (true) {
+        const transport = toBinaryDuplex(await __classPrivateFieldGet(this, _StatelessEmitter_transportFactory, "f").call(this));
+        const metadata = metadataWithId((__classPrivateFieldSet(this, _StatelessEmitter_nextId, (_b = __classPrivateFieldGet(this, _StatelessEmitter_nextId, "f"), _a = _b++, _b), "f"), _a));
+        const handshake = this.buildHandshakeRequest(omitProtocol);
+        const encoded = await encodeCallRequest({
+            handshake,
+            metadata,
+            messageName: message.name,
+            request,
+            requestType: message.requestType,
+        });
+        const framed = frameMessage(encoded, { frameSize: this.frameSize });
+        await transport.writable.write(framed);
+        await transport.writable.close();
+        if (oneWay) {
+            await drainReadable(transport.readable);
+            return undefined;
+        }
+        const payload = await readSingleMessage(transport.readable);
+        const envelope = await decodeCallResponseEnvelope(toArrayBuffer(payload), { expectHandshake: true });
+        const handshakeResponse = envelope.handshake;
+        const outcome = this.finalizeHandshake(handshake, handshakeResponse);
+        if (handshakeResponse.serverProtocol) {
+            const remote = __classPrivateFieldGet(this, _StatelessEmitter_protocolFactory, "f").call(this, JSON.parse(handshakeResponse.serverProtocol));
+            this.protocol.ensureEmitterResolvers(bytesToHex(outcome.serverHash), remote);
+        }
+        if (outcome.retry) {
+            omitProtocol = false;
+            continue;
+        }
+        const resolvers = this.protocol.getEmitterResolvers(bytesToHex(outcome.serverHash), message.name);
+        const payloadValue = await readResponsePayload(envelope, message, resolvers);
+        return payloadValue;
+    }
+};