@fuzdev/fuz_app 0.134.0 → 0.135.0

package/dist/testing/cross_backend/testing_reset_actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing_reset_actions.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_reset_actions.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,EAAc,KAAK,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAMzE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AAoCzC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;QAiBpC;;;;;;;;WAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWyC,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;CAWA,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;CAwBC,CAAC;AAE/C;;;;;;;;GAQG;AACH,eAAO,MAAM,mCAAmC,GAAI,OAAO,YAAY,KAAG,SAIvE,CAAC;AAEJ;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;CAeK,CAAC;AAE/C;;;;;;;;;GASG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWF,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,qCAAqC,QAAO,SAGvD,CAAC;AAEH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;CAYJ,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,uCAAuC,QAAO,SAGzD,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAaF,CAAC;AAkB/C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qCAAqC,GACjD,SAAS,aAAa,CAAC,SAAS,CAAC,KAC/B,SAMF,CAAC;AAEF,4CAA4C;AAC5C,MAAM,WAAW,2BAA2B;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IACjD;;;;;;OAMG;IACH,QAAQ,CAAC,kBAAkB,EAAE,gBAAgB,CAAC;IAC9C;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACxD;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,sBAAsB,GAClC,MAAM,OAAO,EACb,SAAS,2BAA2B,KAClC,KAAK,CAAC,SAAS,CA4IjB,CAAC"}
+{"version":3,"file":"testing_reset_actions.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_reset_actions.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,EAAc,KAAK,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAOzE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AAoCzC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;QAiBpC;;;;;;;;WAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWyC,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;CAWA,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;CAwBC,CAAC;AAE/C;;;;;;;;GAQG;AACH,eAAO,MAAM,mCAAmC,GAAI,OAAO,YAAY,KAAG,SAIvE,CAAC;AAEJ;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;CAeK,CAAC;AAE/C,kFAAkF;AAClF,eAAO,MAAM,iCAAiC,mBAAmB,CAAC;AAElE;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,QAAS,CAAC;AAE9C,sFAAsF;AACtF,eAAO,MAAM,sBAAsB,QAAmB,CAAC;AAEvD;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,QAAmB,CAAC;AAE9D,8FAA8F;AAC9F,eAAO,MAAM,iCAAiC,kBAAkB,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;CAwBN,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,yCAAyC,QAAO,SAmB1D,CAAC;AAEJ;;;;;;;;;GASG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWF,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,qCAAqC,QAAO,SAGvD,CAAC;AAEH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;CAYJ,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,uCAAuC,QAAO,SAGzD,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAaF,CAAC;AAkB/C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qCAAqC,GACjD,SAAS,aAAa,CAAC,SAAS,CAAC,KAC/B,SAMF,CAAC;AAEF,4CAA4C;AAC5C,MAAM,WAAW,2BAA2B;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IACjD;;;;;;OAMG;IACH,QAAQ,CAAC,kBAAkB,EAAE,gBAAgB,CAAC;IAC9C;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACxD;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,sBAAsB,GAClC,MAAM,OAAO,EACb,SAAS,2BAA2B,KAClC,KAAK,CAAC,SAAS,CA6IjB,CAAC"}

package/dist/testing/cross_backend/testing_reset_actions.js

@@ -8,10 +8,12 @@ import '../assert_dev_env.js';
  * expired-by-construction server-side session for the expiry conformance
  * cases), **`_testing_put_fact`** (seed an embedded fact for the fact-serving
  * suite), **`_testing_schema_snapshot`** (introspect the live schema for
- * cross-impl parity diffing against a Rust backend's `fuz_db` snapshot), and
+ * cross-impl parity diffing against a Rust backend's `fuz_db` snapshot),
  * **`_testing_migration_tracker`** (dump the `schema_version` tracker rows for
  * cross-impl migration-identity parity — the provenance half the snapshot gate
- * excludes by design).
+ * excludes by design), and **`_testing_flood_notifications`** (queue a burst
+ * of notifications onto the caller's own WebSocket connection, to push its
+ * outbound queue past its byte budget).
  *
  * A further daemon-token action, **`_testing_action_manifest`** (dump the live
  * RPC registry for cross-impl method-set + auth-shape parity), lives here too
@@ -72,6 +74,7 @@ import { Uuid } from '@fuzdev/fuz_util/id.ts';
 import { fact_hash_bytes } from '@fuzdev/fuz_util/fact_hash.ts';
 import { FactHashSchema } from '@fuzdev/fuz_util/hash_schemas.ts';
 import { rpc_action } from '../../actions/action_rpc.js';
+import { jsonrpc_errors } from '../../http/jsonrpc_errors.js';
 import { emit_after_commit } from '../../http/pending_effects.js';
 import { protocol_action_specs } from '../../actions/protocol.js';
 import { query_put_fact } from '../../db/fact_queries.js';
@@ -291,6 +294,101 @@ export const testing_put_fact_action_spec = {
     description: 'Test-binary only — seed an embedded fact (blake3 of the UTF-8 content) and return its hash, ' +
         'so the cross-process fact-serving suite can store bytes without a DB handle.'
 };
+/** The wire method of each notification `_testing_flood_notifications` queues. */
+export const TESTING_FLOOD_NOTIFICATION_METHOD = '_testing_flood';
+/**
+ * The most notifications one `_testing_flood_notifications` call queues.
+ * Empty ones at this count are charged more than
+ * `DEFAULT_WS_OUTBOUND_QUEUE_BYTES` between them — each frame's envelope and
+ * its overhead — so a burst of tiny frames can overflow a connection on a
+ * default transport too. Same value as the Rust spine's.
+ */
+export const TESTING_FLOOD_MAX_COUNT = 65_536;
+/** The largest `payload` one `_testing_flood_notifications` call builds, in bytes. */
+export const TESTING_FLOOD_MAX_SIZE = 16 * 1024 * 1024;
+/**
+ * The most payload bytes one `_testing_flood_notifications` call builds across
+ * all its notifications — the bound on `count` × `size`. The handler
+ * serializes each notification without yielding, so the product is how long
+ * one call holds the event loop.
+ */
+export const TESTING_FLOOD_MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+/** The `data.reason` of the refusal `_testing_flood_notifications` gives a call over HTTP. */
+export const ERROR_TESTING_FLOOD_NO_CONNECTION = 'no_connection';
+/**
+ * `_testing_flood_notifications` — queue a burst of notifications onto the
+ * **caller's own WebSocket connection**, all in one synchronous run, so a suite
+ * driving the server from outside can push a connection's outbound queue past
+ * its byte budget deterministically — without a second producer, and whether
+ * or not its client is reading: the connection's write pump gets no turn while
+ * the handler runs, so the burst waits at once. Past the budget the server
+ * closes the socket with `WS_CLOSE_OUTBOUND_OVERFLOW`.
+ *
+ * Each notification is
+ * `{"jsonrpc":"2.0","method":"_testing_flood","params":{"index":<i>,"payload":"<size × 'x'>"}}`
+ * with `index` counting from 0, so every frame is a little longer than `size`
+ * bytes and a client can tell which frames reached it.
+ *
+ * The result is `{queued: count}` — the number asked for, not the number that
+ * fit: when the burst overflows the queue the connection is closed and this
+ * response is never written. A burst that fits arrives in order, ahead of the
+ * response.
+ *
+ * A call past `TESTING_FLOOD_MAX_COUNT`, `TESTING_FLOOD_MAX_SIZE`, or
+ * `TESTING_FLOOD_MAX_TOTAL_BYTES` (`count` × `size`) is refused with
+ * `invalid_params` and queues nothing. Over HTTP there is no connection to
+ * queue onto, so the call is refused with `invalid_params`, reason
+ * `ERROR_TESTING_FLOOD_NO_CONNECTION`, rather than answering as though it had
+ * flooded something.
+ *
+ * `auth` gates on the daemon-token credential, matching `_testing_reset`. The
+ * Rust mirror is `fuz_testing::create_testing_flood_notifications_action_spec`.
+ */
+export const testing_flood_notifications_action_spec = {
+    method: '_testing_flood_notifications',
+    kind: 'request_response',
+    initiator: 'frontend',
+    auth: TESTING_ACTION_AUTH,
+    side_effects: false,
+    input: z.strictObject({
+        count: z.number().int().min(0).max(TESTING_FLOOD_MAX_COUNT).meta({
+            description: 'How many notifications to queue.'
+        }),
+        size: z.number().int().min(0).max(TESTING_FLOOD_MAX_SIZE).meta({
+            description: "The byte length of each notification's `payload` string."
+        })
+    }),
+    output: z.strictObject({
+        queued: z.number().int().meta({
+            description: 'The number of notifications asked for — not the number that fit.'
+        })
+    }),
+    async: true,
+    error_reasons: [ERROR_TESTING_FLOOD_NO_CONNECTION],
+    description: "Test-binary only — queue a burst of notifications onto the caller's own WebSocket " +
+        'connection in one synchronous run, to push its outbound queue past its byte budget.'
+};
+/**
+ * Build the standalone `_testing_flood_notifications` action (see the spec
+ * doc). The spine binary bundles it via `create_testing_actions`; mount it
+ * directly on an in-process WS endpoint whose suite drives an outbound
+ * overflow.
+ */
+export const create_testing_flood_notifications_action = () => 
+// not `async`: the burst must be queued in one synchronous run
+rpc_action(testing_flood_notifications_action_spec, ({ count, size }, ctx) => {
+    if (count * size > TESTING_FLOOD_MAX_TOTAL_BYTES) {
+        throw jsonrpc_errors.invalid_params(`count * size must be at most ${TESTING_FLOOD_MAX_TOTAL_BYTES}`);
+    }
+    if (ctx.connection_id === undefined) {
+        throw jsonrpc_errors.invalid_params('_testing_flood_notifications needs a WebSocket connection', { reason: ERROR_TESTING_FLOOD_NO_CONNECTION });
+    }
+    const payload = 'x'.repeat(size);
+    for (let index = 0; index < count; index++) {
+        ctx.notify(TESTING_FLOOD_NOTIFICATION_METHOD, { index, payload });
+    }
+    return { queued: count };
+});
 /**
  * `_testing_schema_snapshot` — introspect the live database into a normalized
  * `SchemaSnapshot` for cross-impl parity diffing. The cross-backend harness
@@ -555,6 +653,7 @@ export const create_testing_actions = (deps, options) => {
             return { hash };
         }),
         create_testing_drain_effects_action(deps.audit),
+        create_testing_flood_notifications_action(),
         create_testing_schema_snapshot_action(),
         create_testing_migration_tracker_action()
     ];

package/dist/testing/cross_backend/ts_spine_backend_config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ts_spine_backend_config.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/ts_spine_backend_config.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAsDzD,6FAA6F;AAC7F,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C,iDAAiD;AACjD,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C,gDAAgD;AAChD,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,wDAAwD,CAAC;AAEzF,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,wDAAwD,CAAC;AAEzF,wDAAwD;AACxD,eAAO,MAAM,kBAAkB,uDAAuD,CAAC;AAEvF,MAAM,WAAW,2BAA2B;IAC3C,mFAAmF;IACnF,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,6DAA6D;IAC7D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;;;;;;OASG;IACH,QAAQ,CAAC,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAC3C;;;;;;OAMG;IACH,QAAQ,CAAC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAC5C;;;;;OAKG;IACH,QAAQ,CAAC,8BAA8B,CAAC,EAAE,MAAM,CAAC;CACjD;AAWD;;;GAGG;AACH,eAAO,MAAM,4BAA4B,GACxC,UAAS,2BAAgC,KACvC,aAoBF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,GACvC,UAAS,2BAAgC,KACvC,aAoBF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B,GACxC,UAAS,2BAAgC,KACvC,aAiCF,CAAC"}
+{"version":3,"file":"ts_spine_backend_config.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/ts_spine_backend_config.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAwDzD,6FAA6F;AAC7F,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C,iDAAiD;AACjD,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C,gDAAgD;AAChD,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,wDAAwD,CAAC;AAEzF,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,wDAAwD,CAAC;AAEzF,wDAAwD;AACxD,eAAO,MAAM,kBAAkB,uDAAuD,CAAC;AAEvF,MAAM,WAAW,2BAA2B;IAC3C,mFAAmF;IACnF,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,6DAA6D;IAC7D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;;;;;;OASG;IACH,QAAQ,CAAC,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAC3C;;;;;;OAMG;IACH,QAAQ,CAAC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAC5C;;;;;OAKG;IACH,QAAQ,CAAC,8BAA8B,CAAC,EAAE,MAAM,CAAC;CACjD;AAWD;;;GAGG;AACH,eAAO,MAAM,4BAA4B,GACxC,UAAS,2BAAgC,KACvC,aAoBF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,GACvC,UAAS,2BAAgC,KACvC,aAoBF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B,GACxC,UAAS,2BAAgC,KACvC,aAiCF,CAAC"}

package/dist/testing/cross_backend/ts_spine_backend_config.js

@@ -23,13 +23,15 @@ const ts_spine_capabilities = Object.freeze({
 /**
  * Capabilities for the **Bun** spine binary — `ts_spine_capabilities` with
  * `oversized_reject_closes_connection: false` and
- * `ws_handshake_pipelining: false`. `Bun.serve` drains the declared
- * `Content-Length` of an oversized-body `413` reject and keeps the socket
- * alive (processing the correctly-framed pipelined request) even when the
- * response carries `Connection: close`, unlike `@hono/node-server` / Deno /
- * hyper, which close. Bun is not insecure — it frames on `Content-Length`, so
- * there is no desync — but the smuggling suite's strong "connection closes"
- * assertion doesn't hold; this flag routes Bun onto the suite's no-desync arm.
+ * `ws_handshake_pipelining: false`.
+ *
+ * `Bun.serve` does not close the connection after an oversized-body `413`:
+ * the response carries `Connection: close`, and Bun keeps the socket open,
+ * skips the declared body, and serves the request that follows it (observed
+ * on Bun 1.3.11). The next request is framed on `Content-Length`, so nothing
+ * is desynchronized, but the smuggling suite's "the pipelined request is never
+ * served" assertion does not hold; the flag puts Bun on the suite's no-desync
+ * arm, which requires exactly the 413 and the reply to the pipelined request.
  * See `docs/security.md` §"Body Size Limiting".
  *
  * `Bun.serve` also answers `400` to an upgrade request that carries WebSocket

package/dist/testing/cross_backend/ws_outbound_overflow.d.ts

@@ -0,0 +1,29 @@
+import '../assert_dev_env.js';
+import { type BackendCapabilities } from './capabilities.js';
+import type { SetupTest } from './setup.js';
+/** Options for the outbound-overflow parity suite. */
+export interface WsOutboundOverflowCrossTestOptions {
+    /** Per-test fixture producer (`default_cross_process_setup(handle)`). */
+    readonly setup_test: SetupTest;
+    /** Backend capability flags; every WebSocket case gates on `capabilities.ws`. */
+    readonly capabilities: BackendCapabilities;
+    /** Base URL the backend is reachable at (e.g. `http://localhost:1178`). */
+    readonly base_url: string;
+    /** WebSocket endpoint path on the backend (e.g. `/api/ws`). */
+    readonly ws_path: string;
+    /** Origin for the session socket's upgrade. Defaults to `base_url`. */
+    readonly origin?: string;
+    /**
+     * The backend's RPC endpoint path, for the over-HTTP refusal. Omitted, that
+     * case is skipped.
+     */
+    readonly rpc_path?: string;
+}
+/**
+ * Register the outbound-overflow parity suite over a real upgrade: a burst
+ * within the budget arrives whole, one past it closes the socket with
+ * `WS_CLOSE_OUTBOUND_OVERFLOW` and no response, and the account's other
+ * connection is unaffected.
+ */
+export declare const describe_ws_outbound_overflow_cross_tests: (options: WsOutboundOverflowCrossTestOptions) => void;
+//# sourceMappingURL=ws_outbound_overflow.d.ts.map

package/dist/testing/cross_backend/ws_outbound_overflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws_outbound_overflow.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/ws_outbound_overflow.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAiE9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AAEtE,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,YAAY,CAAC;AAiCzD,sDAAsD;AACtD,MAAM,WAAW,kCAAkC;IAClD,yEAAyE;IACzE,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,iFAAiF;IACjF,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uEAAuE;IACvE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;GAKG;AACH,eAAO,MAAM,yCAAyC,GACrD,SAAS,kCAAkC,KACzC,IA0LF,CAAC"}

package/dist/testing/cross_backend/ws_outbound_overflow.js

@@ -0,0 +1,211 @@
+import '../assert_dev_env.js';
+/**
+ * Cross-backend parity suite for the **per-connection outbound bound** over a
+ * real upgrade.
+ *
+ * Both spines hold what waits to be written to one WebSocket to a byte budget
+ * (`BackendWebsocketTransport`'s `outbound_queue_bytes` on the TS side, the
+ * Rust `fuz_realtime` outbound queue on the other; both default to 4 MiB, each
+ * waiting frame charged its UTF-8 length plus 64 bytes). A frame that does not
+ * fit closes the socket with `WS_CLOSE_OUTBOUND_OVERFLOW` and the reason
+ * `outbound queue overflow`; the credential stays good, so a client reconnects
+ * under its ordinary backoff. The code and the reason are therefore wire
+ * contract, and this suite is the pin that runs on both.
+ *
+ * It drives the backend's `_testing_flood_notifications` action, which queues
+ * a burst of notifications onto the caller's own connection in one synchronous
+ * run — so the burst waits at once whether or not the client is reading, and
+ * the overflow is deterministic. The cases:
+ *
+ * - **within the budget** — a small burst arrives whole and in order, ahead of
+ *   its response, and the socket stays open.
+ * - **large, within the budget** — a burst of a few mebibytes, most of the
+ *   default budget, arrives the same way: every frame whole, in order, the
+ *   response last. Megabyte frames can outrun a socket's buffer, and where
+ *   they do — the Deno TS spine, as observed; Node and Bun write the burst
+ *   through — the frames behind the first wait on the backend's write pump.
+ * - **overflow** — a burst far past the budget closes the socket with the code
+ *   and the exact reason; the response of the flooding request never arrives;
+ *   any flood frames that did arrive form a contiguous prefix of the burst.
+ *   A second connection on the same account keeps dispatching throughout.
+ * - **refusal** — a burst past the action's own size limit is refused with
+ *   `invalid_params`, and the socket stays open.
+ * - **no connection** — over HTTP RPC the action refuses with `invalid_params`
+ *   and reason `no_connection`, rather than answering as though it flooded.
+ *
+ * What the suite does **not** assert, because it is each implementation's own:
+ * how many frames accepted before the overflow reach the client (the Rust
+ * spine discards them all; the TS spine may deliver the first), and the exact
+ * boundary a burst of tiny frames overflows at.
+ *
+ * The wire literals are deliberate independent copies of the producers'
+ * constants — parity by test, so a value changed on one side fails here
+ * instead of moving both at once.
+ *
+ * The flood action is gated on the daemon token, so the flooding socket
+ * upgrades with it and no `Origin` (both spines discard a daemon token
+ * presented in a browser context). Gated on `capabilities.ws`; cross-process
+ * only (`create_ws_transport` needs a real bound socket), and only for a
+ * backend that mounts `_testing_flood_notifications` on its WS endpoint.
+ *
+ * @module
+ */
+import { assert, describe } from 'vitest';
+import { create_jsonrpc_request } from '../../http/jsonrpc_helpers.js';
+import { create_admitted_ws_transport } from '../transports/ws_transport.js';
+import { is_notification, is_response_for } from '../transports/ws_client.js';
+import { test_if } from './capabilities.js';
+import { cross_rpc_call } from './cell_cross_helpers.js';
+/** The close code both spines send on an outbound overflow. */
+const WS_CLOSE_OUTBOUND_OVERFLOW = 4005;
+/** The close reason both spines send with it. */
+const OUTBOUND_OVERFLOW_REASON = 'outbound queue overflow';
+const FLOOD_METHOD = '_testing_flood_notifications';
+const FLOOD_NOTIFICATION_METHOD = '_testing_flood';
+const HEARTBEAT_METHOD = 'heartbeat';
+const INVALID_PARAMS = -32602;
+const REASON_NO_CONNECTION = 'no_connection';
+const MIB = 1024 * 1024;
+/** A burst within any budget. */
+const FITS = { count: 3, size: 8 };
+/**
+ * A burst of 3 MiB in megabyte frames: charged a little over 3 MiB with its
+ * envelopes and overhead, inside the 4 MiB default budget.
+ */
+const LARGE_FITS = { count: 3, size: MIB };
+/** A burst of 32 MiB — eight times the default budget. */
+const OVERFLOWS = { count: 32, size: MIB };
+/** One mebibyte past the action's `count` × `size` limit. */
+const REFUSED = { count: 65, size: MIB };
+/** How long the test waits for the megabyte burst and its response. */
+const LARGE_BURST_TIMEOUT_MS = 15_000;
+/** How long the test waits for the overflow close. */
+const CLOSE_TIMEOUT_MS = 15_000;
+/**
+ * Register the outbound-overflow parity suite over a real upgrade: a burst
+ * within the budget arrives whole, one past it closes the socket with
+ * `WS_CLOSE_OUTBOUND_OVERFLOW` and no response, and the account's other
+ * connection is unaffected.
+ */
+export const describe_ws_outbound_overflow_cross_tests = (options) => {
+    const { setup_test, capabilities, base_url, ws_path, origin, rpc_path } = options;
+    /** A daemon-token socket the backend has admitted — the one that floods itself. */
+    const open_flooder = (fixture) => create_admitted_ws_transport({
+        base_url,
+        ws_path,
+        cookies: [],
+        origin: null,
+        headers: fixture.create_daemon_token_headers()
+    });
+    /** The `index` of every flood notification `client` received, in arrival order. */
+    const flood_indices = (client) => client.messages
+        .filter(is_notification(FLOOD_NOTIFICATION_METHOD))
+        .map((msg) => msg.params.index);
+    const assert_open_and_answering = async (client, id, message) => {
+        assert.deepStrictEqual(await client.request(id, HEARTBEAT_METHOD, {}), {}, message);
+        assert.strictEqual(client.close_code, null, message);
+    };
+    describe('websocket outbound overflow parity', { timeout: 30_000 }, () => {
+        test_if(capabilities.ws, 'a burst within the budget arrives in order, ahead of its response', async () => {
+            const fixture = await setup_test();
+            const client = await open_flooder(fixture);
+            try {
+                const result = await client.request('fits', FLOOD_METHOD, FITS);
+                assert.deepStrictEqual(result, { queued: FITS.count });
+                assert.deepStrictEqual(flood_indices(client), [0, 1, 2]);
+                const frames = client.messages.filter(is_notification(FLOOD_NOTIFICATION_METHOD));
+                for (const frame of frames) {
+                    assert.strictEqual(frame.params.payload, 'x'.repeat(FITS.size));
+                }
+                // the whole burst is ahead of the response
+                const response_at = client.messages.findIndex(is_response_for('fits'));
+                const last_flood_at = client.messages.lastIndexOf(frames.at(-1));
+                assert.ok(last_flood_at < response_at, 'the burst precedes its response');
+                await assert_open_and_answering(client, 'after_fits', 'the socket stays open');
+            }
+            finally {
+                await client.close().catch(() => { });
+            }
+        });
+        test_if(capabilities.ws, 'a multi-megabyte burst within the budget arrives whole and in order, the response last', async () => {
+            const fixture = await setup_test();
+            const client = await open_flooder(fixture);
+            try {
+                const result = await client.request('large_fits', FLOOD_METHOD, LARGE_FITS, LARGE_BURST_TIMEOUT_MS);
+                assert.deepStrictEqual(result, { queued: LARGE_FITS.count });
+                assert.deepStrictEqual(flood_indices(client), [0, 1, 2]);
+                const frames = client.messages.filter(is_notification(FLOOD_NOTIFICATION_METHOD));
+                const payload = 'x'.repeat(LARGE_FITS.size);
+                for (const frame of frames) {
+                    // compared by length first: a mismatch would otherwise print a mebibyte
+                    assert.strictEqual(frame.params.payload.length, LARGE_FITS.size);
+                    assert.ok(frame.params.payload === payload, 'the payload arrived intact');
+                }
+                // nothing follows the response: the whole burst is ahead of it
+                const response_at = client.messages.findIndex(is_response_for('large_fits'));
+                const last_flood_at = client.messages.lastIndexOf(frames.at(-1));
+                assert.ok(last_flood_at < response_at, 'the burst precedes its response');
+                assert.strictEqual(client.close_code, null, 'a burst within the budget closes nothing');
+                await assert_open_and_answering(client, 'after_large_fits', 'the socket stays open');
+            }
+            finally {
+                await client.close().catch(() => { });
+            }
+        });
+        test_if(capabilities.ws, 'a burst past the budget closes the socket with WS_CLOSE_OUTBOUND_OVERFLOW and no response', async () => {
+            const fixture = await setup_test();
+            // a second connection on the same account (the keeper's session)
+            const bystander = await create_admitted_ws_transport({
+                base_url,
+                ws_path,
+                cookies: fixture.transport.cookies(),
+                origin
+            });
+            const client = await open_flooder(fixture);
+            try {
+                await client.send(create_jsonrpc_request(FLOOD_METHOD, OVERFLOWS, 'overflows'));
+                const closed = await client.wait_for_close(CLOSE_TIMEOUT_MS);
+                assert.ok(closed, 'the flooded socket did not close');
+                assert.strictEqual(client.close_code, WS_CLOSE_OUTBOUND_OVERFLOW);
+                assert.strictEqual(client.close_reason, OUTBOUND_OVERFLOW_REASON);
+                // the response of the request whose handler overflowed is not sent
+                assert.strictEqual(client.messages.some(is_response_for('overflows')), false, 'no response may follow an overflow');
+                // frames accepted before the overflow may or may not arrive; any
+                // that do are a contiguous prefix of the burst, and never all of it
+                const indices = flood_indices(client);
+                assert.ok(indices.length < OVERFLOWS.count, `${indices.length} flood frames arrived`);
+                assert.deepStrictEqual(indices, indices.map((_, i) => i), 'the flood frames that arrived are a contiguous prefix from index 0');
+                // the account's other connection kept working through it
+                await assert_open_and_answering(bystander, 'bystander', "another connection on the account is untouched by the first one's overflow");
+                // not a revocation: the daemon token still upgrades
+                const again = await open_flooder(fixture);
+                await again.close();
+            }
+            finally {
+                await Promise.all([client.close().catch(() => { }), bystander.close().catch(() => { })]);
+            }
+        });
+        test_if(capabilities.ws, 'a burst past the flood action size limit is refused, and the socket stays open', async () => {
+            const fixture = await setup_test();
+            const client = await open_flooder(fixture);
+            try {
+                await client.send(create_jsonrpc_request(FLOOD_METHOD, REFUSED, 'refused'));
+                const frame = await client.wait_for(is_response_for('refused'));
+                assert.ok(frame.error, 'expected invalid_params but the call succeeded');
+                assert.strictEqual(frame.error.code, INVALID_PARAMS);
+                assert.deepStrictEqual(flood_indices(client), [], 'a refused burst queues nothing');
+                await assert_open_and_answering(client, 'after_refused', 'the socket stays open');
+            }
+            finally {
+                await client.close().catch(() => { });
+            }
+        });
+        test_if(rpc_path !== undefined, 'over HTTP the flood action refuses with invalid_params, reason no_connection', async () => {
+            const fixture = await setup_test();
+            const res = await cross_rpc_call(fixture.fresh_transport({ origin: null }), rpc_path, FLOOD_METHOD, FITS, fixture.create_daemon_token_headers());
+            assert.strictEqual(res.ok, false, 'expected a refusal over HTTP');
+            assert.strictEqual(res.error?.code, INVALID_PARAMS);
+            assert.strictEqual(res.error?.data?.reason, REASON_NO_CONNECTION);
+        });
+    });
+};

package/dist/testing/integration.js

@@ -4,7 +4,7 @@ import './assert_dev_env.js';
  *
  * `describe_standard_integration_tests` creates a composable test suite that
  * exercises the full middleware stack (origin, session, bearer_auth, request_context)
- * against a real PGlite database. Consumers call it with their route factory and
+ * against a real database. Consumers call it with their route factory and
  * session config — all auth route tests come for free.
  *
  * Tests use `stub_password_deps` (deterministic hashing, no Argon2 overhead).

package/dist/testing/schema_introspect.d.ts

@@ -14,10 +14,18 @@ import './assert_dev_env.js';
  *   so a label set / ordering drift (e.g. `cell_visibility`) is a gated fact,
  *   not invisible
  *
- * Designed for `pg_catalog` introspection — works against both PostgreSQL
- * and PGlite. The snapshot is fully deterministic: every collection sorts by
+ * Designed for `pg_catalog` introspection — it runs on PostgreSQL, PGlite and
+ * pglet. The snapshot is fully deterministic: every collection sorts by
  * a stable key and excludes time-varying fields like `applied_at`.
  *
+ * Index and constraint definitions are compared as the engine renders them,
+ * so both sides of a parity comparison need engines that render alike. pglet
+ * leaves an index's modifiers out of `pg_indexes.indexdef` — per-key sort
+ * direction, `NULLS` placement, operator classes, `NULLS NOT DISTINCT` — so a
+ * pglet snapshot diffed against a PostgreSQL one reports every index that
+ * uses one, with identical DDL on both sides. Take both snapshots on
+ * PostgreSQL.
+ *
  * Paired with `testing/schema_parity.ts` for comparison + assertion helpers.
  *
  * @module

package/dist/testing/schema_introspect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema_introspect.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/schema_introspect.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;iBAWzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,qCAAqC;AACrC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;iBAOxB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,qFAAqF;AACrF,eAAO,MAAM,gBAAgB;;iBAE3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;iBAG3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;iBAOzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB;;;;iBAOhC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;iBAE3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,GAAU,IAAI,EAAE,KAAG,OAAO,CAAC,gBAAgB,CAa9E,CAAC;AAEF,kDAAkD;AAClD,MAAM,WAAW,0BAA0B;IAC1C;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAChD;AA8DD;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GACjC,IAAI,EAAE,EACN,UAAS,0BAA+B,KACtC,OAAO,CAAC,cAAc,CAyHxB,CAAC"}
+{"version":3,"file":"schema_introspect.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/schema_introspect.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;iBAWzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,qCAAqC;AACrC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;iBAOxB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,qFAAqF;AACrF,eAAO,MAAM,gBAAgB;;iBAE3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;iBAG3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;iBAOzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB;;;;iBAOhC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;iBAE3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,GAAU,IAAI,EAAE,KAAG,OAAO,CAAC,gBAAgB,CAa9E,CAAC;AAEF,kDAAkD;AAClD,MAAM,WAAW,0BAA0B;IAC1C;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAChD;AA8DD;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GACjC,IAAI,EAAE,EACN,UAAS,0BAA+B,KACtC,OAAO,CAAC,cAAc,CAyHxB,CAAC"}

package/dist/testing/schema_introspect.js

@@ -14,10 +14,18 @@ import './assert_dev_env.js';
  *   so a label set / ordering drift (e.g. `cell_visibility`) is a gated fact,
  *   not invisible
  *
- * Designed for `pg_catalog` introspection — works against both PostgreSQL
- * and PGlite. The snapshot is fully deterministic: every collection sorts by
+ * Designed for `pg_catalog` introspection — it runs on PostgreSQL, PGlite and
+ * pglet. The snapshot is fully deterministic: every collection sorts by
  * a stable key and excludes time-varying fields like `applied_at`.
  *
+ * Index and constraint definitions are compared as the engine renders them,
+ * so both sides of a parity comparison need engines that render alike. pglet
+ * leaves an index's modifiers out of `pg_indexes.indexdef` — per-key sort
+ * direction, `NULLS` placement, operator classes, `NULLS NOT DISTINCT` — so a
+ * pglet snapshot diffed against a PostgreSQL one reports every index that
+ * uses one, with identical DDL on both sides. Take both snapshots on
+ * PostgreSQL.
+ *
  * Paired with `testing/schema_parity.ts` for comparison + assertion helpers.
  *
  * @module
@@ -187,11 +195,11 @@ export const query_schema_snapshot = async (db, options = {}) => {
 		 WHERE schemaname = $1
 		 ORDER BY tablename ASC, indexname ASC`, [schema]);
     // Constraints — pg_get_constraintdef produces a canonical text rendering.
-    // Skip NOT NULL constraints (`contype = 'n'`): PG17+ catalogs them as
-    // named `pg_constraint` rows while PGlite / older PG don't, and
-    // nullability is already captured per-column by `is_nullable` — including
-    // them would report a pure engine-cataloging artifact as cross-backend
-    // drift between a PGlite and a real-Postgres backend.
+    // Skip NOT NULL constraints (`contype = 'n'`): a named `pg_constraint` row
+    // per NOT NULL column is something an engine may or may not catalog
+    // (PostgreSQL 18, PGlite 0.5 and pglet 0.1 each do), and nullability is
+    // already captured per-column by `is_nullable` — including the rows would
+    // report an engine-cataloging difference as drift between two backends.
     const constraint_rows = await db.query(`SELECT c.conrelid::regclass::text AS table_name,
 		        c.conname,
 		        c.contype::text,

package/dist/testing/transports/ws_transport.d.ts

@@ -17,9 +17,11 @@ export interface WsTransportOptions {
      * Origin header for the upgrade. Backends running with
      * `ALLOWED_ORIGINS=http://localhost:*` accept `http://localhost:<port>`.
      * Defaults to `base_url` — acceptable because cross-process tests
-     * always run against `localhost`.
+     * always run against `localhost`. `null` sends no `Origin` at all, which a
+     * daemon-token upgrade needs: both spines discard a daemon token (and a
+     * bearer token) presented in a browser context.
      */
-    readonly origin?: string;
+    readonly origin?: string | null;
     /**
      * Optional per-call default for `wait_for` timeouts. Falls back to
      * `WS_CLIENT_DEFAULT_TIMEOUT_MS` if omitted.

package/dist/testing/transports/ws_transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ws_transport.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/transports/ws_transport.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAuB9B,OAAO,EAMN,KAAK,QAAQ,EACb,KAAK,kBAAkB,EAEvB,MAAM,gBAAgB,CAAC;AAIxB,sDAAsD;AACtD,MAAM,WAAW,kBAAkB;IAClC,gHAAgH;IAChH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8DAA8D;IAC9D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACxC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,kBAAkB,CAAC;IACzC;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACpD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,mBAAmB,GAAU,SAAS,kBAAkB,KAAG,OAAO,CAAC,QAAQ,CAwJvF,CAAC;AAEF,mFAAmF;AACnF,eAAO,MAAM,qBAAqB,aAAa,CAAC;AAEhD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,4BAA4B,GACxC,SAAS,kBAAkB,KACzB,OAAO,CAAC,QAAQ,CASlB,CAAC"}
+{"version":3,"file":"ws_transport.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/transports/ws_transport.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAuB9B,OAAO,EAMN,KAAK,QAAQ,EACb,KAAK,kBAAkB,EAEvB,MAAM,gBAAgB,CAAC;AAIxB,sDAAsD;AACtD,MAAM,WAAW,kBAAkB;IAClC,gHAAgH;IAChH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8DAA8D;IAC9D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACxC;;;;;;;OAOG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC;;;OAGG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,kBAAkB,CAAC;IACzC;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACpD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,mBAAmB,GAAU,SAAS,kBAAkB,KAAG,OAAO,CAAC,QAAQ,CAyJvF,CAAC;AAEF,mFAAmF;AACnF,eAAO,MAAM,qBAAqB,aAAa,CAAC;AAEhD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,4BAA4B,GACxC,SAAS,kBAAkB,KACzB,OAAO,CAAC,QAAQ,CASlB,CAAC"}

package/dist/testing/transports/ws_transport.js

@@ -50,7 +50,8 @@ export const create_ws_transport = async (options) => {
         headers.Cookie = cookies.join('; ');
     const socket = new WebSocket(ws_url, {
         headers,
-        origin: origin ?? base_url
+        // `ws` sends no `Origin` header when the option is undefined
+        origin: origin === null ? undefined : (origin ?? base_url)
     });
     const received = [];
     const waiters = [];

package/dist/testing/ws_round_trip.d.ts

@@ -48,9 +48,29 @@ import { BackendWebsocketTransport } from '../actions/transports_ws_backend.js';
 import { type RequestContext } from '../auth/request_context.js';
 import { type CredentialType } from '../hono_context.js';
 import { type WsClient, type WsRequestResponder } from './transports/ws_client.js';
+/**
+ * The runtime socket behind a `FakeWs` — what `WSContext.raw` exposes, shaped
+ * like Node's `ws`: a `bufferedAmount` the outbound writer reads for
+ * backpressure, and a `terminate` it cuts a stalled socket with.
+ */
+export interface FakeWsSocket {
+    /**
+     * Bytes "handed to the socket and not yet written". Grows by each sent
+     * frame's UTF-8 length while `stalled`; set it (e.g. to `0`) to model the
+     * client reading.
+     */
+    bufferedAmount: number;
+    /** While `true`, sent frames stay in `bufferedAmount` — a client that is not reading. */
+    stalled: boolean;
+    /** Whether `terminate` was called — the socket was cut with no close frame. */
+    terminated: boolean;
+    /** Cut the socket. Records `terminated` and empties `bufferedAmount`. */
+    terminate: () => void;
+}
 /**
  * A `WSContext` paired with capture arrays. Use `sends` to assert on
- * outgoing frames; use `closes` to assert on revocation / close.
+ * outgoing frames; use `closes` to assert on revocation / close; use
+ * `socket` to model a client that stopped reading and to assert on a cut.
  */
 export interface FakeWs {
     ws: WSContext;
@@ -59,13 +79,23 @@ export interface FakeWs {
         code?: number;
         reason?: string;
     }>;
+    /** The fake runtime socket (`ws.raw`). */
+    socket: FakeWsSocket;
+}
+/** Options for `create_fake_ws`. */
+export interface CreateFakeWsOptions {
+    /** Start with the client not reading (`FakeWsSocket.stalled`). */
+    stalled?: boolean;
 }
 /**
  * Build a real `WSContext` backed by in-memory `send`/`close` capture.
  * Parsing of outgoing frames is left to the caller — `sends` holds the
  * raw strings as the dispatcher wrote them.
+ *
+ * `readyState` reads `1` (open) until the socket is closed (`2`) or
+ * terminated (`3`).
  */
-export declare const create_fake_ws: () => FakeWs;
+export declare const create_fake_ws: (options?: CreateFakeWsOptions) => FakeWs;
 /** Options for `create_fake_hono_context`. */
 export interface FakeHonoContextOptions {
     credential_type: CredentialType;

package/dist/testing/ws_round_trip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ws_round_trip.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/ws_round_trip.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ws_round_trip.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/ws_round_trip.ts"],"names":[],"mappings":"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"}