@kuralle-syrinx/ws 4.1.0 → 4.3.0

package/package.json

@@ -1,9 +1,27 @@
 {
   "name": "@kuralle-syrinx/ws",
-  "version": "4.1.0",
+  "version": "4.3.0",
   "private": false,
-  "type": "module",
+  "description": "Reconnecting WebSocket connection manager for Syrinx provider sockets — verify-before-trust reconnects, ordered replay, keepalive; Node and Workers",
+  "keywords": [
+    "voice",
+    "voice-agent",
+    "speech",
+    "syrinx",
+    "websocket",
+    "reconnect"
+  ],
   "license": "MIT",
+  "homepage": "https://github.com/kuralle/syrinx#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kuralle/syrinx.git",
+    "directory": "packages/ws"
+  },
+  "bugs": {
+    "url": "https://github.com/kuralle/syrinx/issues"
+  },
+  "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "exports": {
@@ -14,13 +32,13 @@
     "./workers": "./src/workers.ts"
   },
   "dependencies": {
-    "ws": "^8.18.0",
-    "@kuralle-syrinx/core": "4.1.0"
+    "ws": "^8.21.0",
+    "@kuralle-syrinx/core": "4.3.0"
   },
   "devDependencies": {
     "@types/ws": "^8.5.0",
     "typescript": "^5.7.0",
-    "vitest": "^2.1.0"
+    "vitest": "^3.2.6"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",

package/src/index.ts

@@ -106,6 +106,10 @@ let connectionSequence = 0;
 export class WebSocketConnection {
   private socket: ManagedSocket | null = null;
   private ready = false;
+  /** True only once the connection is verified and onReadyBeforeReplay has been
+   * given the chance to run — send() must not reach an open-but-unconfigured
+   * socket, or caller frames beat the provider config frame on reconnect. */
+  private established = false;
   private closed = false;
   private reconnecting = false;
   private connResolver: (() => void) | null = null;
@@ -135,6 +139,7 @@ export class WebSocketConnection {
   async connect(): Promise<void> {
     this.closed = false;
     await this.openSocket();
+    this.established = true;
     this.opts.onReadyBeforeReplay?.();
     this.flushReplay();
   }
@@ -149,7 +154,7 @@ export class WebSocketConnection {
    * throws and the caller decides how to retry/report.
    */
   send(payload: SocketData): void {
-    if (!this.socket || !this.socket.isOpen) {
+    if (!this.socket || !this.socket.isOpen || !this.established) {
       if (this.replayBufferSize > 0 && !this.closed) {
         this.bufferForReplay(payload);
         return;
@@ -208,6 +213,7 @@ export class WebSocketConnection {
     this.connResolver = null;
     this.connRejecter = null;
     this.ready = false;
+    this.established = false;
     this.socket?.dispose();
     this.socket = null;
   }
@@ -223,6 +229,7 @@ export class WebSocketConnection {
     this.socket?.dispose();
     this.socket = null;
     this.ready = false;
+    this.established = false;
     this.stopKeepAlive();
     void this.tryReconnect();
   }
@@ -235,6 +242,7 @@ export class WebSocketConnection {
     this.abortPendingOpen(new Error("WebSocket connection replaced"));
     this.socket?.dispose();
     this.ready = false;
+    this.established = false;
 
     let socket: ManagedSocket | null = null;
     let deadlineTimer: ReturnType<typeof setTimeout> | undefined;
@@ -312,6 +320,7 @@ export class WebSocketConnection {
               settle(() => reject(err));
               if (!bindSocket(created)) return;
               this.ready = false;
+              this.established = false;
               this.connRejecter?.(err);
               this.connResolver = null;
               this.connRejecter = null;
@@ -322,6 +331,7 @@ export class WebSocketConnection {
               settle(() => reject(closeErr));
               if (!bindSocket(created)) return;
               this.ready = false;
+              this.established = false;
               this.stopKeepAlive();
               this.connRejecter?.(closeErr);
               this.connResolver = null;
@@ -416,6 +426,7 @@ export class WebSocketConnection {
           await this.openSocket();
           if (this.socket && (await this.verifyConnection(VERIFY_TIMEOUT_MS))) {
             this.scheduleReconnectBurstReset();
+            this.established = true;
             this.opts.onReadyBeforeReplay?.();
             this.flushReplay();
             this.opts.onReconnected?.();

package/src/index.test.ts

@@ -1,350 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { afterEach, describe, expect, it } from "vitest";
-import { WebSocketServer, type WebSocket } from "ws";
-import type { RetryConfig } from "@kuralle-syrinx/core";
-
-import { WebSocketConnection, type ManagedSocket, type SocketFactory } from "./index.js";
-import { createNodeWsSocket } from "./node.js";
-
-let servers: WebSocketServer[] = [];
-
-afterEach(async () => {
-  await Promise.all(
-    servers.splice(0).map(
-      (server) =>
-        new Promise<void>((resolve) => {
-          for (const client of server.clients) client.terminate();
-          server.close(() => resolve());
-        }),
-    ),
-  );
-});
-
-async function createServer(onConnection: (socket: WebSocket) => void): Promise<{ url: string; port: number; server: WebSocketServer }> {
-  const server = await new Promise<WebSocketServer>((resolve) => {
-    let next: WebSocketServer;
-    next = new WebSocketServer({ port: 0 }, () => resolve(next));
-  });
-  servers.push(server);
-  server.on("connection", onConnection);
-  const address = server.address();
-  if (!address || typeof address === "string") throw new Error("Expected TCP server address");
-  return { url: `ws://127.0.0.1:${address.port}/`, port: address.port, server };
-}
-
-const FAST_RETRY: RetryConfig = { maxAttempts: 3, baseDelayMs: 10, maxDelayMs: 40 };
-
-async function waitFor(predicate: () => boolean, timeoutMs = 2000): Promise<void> {
-  const startedAt = Date.now();
-  while (Date.now() - startedAt < timeoutMs) {
-    if (predicate()) return;
-    await new Promise((resolve) => setTimeout(resolve, 5));
-  }
-  throw new Error("Timed out waiting for condition");
-}
-
-describe("WebSocketConnection", () => {
-  it("delivers messages and holds the socket open with a KeepAlive", async () => {
-    const serverReceived: string[] = [];
-    const { url } = await createServer((socket) => {
-      socket.on("message", (data, isBinary) => {
-        if (!isBinary) serverReceived.push(data.toString());
-      });
-      socket.send("hello-from-server");
-    });
-
-    const messages: string[] = [];
-    const conn = new WebSocketConnection({
-      url: () => url,
-      socketFactory: createNodeWsSocket,
-      retry: FAST_RETRY,
-      keepAliveIntervalMs: 30,
-      keepAliveMessage: () => JSON.stringify({ type: "KeepAlive" }),
-      onMessage: (data, isBinary) => {
-        if (!isBinary) messages.push(data.toString());
-      },
-    });
-    await conn.connect();
-    await waitFor(() => messages.includes("hello-from-server"));
-    // Several keepalive intervals should have elapsed.
-    await waitFor(() => serverReceived.filter((m) => m.includes("KeepAlive")).length >= 2);
-
-    expect(messages).toContain("hello-from-server");
-    expect(serverReceived.filter((m) => m.includes("KeepAlive")).length).toBeGreaterThanOrEqual(2);
-
-    await conn.close();
-  });
-
-  it("reconnects with verification after the server drops the socket", async () => {
-    let connections = 0;
-    const { url } = await createServer((socket) => {
-      connections += 1;
-      // ws auto-replies to ping with pong, so verify() passes.
-      if (connections === 1) {
-        // Drop the first connection shortly after it opens.
-        setTimeout(() => socket.close(1011, "transient"), 20);
-      }
-    });
-
-    let reconnecting = 0;
-    let reconnected = 0;
-    const conn = new WebSocketConnection({
-      url: () => url,
-      socketFactory: createNodeWsSocket,
-      retry: FAST_RETRY,
-      minStableMs: 0, // don't treat the deliberate drop as a quick failure
-      onMessage: () => undefined,
-      onReconnecting: () => {
-        reconnecting += 1;
-      },
-      onReconnected: () => {
-        reconnected += 1;
-      },
-    });
-    await conn.connect();
-    await waitFor(() => reconnected >= 1);
-
-    expect(reconnecting).toBeGreaterThanOrEqual(1);
-    expect(reconnected).toBe(1);
-    expect(connections).toBeGreaterThanOrEqual(2);
-    // The reconnected socket is usable.
-    expect(conn.isReady).toBe(true);
-    conn.send("after-reconnect");
-
-    await conn.close();
-  });
-
-  it("gives up and reports unrecoverable when the server stays down", async () => {
-    const { url, server } = await createServer(() => undefined);
-    let unrecoverable: Error | null = null;
-    const conn = new WebSocketConnection({
-      url: () => url,
-      socketFactory: createNodeWsSocket,
-      retry: FAST_RETRY,
-      maxReconnectAttempts: 2,
-      minStableMs: 0,
-      onMessage: () => undefined,
-      onUnrecoverable: (err) => {
-        unrecoverable = err;
-      },
-    });
-    await conn.connect();
-    expect(conn.isReady).toBe(true);
-
-    // Kill the server: the live socket drops and every reconnect attempt fails.
-    await new Promise<void>((resolve) => {
-      for (const client of server.clients) client.terminate();
-      server.close(() => resolve());
-    });
-
-    await waitFor(() => unrecoverable !== null, 3000);
-    expect(unrecoverable).toBeInstanceOf(Error);
-    expect((unrecoverable! as Error).message).toContain("failed to reconnect");
-
-    await conn.close();
-  });
-
-  it("rejects connect when disposed before the socket opens", async () => {
-    const hangingSocket: ManagedSocket = {
-      get isOpen() {
-        return false;
-      },
-      send: () => undefined,
-      keepAlivePing: () => undefined,
-      verify: async () => false,
-      dispose: () => undefined,
-      onOpen: () => undefined,
-      onMessage: () => undefined,
-      onClose: () => undefined,
-      onError: () => undefined,
-    };
-    const socketFactory: SocketFactory = () => hangingSocket;
-    const conn = new WebSocketConnection({
-      url: () => "ws://127.0.0.1:1/",
-      socketFactory,
-      retry: FAST_RETRY,
-      onMessage: () => undefined,
-    });
-
-    const connectPromise = conn.connect();
-    await new Promise((resolve) => setTimeout(resolve, 10));
-    await conn.close();
-
-    await expect(connectPromise).rejects.toThrow(/disposed/i);
-  });
-
-  it("stops reconnecting when the socket keeps dying right after connecting", async () => {
-    // Server accepts + answers ping (verify passes) but closes ~15ms after open,
-    // every time — backoff can't fix this, so the quick-failure guard must give up.
-    const { url } = await createServer((socket) => {
-      setTimeout(() => socket.close(1011, "flap"), 15);
-    });
-
-    let unrecoverable: Error | null = null;
-    let reconnects = 0;
-    const conn = new WebSocketConnection({
-      url: () => url,
-      socketFactory: createNodeWsSocket,
-      retry: FAST_RETRY,
-      minStableMs: 200,
-      maxQuickFailures: 2,
-      onMessage: () => undefined,
-      onReconnected: () => {
-        reconnects += 1;
-      },
-      onUnrecoverable: (err) => {
-        unrecoverable = err;
-      },
-    });
-    await conn.connect();
-    await waitFor(() => unrecoverable !== null, 3000);
-
-    expect((unrecoverable! as Error).message).toContain("check credentials or provider policy");
-    // It should bail out quickly, not loop forever.
-    expect(reconnects).toBeLessThanOrEqual(3);
-
-    await conn.close();
-  });
-
-  it("rejects openSocket when the socket factory never resolves", async () => {
-    const connectTimeoutMs = 50;
-    const hangingFactory: SocketFactory = () =>
-      new Promise<ManagedSocket>(() => {
-        /* never resolves */
-      });
-
-    const conn = new WebSocketConnection({
-      url: () => "ws://127.0.0.1:1/",
-      socketFactory: hangingFactory,
-      connectTimeoutMs,
-      retry: FAST_RETRY,
-      onMessage: () => undefined,
-    });
-
-    const startedAt = Date.now();
-    await expect(conn.connect()).rejects.toThrow(/connect timeout/i);
-    expect(Date.now() - startedAt).toBeLessThan(connectTimeoutMs + 100);
-    expect(Date.now() - startedAt).toBeGreaterThanOrEqual(connectTimeoutMs - 10);
-
-    await conn.close();
-  });
-
-  it("rejects openSocket when the socket fires no event after construction", async () => {
-    const connectTimeoutMs = 50;
-    const silentSocket: ManagedSocket = {
-      get isOpen() {
-        return false;
-      },
-      send: () => undefined,
-      keepAlivePing: () => undefined,
-      verify: async () => false,
-      dispose: () => undefined,
-      onOpen: () => undefined,
-      onMessage: () => undefined,
-      onClose: () => undefined,
-      onError: () => undefined,
-    };
-    const socketFactory: SocketFactory = () => silentSocket;
-
-    const conn = new WebSocketConnection({
-      url: () => "ws://127.0.0.1:1/",
-      socketFactory,
-      connectTimeoutMs,
-      retry: { maxAttempts: 2, baseDelayMs: 5, maxDelayMs: 10 },
-      maxReconnectAttempts: 1,
-      minStableMs: 0,
-      onMessage: () => undefined,
-    });
-
-    const startedAt = Date.now();
-    await expect(conn.connect()).rejects.toThrow(/connect timeout/i);
-    expect(Date.now() - startedAt).toBeLessThan(connectTimeoutMs + 100);
-
-    await conn.close();
-  });
-
-  it("reconnects after openSocket times out on a silent socket during tryReconnect", async () => {
-    const connectTimeoutMs = 40;
-    let factoryCalls = 0;
-    const { url, server } = await createServer((socket) => {
-      socket.on("message", () => undefined);
-    });
-
-    const silentSocket: ManagedSocket = {
-      get isOpen() {
-        return false;
-      },
-      send: () => undefined,
-      keepAlivePing: () => undefined,
-      verify: async () => false,
-      dispose: () => undefined,
-      onOpen: () => undefined,
-      onMessage: () => undefined,
-      onClose: () => undefined,
-      onError: () => undefined,
-    };
-
-    const socketFactory: SocketFactory = (targetUrl, headers) => {
-      factoryCalls += 1;
-      if (factoryCalls === 2) return silentSocket;
-      return createNodeWsSocket(targetUrl, headers);
-    };
-
-    let reconnected = 0;
-    const conn = new WebSocketConnection({
-      url: () => url,
-      socketFactory,
-      connectTimeoutMs,
-      retry: { maxAttempts: 3, baseDelayMs: 5, maxDelayMs: 10 },
-      minStableMs: 0,
-      onMessage: () => undefined,
-      onReconnected: () => {
-        reconnected += 1;
-      },
-    });
-
-    await conn.connect();
-    expect(factoryCalls).toBe(1);
-
-    for (const client of server.clients) client.terminate();
-    await waitFor(() => reconnected >= 1, 5000);
-    expect(factoryCalls).toBeGreaterThanOrEqual(3);
-
-    await conn.close();
-  });
-
-  it("gives up after maxReconnectDurationMs when the link keeps flapping", async () => {
-    const minStableMs = 30;
-    const maxReconnectDurationMs = 200;
-    const { url } = await createServer((socket) => {
-      setTimeout(() => socket.close(1011, "flap"), minStableMs + 1);
-    });
-
-    let unrecoverable: Error | null = null;
-    let reconnects = 0;
-    const conn = new WebSocketConnection({
-      url: () => url,
-      socketFactory: createNodeWsSocket,
-      retry: { maxAttempts: 50, baseDelayMs: 5, maxDelayMs: 10 },
-      minStableMs,
-      maxQuickFailures: 100,
-      maxReconnectDurationMs,
-      maxReconnectAttempts: 50,
-      onMessage: () => undefined,
-      onReconnected: () => {
-        reconnects += 1;
-      },
-      onUnrecoverable: (err) => {
-        unrecoverable = err;
-      },
-    });
-    await conn.connect();
-    await waitFor(() => unrecoverable !== null, 5000);
-
-    expect((unrecoverable! as Error).message).toContain(String(maxReconnectDurationMs));
-    expect(reconnects).toBeGreaterThanOrEqual(1);
-
-    await conn.close();
-  });
-});

package/src/node.test.ts

@@ -1,68 +0,0 @@
-// SPDX-License-Identifier: MIT
-//
-// Regression: disposing a Node `ws` socket that is still CONNECTING must not crash
-// the process. `ws.close()` on a connecting socket emits an asynchronous 'error'
-// event ("WebSocket was closed before the connection was established"); dispose()
-// removeAllListeners()'d the error sink, so without re-attaching one the event
-// becomes an uncaught exception. This happens whenever a caller hangs up during a
-// slow provider connect (surfaced live via the Cartesia TTS plugin teardown).
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { WebSocketServer, type WebSocket } from "ws";
-import { createNodeWsSocket } from "./node.js";
-
-describe("createNodeWsSocket dispose while connecting", () => {
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("does not raise an unhandled 'error' when disposed mid-handshake", async () => {
-    // A socket to a non-routable address stays in CONNECTING. If dispose() leaked an
-    // unhandled 'error', the vitest process would record an uncaughtException and fail
-    // this file — reaching the assertion is the proof.
-    const uncaught: unknown[] = [];
-    const onUncaught = (err: unknown): void => {
-      uncaught.push(err);
-    };
-    process.on("uncaughtException", onUncaught);
-    try {
-      // createNodeWsSocket is synchronous; await narrows the SocketFactory union.
-      const socket = await createNodeWsSocket("ws://10.255.255.1:9999", {});
-      socket.dispose(); // synchronous, while readyState === CONNECTING
-      await new Promise((resolve) => setTimeout(resolve, 150));
-    } finally {
-      process.off("uncaughtException", onUncaught);
-    }
-    expect(uncaught).toEqual([]);
-  });
-
-  it("clears the verify timeout when disposed during verify", async () => {
-    vi.useFakeTimers();
-    const server = await new Promise<WebSocketServer>((resolve) => {
-      let next: WebSocketServer;
-      next = new WebSocketServer({ port: 0 }, () => resolve(next));
-    });
-    server.on("connection", (ws) => {
-      ws.on("ping", () => undefined);
-    });
-    const address = server.address();
-    if (!address || typeof address === "string") throw new Error("Expected TCP server address");
-
-    const socket = await createNodeWsSocket(`ws://127.0.0.1:${String(address.port)}/`, {});
-    await new Promise<void>((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error("Timed out waiting for websocket open")), 2000);
-      socket.onOpen(() => {
-        clearTimeout(timer);
-        resolve();
-      });
-    });
-
-    const verifyPromise = socket.verify(5000);
-    socket.dispose();
-    await vi.advanceTimersByTimeAsync(6000);
-    await expect(verifyPromise).resolves.toBe(false);
-
-    await new Promise<void>((resolve) => server.close(() => resolve()));
-    vi.useRealTimers();
-  });
-});

package/src/replay.test.ts

@@ -1,99 +0,0 @@
-// 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

@@ -1,132 +0,0 @@
-// 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/workers.test.ts

@@ -1,84 +0,0 @@
-// 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/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "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"]
-}