@kuralle-syrinx/ws 2.1.0

package/src/realtime-socket.ts

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+//
+// Full-duplex provider socket for OpenAI Realtime (and siblings). Wraps
+// WebSocketConnection with JSON send/receive — the cascade STT/TTS sockets
+// stay separate; this is the bi-model live loop transport.
+
+import { VOICE_PROVIDER_RETRY_CONFIG, type RetryConfig } from "@kuralle-syrinx/core";
+
+import { WebSocketConnection, type SocketFactory } from "./index.js";
+
+export interface RealtimeSocketOptions {
+  readonly url: () => string;
+  readonly headers?: Record<string, string>;
+  readonly socketFactory: SocketFactory;
+  readonly retry?: RetryConfig;
+  readonly keepAliveIntervalMs?: number;
+  readonly replayBufferSize?: number;
+  readonly onMessage: (json: string) => void;
+  readonly onReady?: () => void;
+  readonly onConnectionLost?: (err: Error) => void;
+  readonly onUnrecoverable?: (err: Error) => void;
+}
+
+export class RealtimeSocket {
+  private conn: WebSocketConnection | null = null;
+
+  constructor(private readonly opts: RealtimeSocketOptions) {}
+
+  async connect(): Promise<void> {
+    this.conn = new WebSocketConnection({
+      url: this.opts.url,
+      headers: this.opts.headers,
+      socketFactory: this.opts.socketFactory,
+      retry: this.opts.retry ?? VOICE_PROVIDER_RETRY_CONFIG,
+      keepAliveIntervalMs: this.opts.keepAliveIntervalMs ?? 15_000,
+      replayBufferSize: this.opts.replayBufferSize ?? 0,
+      onMessage: (data) => {
+        if (typeof data === "string") this.opts.onMessage(data);
+      },
+      onConnectionLost: this.opts.onConnectionLost,
+      onUnrecoverable: this.opts.onUnrecoverable,
+      onReadyBeforeReplay: this.opts.onReady,
+    });
+    await this.conn.connect();
+  }
+
+  send(event: Record<string, unknown>): void {
+    if (!this.conn) throw new Error("Realtime socket is not connected");
+    this.conn.send(JSON.stringify(event));
+  }
+
+  get isReady(): boolean {
+    return this.conn?.isReady ?? false;
+  }
+
+  async close(): Promise<void> {
+    await this.conn?.close();
+    this.conn = null;
+  }
+}

package/src/replay.test.ts

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: MIT
+//
+// VE-06.2: reconnect replay. A frame whose send() fails because the socket is not open
+// (provably never reached the wire) is buffered and re-sent in order on reconnect; frames
+// sent on an open socket are never buffered, so received frames are never duplicated.
+
+import { describe, expect, it } from "vitest";
+import type { RetryConfig } from "@kuralle-syrinx/core";
+
+import { WebSocketConnection, type SocketData } from "./index.js";
+import { wrapWebSocket, type WebSocketEventLike, type WebSocketLike } from "./web-socket.js";
+
+const FAST_RETRY: RetryConfig = { maxAttempts: 5, baseDelayMs: 5, maxDelayMs: 20 };
+
+class FakeWebSocket implements WebSocketLike {
+  readyState = 0;
+  binaryType = "blob";
+  readonly sent: SocketData[] = [];
+  private readonly listeners = new Map<string, Array<(event: WebSocketEventLike) => void>>();
+  send(data: string | ArrayBufferView | ArrayBuffer): void {
+    this.sent.push(typeof data === "string" ? data : new Uint8Array(data as ArrayBuffer));
+  }
+  close(): void { this.readyState = 3; this.emit("close", { code: 1006, reason: "drop" }); }
+  addEventListener(type: string, l: (e: WebSocketEventLike) => void): void {
+    const list = this.listeners.get(type) ?? []; list.push(l); this.listeners.set(type, list);
+  }
+  private emit(type: string, event: WebSocketEventLike): void { for (const l of this.listeners.get(type) ?? []) l(event); }
+  fireOpen(): void { this.readyState = 1; this.emit("open", {}); }
+}
+
+const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+describe("WebSocketConnection reconnect replay (VE-06.2)", () => {
+  it("send() to a closed socket throws when replay is disabled (default)", async () => {
+    const fake = new FakeWebSocket();
+    const conn = new WebSocketConnection({
+      url: () => "wss://x", socketFactory: () => wrapWebSocket(fake), retry: FAST_RETRY,
+      onMessage: () => undefined,
+    });
+    const connected = conn.connect(); fake.fireOpen(); await connected;
+    fake.readyState = 3; // simulate closed
+    expect(() => conn.send("frame")).toThrow(/not open/);
+    await conn.close();
+  });
+
+  it("buffers gap frames and replays them in order on reconnect; on-wire frames are not replayed", async () => {
+    const fakes: FakeWebSocket[] = [];
+    const replayEvents: Array<{ event: string; count: number }> = [];
+    const conn = new WebSocketConnection({
+      url: () => "wss://x",
+      socketFactory: () => { const f = new FakeWebSocket(); fakes.push(f); return wrapWebSocket(f); },
+      retry: FAST_RETRY,
+      replayBufferSize: 10,
+      onReplay: (event, count) => replayEvents.push({ event, count }),
+      onMessage: () => undefined,
+    });
+
+    const connected = conn.connect();
+    fakes[0]!.fireOpen();
+    await connected;
+
+    conn.send("on-wire-1"); // sent on the open socket — must NOT be replayed
+    expect(fakes[0]!.sent).toEqual(["on-wire-1"]);
+
+    // Connection drops → reconnect begins.
+    fakes[0]!.close();
+    // During the gap (socket not open) the caller keeps sending — these buffer for replay.
+    conn.send("gap-1");
+    conn.send("gap-2");
+
+    // Wait for the reconnect to create a new socket, then open it.
+    await wait(40);
+    expect(fakes.length).toBeGreaterThanOrEqual(2);
+    fakes[fakes.length - 1]!.fireOpen();
+    await wait(10);
+
+    const reconnected = fakes[fakes.length - 1]!;
+    // The two gap frames are replayed in order on the new socket; the on-wire frame is NOT.
+    expect(reconnected.sent).toEqual(["gap-1", "gap-2"]);
+    expect(replayEvents.filter((e) => e.event === "replayed")).toHaveLength(1);
+    expect(replayEvents.find((e) => e.event === "replayed")?.count).toBe(2);
+
+    await conn.close();
+  });
+
+  it("bounds the replay buffer, dropping oldest with an overflow signal", async () => {
+    const fake = new FakeWebSocket();
+    const events: string[] = [];
+    const conn = new WebSocketConnection({
+      url: () => "wss://x", socketFactory: () => wrapWebSocket(fake), retry: FAST_RETRY,
+      replayBufferSize: 2, onReplay: (e) => events.push(e), onMessage: () => undefined,
+    });
+    const connected = conn.connect(); fake.fireOpen(); await connected;
+    fake.readyState = 3; // closed
+    conn.send("a"); conn.send("b"); conn.send("c"); // buffer holds last 2 → "a" overflows
+    expect(events.filter((e) => e === "overflow")).toHaveLength(1);
+    await conn.close();
+  });
+});

package/src/web-socket.test.ts

@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: MIT
+//
+// Proves the connection manager runs over the standard built-in WebSocket
+// (Cloudflare Workers / browser / Bun) with no `ws` and no ping frames — keepalive uses an
+// app message and verify falls back to readyState.
+
+import { describe, expect, it } from "vitest";
+import type { RetryConfig } from "@kuralle-syrinx/core";
+
+import { WebSocketConnection, type SocketData } from "./index.js";
+import { wrapWebSocket, type WebSocketEventLike, type WebSocketLike } from "./web-socket.js";
+
+const FAST_RETRY: RetryConfig = { maxAttempts: 3, baseDelayMs: 10, maxDelayMs: 40 };
+
+/** A controllable standard-WebSocket-shaped socket — no ping, addEventListener-based. */
+class FakeWebSocket implements WebSocketLike {
+  readyState = 0;
+  binaryType = "blob";
+  readonly sent: SocketData[] = [];
+  private readonly listeners = new Map<string, Array<(event: WebSocketEventLike) => void>>();
+
+  send(data: string | ArrayBufferView | ArrayBuffer): void {
+    this.sent.push(typeof data === "string" ? data : new Uint8Array(data as ArrayBuffer));
+  }
+  close(): void {
+    this.readyState = 3;
+    this.emit("close", { code: 1000, reason: "" });
+  }
+  addEventListener(type: string, listener: (event: WebSocketEventLike) => void): void {
+    const list = this.listeners.get(type) ?? [];
+    list.push(listener);
+    this.listeners.set(type, list);
+  }
+  private emit(type: string, event: WebSocketEventLike): void {
+    for (const l of this.listeners.get(type) ?? []) l(event);
+  }
+  fireOpen(): void {
+    this.readyState = 1;
+    this.emit("open", {});
+  }
+  fireMessage(data: string | ArrayBuffer): void {
+    this.emit("message", { data });
+  }
+}
+
+describe("WebSocketConnection over the standard WebSocket (Workers/browser)", () => {
+  it("connects, delivers text + binary, and keepalives with an app message (no ping)", async () => {
+    const fake = new FakeWebSocket();
+    const received: Array<{ data: SocketData; isBinary: boolean }> = [];
+    const conn = new WebSocketConnection({
+      url: () => "wss://example/v1",
+      socketFactory: () => wrapWebSocket(fake),
+      retry: FAST_RETRY,
+      keepAliveIntervalMs: 20,
+      keepAliveMessage: () => JSON.stringify({ type: "KeepAlive" }),
+      onMessage: (data, isBinary) => received.push({ data, isBinary }),
+    });
+
+    const connected = conn.connect();
+    fake.fireOpen();
+    await connected;
+    expect(conn.isReady).toBe(true);
+
+    fake.fireMessage("hello-text");
+    fake.fireMessage(new Uint8Array([1, 2, 3]).buffer);
+
+    await new Promise((resolve) => setTimeout(resolve, 60));
+
+    expect(received[0]).toEqual({ data: "hello-text", isBinary: false });
+    const binary = received.find((r) => r.isBinary);
+    expect(binary?.data).toEqual(new Uint8Array([1, 2, 3]));
+    // KeepAlive went out as an app message, since the built-in WebSocket has no ping frame.
+    expect(fake.sent.filter((m) => typeof m === "string" && m.includes("KeepAlive")).length).toBeGreaterThanOrEqual(1);
+
+    await conn.close();
+    expect(fake.readyState).toBe(3);
+  });
+
+  it("verify fails when livenessProbe gets no reply and reconnect continues", async () => {
+    let activeFake: FakeWebSocket | null = null;
+    let probeCalls = 0;
+    let reconnecting = 0;
+
+    const conn = new WebSocketConnection({
+      url: () => "wss://example/v1",
+      socketFactory: () => {
+        activeFake = new FakeWebSocket();
+        queueMicrotask(() => activeFake!.fireOpen());
+        return wrapWebSocket(activeFake);
+      },
+      retry: FAST_RETRY,
+      minStableMs: 0,
+      connectTimeoutMs: 500,
+      livenessProbe: async () => {
+        probeCalls += 1;
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        return false;
+      },
+      onMessage: () => undefined,
+      onReconnecting: () => {
+        reconnecting += 1;
+      },
+    });
+
+    await conn.connect();
+    expect(conn.isReady).toBe(true);
+
+    activeFake!.close();
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    expect(probeCalls).toBeGreaterThanOrEqual(1);
+    expect(reconnecting).toBeGreaterThanOrEqual(1);
+
+    await conn.close();
+  });
+});
+
+describe("wrapWebSocket skip-open (workerd fetch-upgrade)", () => {
+  it("invokes onOpen via microtask when the socket is already open", async () => {
+    const fake = new FakeWebSocket();
+    fake.readyState = 1;
+
+    let opened = false;
+    wrapWebSocket(fake).onOpen(() => {
+      opened = true;
+    });
+
+    expect(opened).toBe(false);
+    await new Promise<void>((resolve) => queueMicrotask(resolve));
+    expect(opened).toBe(true);
+  });
+});

package/src/web-socket.ts

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: MIT
+//
+// Adapter for WebSocketConnection backed by the standard built-in WebSocket —
+// the one available in the browser, Cloudflare Workers, and Bun (and Node 21+).
+// It has no ping frame, so verify() falls back to readyState and keepalive must
+// use an app-level message (keepAliveMessage). Headers cannot be set on the
+// WebSocket constructor in the browser; on Workers, auth-header connections use
+// the fetch-upgrade route — construct the socket yourself and pass it to
+// wrapWebSocket.
+
+import type { ManagedSocket, SocketData, SocketFactory } from "./index.js";
+
+/** The subset of the standard WebSocket this adapter relies on (no DOM lib needed). */
+export interface WebSocketLike {
+  readyState: number;
+  binaryType: string;
+  send(data: string | ArrayBufferView | ArrayBuffer): void;
+  close(code?: number, reason?: string): void;
+  addEventListener(type: string, listener: (event: WebSocketEventLike) => void): void;
+}
+
+/** The event object a standard WebSocket hands its listeners (message: data; close: code/reason). */
+export interface WebSocketEventLike {
+  readonly data?: string | ArrayBuffer;
+  readonly code?: number;
+  readonly reason?: string;
+}
+
+const WEBSOCKET_OPEN = 1;
+
+/** Factory using the runtime's global WebSocket (no auth headers — same-origin or token-in-URL). */
+export const createWebSocketAdapter: SocketFactory = (url): ManagedSocket => {
+  const ctor = (globalThis as { WebSocket?: new (url: string) => WebSocketLike }).WebSocket;
+  if (!ctor) throw new Error("global WebSocket is not available in this runtime");
+  return wrapWebSocket(new ctor(url));
+};
+
+/** Wrap an already-constructed WebSocket (e.g. a Workers fetch-upgrade `response.webSocket`). */
+export function wrapWebSocket(ws: WebSocketLike): ManagedSocket {
+  ws.binaryType = "arraybuffer";
+  return {
+    get isOpen(): boolean {
+      return ws.readyState === WEBSOCKET_OPEN;
+    },
+    send: (data: SocketData) => ws.send(data),
+    keepAlivePing: () => {
+      // The standard WebSocket has no ping frame — rely on keepAliveMessage.
+    },
+    verify: async (_timeoutMs: number): Promise<boolean> => ws.readyState === WEBSOCKET_OPEN,
+    dispose: () => {
+      try {
+        ws.close();
+      } catch {
+        // best effort
+      }
+    },
+    onOpen: (handler) => {
+      // workerd: after fetch-upgrade + WebSocket.accept(), readyState is already OPEN
+      // and the runtime never emits an "open" event — only sockets that transition
+      // from CONNECTING fire it. queueMicrotask preserves the async onOpen contract
+      // WebSocketConnection expects without waiting for an event that won't come.
+      if (ws.readyState === WEBSOCKET_OPEN) {
+        queueMicrotask(handler);
+        return;
+      }
+      ws.addEventListener("open", () => handler());
+    },
+    onMessage: (handler) =>
+      ws.addEventListener("message", (event) => {
+        const payload = event.data;
+        if (typeof payload === "string") {
+          handler(payload, false);
+        } else if (payload) {
+          handler(new Uint8Array(payload), true);
+        }
+      }),
+    onClose: (handler) => ws.addEventListener("close", (event) => handler(event.code ?? 1006, event.reason ?? "")),
+    onError: (handler) => ws.addEventListener("error", () => handler(new Error("WebSocket error"))),
+  };
+}

package/src/workers.test.ts

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+//
+// Proves the Workers fetch-upgrade adapter drives the full manager: the async
+// socket factory is awaited, the auth headers + Upgrade go out on the fetch, and
+// the accepted (already-open) socket connects without an "open" event.
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { RetryConfig } from "@kuralle-syrinx/core";
+
+import { WebSocketConnection } from "./index.js";
+import { createWorkersSocket } from "./workers.js";
+import type { WebSocketEventLike } from "./web-socket.js";
+
+const FAST_RETRY: RetryConfig = { maxAttempts: 3, baseDelayMs: 10, maxDelayMs: 40 };
+
+const realFetch = globalThis.fetch;
+afterEach(() => {
+  globalThis.fetch = realFetch;
+});
+
+/** A Workers-style already-open socket returned by a fetch upgrade. */
+class FakeWorkersSocket {
+  readyState = 1; // already OPEN, as after a fetch upgrade
+  binaryType = "blob";
+  accepted = false;
+  readonly sent: Array<string | ArrayBufferView | ArrayBuffer> = [];
+  private readonly listeners = new Map<string, Array<(event: WebSocketEventLike) => void>>();
+  accept(): void {
+    this.accepted = true;
+  }
+  send(data: string | ArrayBufferView | ArrayBuffer): void {
+    this.sent.push(data);
+  }
+  close(): void {
+    this.readyState = 3;
+  }
+  addEventListener(type: string, listener: (event: WebSocketEventLike) => void): void {
+    const list = this.listeners.get(type) ?? [];
+    list.push(listener);
+    this.listeners.set(type, list);
+  }
+  fire(type: string, event: WebSocketEventLike): void {
+    for (const l of this.listeners.get(type) ?? []) l(event);
+  }
+}
+
+describe("createWorkersSocket (Cloudflare fetch-upgrade)", () => {
+  it("upgrades with auth headers and connects an already-open socket", async () => {
+    const fake = new FakeWorkersSocket();
+    const fetchMock = vi.fn(async (_url: string, _init: { headers: Record<string, string> }) => ({
+      status: 101,
+      webSocket: fake,
+    }));
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+    const received: string[] = [];
+    const conn = new WebSocketConnection({
+      url: () => "wss://api.deepgram.com/v1/listen",
+      headers: { Authorization: "Token secret-key" },
+      socketFactory: createWorkersSocket,
+      retry: FAST_RETRY,
+      onMessage: (data) => {
+        if (typeof data === "string") received.push(data);
+      },
+    });
+
+    await conn.connect();
+    expect(conn.isReady).toBe(true);
+    expect(fake.accepted).toBe(true);
+
+    // The fetch carried the Upgrade + the provider auth header.
+    const init = fetchMock.mock.calls[0]![1];
+    expect(init.headers.Upgrade).toBe("websocket");
+    expect(init.headers.Authorization).toBe("Token secret-key");
+
+    fake.fire("message", { data: "{\"type\":\"Results\"}" });
+    expect(received).toEqual(["{\"type\":\"Results\"}"]);
+
+    conn.send("audio-frame");
+    expect(fake.sent).toContain("audio-frame");
+
+    await conn.close();
+  });
+});

package/src/workers.ts

@@ -0,0 +1,147 @@
+// SPDX-License-Identifier: MIT
+//
+// Cloudflare Workers socket adapter. The built-in WebSocket constructor can't
+// set request headers, so auth-header provider connections (Deepgram's
+// `Authorization: Token`, Cartesia's `X-API-Key`) are opened with a `fetch`
+// upgrade and the returned `response.webSocket`, then `accept()`-ed before use.
+//
+// Pattern from Cloudflare's own agents/voice package (workers-ai-providers.ts):
+//   const resp = await fetch(url, { headers: { Upgrade: "websocket", ...auth } });
+//   const ws = resp.webSocket; ws.accept();
+
+import type { ManagedSocket } from "./index.js";
+import { wrapWebSocket, type WebSocketLike } from "./web-socket.js";
+
+/** The Workers WebSocket adds accept(); the upgrade response carries it. */
+type WorkersWebSocket = WebSocketLike & { accept(): void };
+interface UpgradeResponse {
+  readonly status?: number;
+  readonly webSocket?: WorkersWebSocket | null;
+}
+type WorkersFetch = (url: string, init: { headers: Record<string, string> }) => Promise<UpgradeResponse>;
+
+export interface WorkersDurableObjectWebSocketContext {
+  acceptWebSocket(socket: WorkersWebSocket): void;
+}
+
+export interface WorkersInboundSocket {
+  readonly socket: ManagedSocket;
+  readonly response: Response;
+  readonly clientWebSocket: WorkersWebSocket;
+  readonly serverWebSocket: WorkersWebSocket;
+  readonly controller?: WorkersInboundSocketController;
+}
+
+export interface WorkersInboundSocketController {
+  message(data: string | ArrayBuffer): void;
+  close(code: number, reason: string): void;
+  error(err?: Error): void;
+}
+
+type WebSocketPairValue = { 0: WorkersWebSocket; 1: WorkersWebSocket };
+type WebSocketPairConstructor = new () => WebSocketPairValue;
+
+/** Open an auth-header WebSocket from a Worker via fetch upgrade. Async — await before use. */
+export async function createWorkersSocket(url: string, headers: Record<string, string>): Promise<ManagedSocket> {
+  const doFetch = (globalThis as { fetch?: WorkersFetch }).fetch;
+  if (!doFetch) throw new Error("fetch is not available in this runtime");
+  // workerd's fetch() only accepts http(s) schemes; the upgrade is requested on
+  // the http(s) URL with `Upgrade: websocket`, not on a ws(s):// URL.
+  const resp = await doFetch(toHttpUrl(url), { headers: { ...headers, Upgrade: "websocket" } });
+  const ws = resp.webSocket;
+  if (!ws) throw new Error(`WebSocket upgrade failed (status ${String(resp.status ?? "unknown")})`);
+  ws.accept();
+  return wrapWebSocket(ws);
+}
+
+/** Normalize a ws(s):// provider URL to the http(s):// scheme workerd's fetch requires. */
+function toHttpUrl(url: string): string {
+  if (url.startsWith("wss://")) return `https://${url.slice("wss://".length)}`;
+  if (url.startsWith("ws://")) return `http://${url.slice("ws://".length)}`;
+  return url;
+}
+
+export function createWorkersInboundSocket(ctx?: WorkersDurableObjectWebSocketContext): WorkersInboundSocket {
+  const Pair = (globalThis as { WebSocketPair?: WebSocketPairConstructor }).WebSocketPair;
+  if (!Pair) throw new Error("WebSocketPair is not available in this runtime");
+  const pair = new Pair();
+  const client = pair[0];
+  const server = pair[1];
+  let controller: WorkersInboundSocketController | undefined;
+  let socket: ManagedSocket;
+  if (ctx) {
+    ctx.acceptWebSocket(server);
+    const controlled = createControlledSocket(server);
+    socket = controlled.socket;
+    controller = controlled.controller;
+  } else {
+    server.accept();
+    socket = wrapWebSocket(server);
+  }
+  const response = new Response(null, {
+    status: 101,
+    webSocket: client,
+  } as ResponseInit & { webSocket: WorkersWebSocket });
+  return {
+    socket,
+    response,
+    clientWebSocket: client,
+    serverWebSocket: server,
+    controller,
+  };
+}
+
+function createControlledSocket(ws: WorkersWebSocket): {
+  readonly socket: ManagedSocket;
+  readonly controller: WorkersInboundSocketController;
+} {
+  const messageHandlers = new Set<(data: string | Uint8Array, isBinary: boolean) => void>();
+  const closeHandlers = new Set<(code: number, reason: string) => void>();
+  const errorHandlers = new Set<(err: Error) => void>();
+  return {
+    socket: {
+      get isOpen(): boolean {
+        return ws.readyState === 1;
+      },
+      send: (data) => ws.send(data),
+      keepAlivePing: () => undefined,
+      verify: async () => ws.readyState === 1,
+      dispose: () => {
+        try {
+          ws.close();
+        } catch {
+          // best effort
+        }
+      },
+      onOpen: (handler) => {
+        if (ws.readyState === 1) queueMicrotask(handler);
+      },
+      onMessage: (handler) => {
+        messageHandlers.add(handler);
+      },
+      onClose: (handler) => {
+        closeHandlers.add(handler);
+      },
+      onError: (handler) => {
+        errorHandlers.add(handler);
+      },
+    },
+    controller: {
+      message(data) {
+        if (typeof data === "string") {
+          for (const handler of messageHandlers) handler(data, false);
+          return;
+        }
+        const bytes = new Uint8Array(data);
+        for (const handler of messageHandlers) handler(bytes, true);
+      },
+      close(code, reason) {
+        for (const handler of closeHandlers) handler(code, reason);
+      },
+      error(err) {
+        const error = err ?? new Error("WebSocket error");
+        for (const handler of errorHandlers) handler(error);
+      },
+    },
+  };
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitReturns": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}