@specific.dev/spectest 0.109.0 → 0.110.0

package/dist/components/index.d.ts

@@ -13,6 +13,6 @@ export { github, type GithubOptions } from "./github.js";
 export { apple, type AppleOptions } from "./apple.js";
 export { microsoft, type MicrosoftOptions } from "./microsoft.js";
 export { okta, type OktaOptions } from "./okta.js";
-export { replayFake, type ReplayFakeOptions, type ReplayFakeContext, type ReplayHandler, type ReplayKey, type ReplayRequest, type MatchKey, type JsonValue, type InjectRule, type InjectMatch, type StringMatch, type SignConfig, type AwsSigV4Sign, type ReplayHelpers, type ReplaySummary, type Cassette, type CassetteInteraction, type CassetteRequest, type CassetteResponse, type CassetteState, } from "./replayFake.js";
+export { replayFake, type ReplayFakeOptions, type ReplayFakeContext, type ReplayHandler, type ReplayKey, type WebSocketKey, type ReplayWebSocketMessage, type CassetteWebSocket, type CassetteWebSocketMessage, type WebSocketTiming, type ReplayRequest, type MatchKey, type JsonValue, type InjectRule, type InjectMatch, type StringMatch, type SignConfig, type AwsSigV4Sign, type ReplayHelpers, type ReplaySummary, type Cassette, type CassetteInteraction, type CassetteRequest, type CassetteResponse, type CassetteState, } from "./replayFake.js";
 export { electron, type ElectronOptions } from "./electron.js";
 export { android, type AndroidOptions } from "./android.js";

package/dist/components/replay-key.d.ts

@@ -23,5 +23,9 @@ export interface ReplayRequest {
     bytes(): Uint8Array;
 }
 export type ReplayKey = (request: ReplayRequest) => MatchKey;
+/** Stream a typed, length-delimited canonical representation into the hash.
+ *  Never call toJSON: unsupported values must fail rather than silently lose
+ *  identity fields. In particular, an async callback must not become `{}`. */
+export declare function hashKey(key: MatchKey): string;
 /** Internal only; the SDK exports the request/key types, not this function. */
 export declare function replaySignature(request: CassetteRequest, key?: ReplayKey): string;

package/dist/components/replay-key.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 /** Stream a typed, length-delimited canonical representation into the hash.
  *  Never call toJSON: unsupported values must fail rather than silently lose
  *  identity fields. In particular, an async callback must not become `{}`. */
-function hashKey(key) {
+export function hashKey(key) {
     const hash = createHash("sha256");
     const ancestors = new Set();
     const visit = (value) => {

package/dist/components/replay-websocket.d.ts

@@ -0,0 +1,75 @@
+import type { FakeWebSocketHandlers } from "../fake-websocket.js";
+import type { CassetteRequest } from "./replayFake.js";
+import { FakeWebSocketLifetime } from "../harness/fake-websocket-lifetime.js";
+import { type MatchKey } from "./replay-key.js";
+export type ReplayWebSocketMessage = string | Uint8Array;
+export type WebSocketKey<S = unknown> = ((message: ReplayWebSocketMessage) => MatchKey) | {
+    initial: S;
+    reduce(state: S, message: ReplayWebSocketMessage): {
+        state: S;
+        key: MatchKey;
+    };
+};
+export interface WebSocketTiming {
+    /** Number of emitted input keys required. Zero means connection opening. */
+    afterInput: number;
+    /** Milliseconds since that input key (or opening). */
+    delayMs: number;
+}
+export interface CassetteWebSocketMessage extends WebSocketTiming {
+    type: "text" | "binary";
+    /** UTF-8 text or base64 binary. */
+    data: string;
+}
+export interface CassetteWebSocket {
+    request: CassetteRequest;
+    protocol?: string;
+    inputs: string[];
+    messages: CassetteWebSocketMessage[];
+    /** Absent while recording a connection that is still open. */
+    close?: WebSocketTiming & {
+        initiator: "client" | "server";
+        code: number;
+        reason: string;
+    };
+}
+export declare function validateWebSocketKey<S>(key: WebSocketKey<S> | undefined): void;
+/** Clone once per connection; never retain incoming payloads. */
+export declare function websocketMatcher<S>(key?: WebSocketKey<S>): (message: ReplayWebSocketMessage) => string | null;
+export declare function validateWebSocketRecording(record: CassetteWebSocket): void;
+export interface WebSocketSession {
+    cancel(): void;
+}
+export declare function replayWebSocket(args: {
+    recording: CassetteWebSocket;
+    match: (message: ReplayWebSocketMessage) => string | null;
+    label: string;
+    timeoutMs: number;
+    lifetime?: FakeWebSocketLifetime;
+    finished(session: WebSocketSession, error?: Error): void;
+}): {
+    handlers: FakeWebSocketHandlers;
+    session: WebSocketSession;
+};
+/** Open upstream before accepting downstream, retaining only a bounded opening queue. */
+export declare function recordWebSocket(args: {
+    url: string;
+    ip: string;
+    host: string;
+    headers: Record<string, string>;
+    protocols: string[];
+    request: CassetteRequest;
+    match: (message: ReplayWebSocketMessage) => string | null;
+    redact(value: string): string;
+    secrets: {
+        ref: string;
+        value: string;
+    }[];
+    label: string;
+    captured(record: CassetteWebSocket): void;
+    lifetime?: FakeWebSocketLifetime;
+    finished(session: WebSocketSession, error?: Error): void;
+}): Promise<{
+    handlers: FakeWebSocketHandlers;
+    session: WebSocketSession;
+}>;

package/dist/components/replay-websocket.js

@@ -0,0 +1,414 @@
+import { createHash } from "node:crypto";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { FakeWebSocketLifetime, bindWebSocketLifetime } from "../harness/fake-websocket-lifetime.js";
+import { hashKey } from "./replay-key.js";
+// Bun's built-in ws shim does not support the external-DNS lookup option.
+const require = createRequire(import.meta.url);
+const { WebSocket } = require(join(dirname(require.resolve("ws/package.json")), "index.js"));
+const MAX_BUFFER = 16 * 1024 * 1024;
+const MAX_PENDING = 1024;
+export function validateWebSocketKey(key) {
+    if (key === undefined || typeof key === "function")
+        return;
+    if (!key || typeof key !== "object" || !("initial" in key) || typeof key.reduce !== "function") {
+        throw new Error("websocketKey must be a synchronous function or { initial, reduce }");
+    }
+    structuredClone(key.initial);
+}
+/** Clone once per connection; never retain incoming payloads. */
+export function websocketMatcher(key) {
+    let state = key && typeof key !== "function" ? structuredClone(key.initial) : undefined;
+    return message => {
+        if (!key)
+            return createHash("sha256").update(typeof message === "string" ? "text:" : "binary:").update(message).digest("hex");
+        let value;
+        if (typeof key === "function")
+            value = key(message);
+        else {
+            const next = key.reduce(state, message);
+            if (next instanceof Promise) {
+                void next.catch(() => { });
+                throw new Error("websocketKey reducer must be synchronous");
+            }
+            if (!next || typeof next !== "object" || !("state" in next) || !("key" in next)
+                || ("then" in next && typeof next.then === "function")) {
+                throw new Error("websocketKey reducer must return { state, key }");
+            }
+            value = next.key;
+            const signature = value === null ? null : hashKey(value);
+            state = next.state;
+            return signature;
+        }
+        return value === null ? null : hashKey(value);
+    };
+}
+export function validateWebSocketRecording(record) {
+    if (!record || !record.request || !Array.isArray(record.inputs)
+        || !record.inputs.every(k => typeof k === "string" && /^[a-f0-9]{64}$/.test(k))
+        || !Array.isArray(record.messages)) {
+        throw new Error("invalid WebSocket recording: expected request, input hashes and messages");
+    }
+    for (const message of record.messages) {
+        if (!message || typeof message.data !== "string" || !["text", "binary"].includes(message.type)) {
+            throw new Error("invalid WebSocket output message");
+        }
+        if (message.type === "binary" && !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(message.data)) {
+            throw new Error("invalid base64 WebSocket output");
+        }
+        if (Buffer.byteLength(message.data, message.type === "binary" ? "base64" : "utf8") > MAX_BUFFER) {
+            throw new Error("WebSocket output buffer exceeded");
+        }
+    }
+    let lastBarrier = 0;
+    let lastDelay = 0;
+    for (const event of [...record.messages, ...(record.close ? [record.close] : [])]) {
+        if (!Number.isInteger(event.afterInput) || event.afterInput < lastBarrier
+            || event.afterInput > record.inputs.length || !Number.isFinite(event.delayMs)
+            || event.delayMs < 0 || event.delayMs > 2_147_483_647
+            || (event.afterInput === lastBarrier && event.delayMs < lastDelay)) {
+            throw new Error("invalid WebSocket playback timing or input dependency");
+        }
+        lastBarrier = event.afterInput;
+        lastDelay = event.delayMs;
+    }
+    if (record.protocol !== undefined && (typeof record.protocol !== "string"
+        || !/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(record.protocol))) {
+        throw new Error("invalid WebSocket subprotocol");
+    }
+    if (record.close && (!["client", "server"].includes(record.close.initiator)
+        || !validCloseCode(record.close.code) || typeof record.close.reason !== "string"
+        || Buffer.byteLength(record.close.reason) > 123 || record.close.afterInput !== record.inputs.length)) {
+        throw new Error("invalid WebSocket closure");
+    }
+}
+function validCloseCode(code) {
+    return Number.isInteger(code) && ((code >= 1000 && code <= 1014 && ![1004, 1005, 1006].includes(code)) || (code >= 3000 && code <= 4999) || code === 1005 || code === 1006);
+}
+function closeSocket(socket, code, reason) {
+    // Reserved status codes describe transport closure and cannot go on the wire.
+    if (code === 1006 && socket.terminate)
+        socket.terminate();
+    else if (code === 1005 || code === 1006)
+        socket.close();
+    else
+        socket.close(code, reason);
+}
+export function replayWebSocket(args) {
+    const { recording: record, label } = args;
+    const lifetime = args.lifetime ?? new FakeWebSocketLifetime();
+    let detach = () => { };
+    let socket;
+    let position = 0;
+    let output = 0;
+    const barriers = [];
+    let timer;
+    let deadline;
+    let stopped = false;
+    let sentClose = false;
+    const diagnostic = (detail) => new Error(`${label}, input #${position + 1}: ${detail}`);
+    const clear = () => { clearTimeout(timer); clearTimeout(deadline); };
+    const finish = (error) => {
+        if (stopped)
+            return;
+        stopped = true;
+        clear();
+        detach();
+        lifetime.end(error ? { kind: "failed", error } : { kind: "aborted" });
+        args.finished(session, error);
+    };
+    const fail = (error) => {
+        finish(error);
+        socket?.close(1011, "WebSocket replay failed");
+    };
+    const missing = () => diagnostic(`required input never arrived; expected ${record.inputs[position]}`);
+    const armDeadline = () => {
+        clearTimeout(deadline);
+        if (position < record.inputs.length)
+            deadline = setTimeout(() => fail(missing()), args.timeoutMs);
+    };
+    const schedule = () => {
+        if (stopped || !socket || sentClose)
+            return;
+        clearTimeout(timer);
+        const event = record.messages[output] ?? (record.close?.initiator === "server" ? record.close : undefined);
+        if (!event || barriers[event.afterInput] === undefined)
+            return;
+        const delay = Math.max(0, barriers[event.afterInput] + event.delayMs - performance.now());
+        timer = setTimeout(() => {
+            if (stopped)
+                return;
+            try {
+                if ("data" in event) {
+                    socket.send(event.type === "text" ? event.data : new Uint8Array(Buffer.from(event.data, "base64")));
+                    output++;
+                    schedule();
+                }
+                else {
+                    sentClose = true;
+                    closeSocket(socket, event.code, event.reason);
+                }
+            }
+            catch (error) {
+                fail(diagnostic(`playback failed: ${error.message}`));
+            }
+        }, Math.min(delay, 2_147_483_647));
+    };
+    const session = {
+        cancel() { finish(); socket?.close(1001, "replay cleanup"); },
+    };
+    deadline = setTimeout(() => fail(diagnostic("connection never opened")), args.timeoutMs);
+    const handlers = {
+        protocol: record.protocol,
+        open(ws) {
+            socket = ws;
+            if (stopped) {
+                ws.close(1001, "replay cancelled");
+                return;
+            }
+            barriers[0] = performance.now();
+            armDeadline();
+            schedule();
+        },
+        message(_ws, message) {
+            if (stopped)
+                return;
+            try {
+                const actual = args.match(message);
+                if (actual === null)
+                    return;
+                const expected = record.inputs[position];
+                if (expected !== actual)
+                    throw new Error(`expected ${expected ?? "<exhausted>"}, actual ${actual}`);
+                barriers[++position] = performance.now();
+                armDeadline();
+                schedule();
+            }
+            catch (error) {
+                const failure = diagnostic(`matching failed: ${error.message}`);
+                fail(failure);
+                throw failure;
+            }
+        },
+        close(_ws, code, reason) {
+            if (stopped)
+                return;
+            let error;
+            if (position < record.inputs.length)
+                error = missing();
+            else if (output < record.messages.length || (record.close?.initiator === "server" && !sentClose))
+                error = diagnostic("unexpected connection closure before playback completed");
+            // A peer acknowledging our close need not echo its reason (Node's native
+            // WebSocket omits it). Only match the reason for client-initiated closes.
+            else if (record.close && (code !== record.close.code || (record.close.initiator === "client" && reason !== record.close.reason)))
+                error = diagnostic(`unexpected connection closure: expected code ${record.close.code}, actual ${code}${record.close.initiator === "client" ? `; expected reason ${JSON.stringify(record.close.reason)}, actual ${JSON.stringify(reason)}` : ""}`);
+            finish(error);
+        },
+    };
+    detach = lifetime.onEnd(event => {
+        if (event.kind === "closed" && socket)
+            handlers.close(socket, event.code, event.reason);
+        else
+            session.cancel();
+    });
+    return { session, handlers: bindWebSocketLifetime(handlers, lifetime) };
+}
+/** Open upstream before accepting downstream, retaining only a bounded opening queue. */
+export async function recordWebSocket(args) {
+    const lifetime = args.lifetime ?? new FakeWebSocketLifetime();
+    if (lifetime.ended)
+        throw new Error("WebSocket handshake aborted");
+    let detach = () => { };
+    const upstream = new WebSocket(args.url, args.protocols, {
+        headers: args.headers, maxPayload: MAX_BUFFER,
+        handshakeTimeout: 10_000,
+        lookup: ((_hostname, options, callback) => {
+            if (options.all)
+                callback(null, [{ address: args.ip, family: 4 }]);
+            else
+                callback(null, args.ip, 4);
+        }),
+    });
+    const record = { request: args.request, inputs: [], messages: [] };
+    let socket;
+    let anchor = performance.now();
+    let stopped = false;
+    let clientClosed = false;
+    let upstreamClosure;
+    let queue = [];
+    let queuedBytes = 0;
+    let openingTimer;
+    let opened = false;
+    let rejectOpen = () => { };
+    const timing = () => ({ afterInput: record.inputs.length, delayMs: Math.max(0, performance.now() - anchor) });
+    const scrub = (value) => {
+        const result = args.redact(value);
+        for (const secret of args.secrets)
+            if (secret.value && result.includes(secret.value))
+                throw new Error(`secret ${secret.ref} survived WebSocket redaction`);
+        return result;
+    };
+    const finish = (error) => {
+        if (stopped)
+            return;
+        stopped = true;
+        clearTimeout(openingTimer);
+        detach();
+        queue = [];
+        upstream.terminate();
+        lifetime.end(error ? { kind: "failed", error } : { kind: "aborted" });
+        args.finished(session, error);
+    };
+    const fail = (error) => {
+        if (stopped)
+            return;
+        const failure = new Error(`${args.label}: ${error.message}`);
+        rejectOpen(failure);
+        finish(failure);
+        socket?.close(1011, "WebSocket recording failed");
+    };
+    const session = {
+        cancel() { rejectOpen(new Error("WebSocket handshake aborted")); finish(); socket?.close(1001, "recording cleanup"); },
+    };
+    upstream.on("error", fail);
+    upstream.on("message", (data, binary) => {
+        if (stopped || clientClosed)
+            return;
+        try {
+            const bytes = Array.isArray(data) ? Buffer.concat(data) : Buffer.from(data);
+            const message = binary ? new Uint8Array(bytes) : bytes.toString();
+            // Redact bytes too: base64 encoding must not hide a brokered secret.
+            const redacted = binary ? redactBinary(bytes, args.redact, args.secrets) : scrub(bytes.toString());
+            record.messages.push({ ...timing(), type: binary ? "binary" : "text", data: redacted });
+            if (socket)
+                socket.send(message);
+            else {
+                queuedBytes += bytes.length;
+                if (queue.length >= MAX_PENDING || queuedBytes > MAX_BUFFER)
+                    throw new Error("WebSocket opening buffer exceeded");
+                queue.push(message);
+            }
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    upstream.on("close", (code, reason) => {
+        if (stopped)
+            return;
+        if (!opened) {
+            fail(new Error("upstream closed before handshake completed"));
+            return;
+        }
+        try {
+            if (!clientClosed) {
+                upstreamClosure = { code, reason: reason.toString() };
+                record.close = { ...timing(), initiator: "server", code, reason: scrub(reason.toString()) };
+            }
+            if (socket) {
+                closeSocket(socket, code, reason.toString());
+                finish();
+            }
+            // If the upstream closes before downstream open, open() flushes the queue.
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    const opening = new Promise((resolve, reject) => {
+        rejectOpen = reject;
+        upstream.once("open", () => {
+            try {
+                opened = true;
+                anchor = performance.now();
+                if (upstream.protocol)
+                    record.protocol = scrub(upstream.protocol);
+                args.captured(record);
+                openingTimer = setTimeout(() => fail(new Error("downstream did not open")), 10_000);
+                resolve();
+            }
+            catch (error) {
+                fail(error);
+            }
+        });
+    });
+    const handlers = {
+        open(ws) {
+            socket = ws;
+            clearTimeout(openingTimer);
+            if (stopped) {
+                ws.close(1011, "WebSocket recording failed");
+                return;
+            }
+            try {
+                for (const message of queue)
+                    ws.send(message);
+                queue = [];
+                queuedBytes = 0;
+                if (upstreamClosure) {
+                    closeSocket(ws, upstreamClosure.code, upstreamClosure.reason);
+                    finish();
+                }
+            }
+            catch (error) {
+                fail(error);
+            }
+        },
+        message(_ws, message) {
+            if (stopped)
+                return;
+            try {
+                const signature = args.match(typeof message === "string" ? message : Uint8Array.from(message));
+                if (signature !== null) {
+                    record.inputs.push(signature);
+                    anchor = performance.now();
+                }
+                const size = typeof message === "string" ? Buffer.byteLength(message) : message.byteLength;
+                if (size + upstream.bufferedAmount > MAX_BUFFER)
+                    throw new Error("WebSocket upstream buffer exceeded");
+                if (upstream.readyState !== WebSocket.OPEN)
+                    throw new Error("upstream is not open");
+                upstream.send(message);
+            }
+            catch (error) {
+                fail(error);
+                throw error;
+            }
+        },
+        close(_ws, code, reason) {
+            if (stopped || clientClosed)
+                return;
+            try {
+                clientClosed = true;
+                record.close = { ...timing(), initiator: "client", code, reason: scrub(reason) };
+                closeSocket(upstream, code, reason);
+                openingTimer = setTimeout(() => finish(), 1_000);
+            }
+            catch (error) {
+                fail(error);
+            }
+        },
+    };
+    detach = lifetime.onEnd(event => {
+        if (event.kind === "closed" && socket)
+            handlers.close(socket, event.code, event.reason);
+        else
+            session.cancel();
+    });
+    await opening;
+    handlers.protocol = upstream.protocol || undefined;
+    return { session, handlers: bindWebSocketLifetime(handlers, lifetime) };
+}
+function redactBinary(bytes, redact, secrets) {
+    // Preserve arbitrary bytes; textual patterns can only safely apply to valid UTF-8.
+    let output = bytes;
+    try {
+        const text = new TextDecoder("utf8", { fatal: true, ignoreBOM: true }).decode(bytes);
+        output = Buffer.from(redact(text));
+    }
+    catch { /* Binary payload; fail closed for embedded credentials below. */ }
+    for (const { ref, value } of secrets)
+        if (value && output.includes(Buffer.from(value)))
+            throw new Error(`secret ${ref} survived binary WebSocket redaction`);
+    return output.toString("base64");
+}

package/dist/components/replayFake.d.ts

@@ -1,4 +1,6 @@
 import type { FakeContext, FakeDefinition } from "../index.js";
+import { type WebSocketKey, type CassetteWebSocket, type WebSocketSession } from "./replay-websocket.js";
+export type { WebSocketKey, ReplayWebSocketMessage, CassetteWebSocket, CassetteWebSocketMessage, WebSocketTiming } from "./replay-websocket.js";
 import { type ReplayKey } from "./replay-key.js";
 export type { JsonValue, MatchKey, ReplayRequest, ReplayKey } from "./replay-key.js";
 /** Match one request dimension. A bare string is an exact match; the
@@ -62,7 +64,7 @@ export interface ReplayFakeContext extends FakeContext {
     replay(request: Request): Promise<Response>;
 }
 export type ReplayHandler<S> = (request: Request, state: S, ctx: ReplayFakeContext) => Response | Promise<Response>;
-export interface ReplayFakeOptions<S = undefined, H extends Record<string, unknown> = {}> {
+export interface ReplayFakeOptions<S = undefined, H extends Record<string, unknown> = {}, W = unknown> {
     /** Stable name — the `ctx.fakes` key. */
     name: string;
     /** The REAL host to fake, e.g. `"api.stripe.com"`. The fake answers for
@@ -79,6 +81,13 @@ export interface ReplayFakeOptions<S = undefined, H extends Record<string, unkno
      *  bytes; objects compare independently of property order. No implicit
      *  matching dimensions or fallback apply when a key is supplied. */
     key?: ReplayKey;
+    /** Complete messages (string or Uint8Array), synchronously reduced per connection.
+     * Return null to emit no input. Raw inputs are never stored; changing this
+     * matcher can require re-recording. Defaults to SHA-256(type + bytes). */
+    websocketKey?: WebSocketKey<W>;
+    /** Maximum wait for each required input key; null-producing messages do not
+     * extend it. Defaults to 30 seconds. */
+    websocketTimeoutMs?: number;
     /** Per-fake credential brokering. Rules are evaluated in
      *  order; the first whose `match` matches wins (a rule without `match`
      *  matches everything and shadows later rules). Applied at the
@@ -94,8 +103,9 @@ export interface ReplayFakeOptions<S = undefined, H extends Record<string, unkno
     /** Extra substrings/patterns to scrub from stored request/response
      *  bodies and queries (every injected secret value is always scrubbed). */
     redactPatterns?: (string | RegExp)[];
-    /** `"auto"` (default) records under eval and replays under test;
-     *  `"record"` / `"replay"` force a mode. */
+    /** `"auto"` (default) records in interactive environments and replays in
+     *  tests. `"replay"` always replays; `"record"` requires an interactive
+     *  environment. Test environments always replay, even between cases. */
     mode?: "auto" | "record" | "replay";
     /** Custom state, with the same lifecycle as a normal fake's state. Kept
      *  separate from cassette internals; helpers and handler see only S. */
@@ -143,6 +153,7 @@ export interface Cassette {
     /** The real host this cassette mirrors (e.g. `api.stripe.com`). */
     host: string;
     interactions: CassetteInteraction[];
+    websockets?: CassetteWebSocket[];
 }
 /** Forked-per-test state for one replay fake. */
 export interface CassetteState {
@@ -154,6 +165,11 @@ export interface CassetteState {
     /** Interactions captured this record session. */
     recorded: CassetteInteraction[];
     dirty: boolean;
+    websocketIndex: Map<string, number[]>;
+    websocketCursor: Map<string, number>;
+    recordedWebSockets: CassetteWebSocket[];
+    websocketSessions: Set<WebSocketSession>;
+    websocketErrors: string[];
 }
 /** What `replay(...)` returns — a small summary that surfaces in the test
  *  timeline (recorded as a `fake` event) so the run shows exactly which
@@ -165,6 +181,7 @@ export interface ReplaySummary {
     host: string;
     /** Number of interactions now available for replay. */
     interactions: number;
+    websockets?: number;
 }
 export interface ReplayHelpers extends Record<string, unknown> {
     /** Load a cassette into THIS fork's replay set for delegated requests,
@@ -185,6 +202,6 @@ export interface ReplayHelpers extends Record<string, unknown> {
     /** Count of interactions captured this record session. */
     count(): number;
 }
-export declare function replayFake<S = undefined, H extends Record<string, unknown> = {}>(opts: ReplayFakeOptions<S, H>): FakeDefinition<CassetteState & {
+export declare function replayFake<S = undefined, H extends Record<string, unknown> = {}, W = unknown>(opts: ReplayFakeOptions<S, H, W>): FakeDefinition<CassetteState & {
     custom: S;
 }, ReplayHelpers & H>;