@fuzdev/fuz_app 0.127.0 → 0.129.0

package/dist/testing/cross_backend/testing_reset_actions.js

@@ -2,7 +2,7 @@ import '../assert_dev_env.js';
 /**
  * Test-binary RPC actions for cross-process integration tests.
  *
- * Six daemon-token-authed actions, bundled by `create_testing_actions`:
+ * The daemon-token-authed actions bundled by `create_testing_actions`:
  * **`_testing_reset`** (DB wipe + keeper re-seed), **`_testing_drain_effects`**
  * (audit barrier), **`_testing_mint_session`** (forge an
  * expired-by-construction server-side session for the expiry conformance
@@ -31,11 +31,11 @@ import '../assert_dev_env.js';
  * new keeper + secondary credentials return as the action output so
  * the per-test fixture closes over them.
  *
- * The redesign converges in-process and cross-process keeper
- * lifetimes: both modes now run against a freshly bootstrapped keeper
- * per test. Mutation-cascade tests (password change, revoke-all,
- * hardcoded-username signup uniqueness) and direct keeper-vs-admin
- * probes work uniformly cross-process.
+ * In-process and cross-process keeper lifetimes match: both modes run
+ * against a freshly bootstrapped keeper per test, so mutation-cascade
+ * tests (password change, revoke-all, hardcoded-username signup
+ * uniqueness) and direct keeper-vs-admin probes work uniformly
+ * cross-process.
  *
  * **Keeper ≠ admin.** The `keeper` and `admin` roles are independent.
  * Keeper authorizes daemon-token / bootstrap paths; admin authorizes
@@ -47,9 +47,8 @@ import '../assert_dev_env.js';
  * via `extra_accounts: [{username, roles: [ROLE_KEEPER]}]` so the
  * account is seeded at this same bootstrap-equivalent step.
  *
- * **No free-form runtime bypass.** Earlier drafts considered a separate
- * `_testing_seed_role_grant` action for arbitrary direct grants; that
- * was rejected because a runtime bypass would let tests skip the
+ * **No free-form runtime bypass.** There is no action for arbitrary
+ * direct role grants: a runtime bypass would let tests skip the
  * production consent flow's side-effects (audit emit, WS fan-out) and
  * silently mask bugs in those paths. The bypass that does exist —
  * `extra_accounts` — is framed as bootstrap-time seeding, the same
@@ -73,10 +72,10 @@ 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 { 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';
 import { ROLE_ADMIN, ROLE_KEEPER } from '../../auth/role_schema.js';
-import { auth_integration_truncate_tables } from '../db.js';
 import { query_schema_snapshot, SchemaSnapshot, query_migration_tracker, MigrationTracker } from '../schema_introspect.js';
 import { ActionManifest, build_action_manifest } from './action_manifest.js';
 import { query_create_actor } from '../../auth/account_queries.js';
@@ -86,8 +85,8 @@ import { DEFAULT_TEST_PASSWORD } from '../test_credentials.js';
  * Shared `auth` axis for every `_testing_*` action: keeper-only via the
  * daemon-token credential, no acting actor. This is the entire structural
  * fence on the backdoor surface (these actions run direct DB writes the
- * production wire never exposes), so all five specs reference this one const
- * rather than re-declaring it — a single source of truth the gate test
+ * production wire never exposes), so every `_testing_*` spec references this
+ * one const rather than re-declaring it — a single source of truth the gate test
  * (`testing_actions_auth.test.ts`) pins. Mirrors the Rust `DAEMON_TOKEN_ONLY`
  * / shared `AuthSpec` in `fuz_testing`.
  */
@@ -168,16 +167,21 @@ export const testing_reset_action_spec = {
  * the cross-backend conformance suite uses in place of a poll/sleep before
  * asserting on audit rows.
  *
- * On the TS spine the barrier is **satisfied by construction**: the test
- * binary runs `await_pending_effects: true`, so every **HTTP** mutation's
- * fire-and-forget audit emits are awaited before its response returns — by
- * the time a later drain call runs, prior emits are already durable. A
- * WS-dispatched mutation replies before its effects flush, so on TS this
- * action is not a barrier for WS-originated emits; issue audit-asserting
- * mutations over HTTP. The action still
- * exists so the cross-backend test body calls the same method on every
- * backend; the Rust spine (whose audit writes are detached tokio tasks)
- * does the real await in `AuditEmitter::drain_inflight`.
+ * The handler awaits `AuditEmitter.drain_inflight`, which waits until no
+ * tracked `emit` write is outstanding — so the binary's emitter must be built
+ * with `track_inflight: true`, or the drain resolves at once and is no barrier.
+ * Tracking is what makes it a barrier whatever the transport: an **HTTP**
+ * mutation on a binary running `await_pending_effects: true` has its writes
+ * settled by the time it responds, but a **WS** mutation is answered before
+ * its effects flush (reply-then-close for a self-revocation), so its audit
+ * write can still be in flight when the caller reads the reply. The Rust
+ * spine does the same await in `AuditEmitter::drain_inflight`, over an
+ * emitter built with `new_with_inflight_tracking`.
+ *
+ * Covered: every `emit` that ran before the drain was dispatched, and any
+ * started while it waits. A write that starts after the drain resolves is
+ * not — nor are eager writes outside `emit` (session touch, token usage),
+ * which only the dispatching transport's own flush awaits.
  *
  * `auth` gates on the daemon-token credential, matching `_testing_reset`.
  */
@@ -246,13 +250,18 @@ export const testing_mint_session_action_spec = {
         'signed cookie value (exercises the authoritative server-side DB-row expiry gate).'
 };
 /**
- * Build the standalone `_testing_drain_effects` action. No deps — on TS the
- * barrier is satisfied by `await_pending_effects` (see the spec doc), so the
- * handler just returns `{ok: true}`. Mount it on any test endpoint whose
- * suite asserts on audit rows (the spine binary bundles it via
+ * Build the standalone `_testing_drain_effects` action over `audit` — the
+ * emitter the backend's handlers emit through (`deps.audit`), built with
+ * `track_inflight: true` (see the spec doc). Mount it on any test endpoint
+ * whose suite asserts on audit rows (the spine binary bundles it via
  * `create_testing_actions`; in-process suites mount it directly).
+ *
+ * @param audit - the backend's emitter, whose in-flight writes the action awaits
  */
-export const create_testing_drain_effects_action = () => rpc_action(testing_drain_effects_action_spec, async () => ({ ok: true }));
+export const create_testing_drain_effects_action = (audit) => rpc_action(testing_drain_effects_action_spec, async () => {
+    await audit.drain_inflight();
+    return { ok: true };
+});
 /**
  * `_testing_put_fact` — seed an **embedded** fact (`fact.bytes`) for the
  * cross-process fact-serving suite, which drives over real HTTP and has no
@@ -375,26 +384,31 @@ export const testing_action_manifest_action_spec = {
         '{method, auth, side_effects, rate_limit} manifest for cross-impl method-set + ' +
         'auth-shape parity diffing.'
 };
+/**
+ * The protocol methods (`heartbeat` / `cancel` / `peer/ping`) the
+ * `_testing_action_manifest` dump leaves out, so the cross-impl diff stays
+ * apples-to-apples: the two impls organize them differently (`peer/ping` is
+ * on the TS spine's WS **and** HTTP-RPC endpoints; heartbeat/cancel WS-only;
+ * the Rust stub compiles one shared registry serving both transports), so
+ * including them would be a spurious divergence (see `action_manifest.ts`
+ * §Scope). The exclusion set is the live `protocol_action_specs` bundle —
+ * kept in lockstep with the static `PROTOCOL_ACTION_METHODS` by a drift-guard
+ * test — so this stays off the heavyweight `action_codegen` module the spawned
+ * binary would otherwise pull in.
+ */
+const PROTOCOL_METHODS = new Set(protocol_action_specs.map((spec) => spec.method));
 /**
  * Build the `_testing_action_manifest` action over a backend's full live RPC
  * mount. The handler closes over a manifest computed once at assembly time
- * from every `mounted` spec **plus this action's own spec** — the manifest
- * action is itself a live method, so it must appear in the dump it serves.
- * `mounted` excludes it (it's appended to the mount *after* the rest is
- * assembled, in `build_full_spine_rpc_actions`), so its static spec is folded
- * in here; the Rust mirror folds in its own descriptor the same way.
+ * from every `mounted` spec except the protocol methods (`PROTOCOL_METHODS`)
+ * **plus this action's own spec** — the manifest action is itself a live
+ * method, so it must appear in the dump it serves. `mounted` excludes it
+ * (it's appended to the mount *after* the rest is assembled, in
+ * `build_full_spine_rpc_actions`), so its static spec is folded in here; the
+ * Rust mirror folds in its own descriptor the same way.
  *
- * Protocol actions (`heartbeat` / `cancel` / `peer/ping`) are filtered out of
- * the manifest here so the cross-impl diff stays apples-to-apples: the two
- * impls organize them differently (`peer/ping` is on the TS spine's WS **and**
- * HTTP-RPC endpoints; heartbeat/cancel WS-only; the Rust stub compiles one
- * shared registry serving both transports), so including them would be a
- * spurious divergence (see `action_manifest.ts` §Scope). The exclusion set is
- * the live `protocol_action_specs` bundle — kept in lockstep with the static
- * `PROTOCOL_ACTION_METHODS` by a drift-guard test — so this stays off the
- * heavyweight `action_codegen` module the spawned binary would otherwise pull in.
+ * @param mounted - every other action on the backend's live RPC mount
  */
-const PROTOCOL_METHODS = new Set(protocol_action_specs.map((spec) => spec.method));
 export const create_testing_action_manifest_action = (mounted) => {
     const manifest = build_action_manifest([
         ...mounted.map((action) => action.spec).filter((spec) => !PROTOCOL_METHODS.has(spec.method)),
@@ -405,9 +419,10 @@ export const create_testing_action_manifest_action = (mounted) => {
 /**
  * Build the testing RPC actions for a test binary's registry.
  *
- * Returns `_testing_reset` — the single privileged action test binaries
- * register. The test binary calls this at server-assembly time and
- * registers the result on its dispatcher.
+ * Returns the bundled `_testing_*` actions (module doc). The test binary
+ * calls this at server-assembly time and registers the result on its
+ * dispatcher. `_testing_drain_effects` drains `deps.audit`, so the binary's
+ * `audit_factory` builds the emitter with `track_inflight: true`.
  *
  * The reset action's table-wipe list mirrors
  * `auth_integration_truncate_tables` from `testing/db.ts` — the
@@ -499,9 +514,15 @@ export const create_testing_actions = (deps, options) => {
             // 6. Refresh the daemon-token cache so subsequent daemon-token
             //    requests resolve to the freshly seeded keeper. The
             //    middleware's lazy-refresh path only fires when the cached
-            //    id is null; setting it directly here avoids one round-trip
-            //    of stale-id-then-refresh on the next call.
-            daemon_token_state.keeper_account_id = keeper.account.id;
+            //    id is null, so the reset sets it — after the commit, so a
+            //    reset that rolls back (a throwing `reset_state`, a failed
+            //    COMMIT) leaves the cache on the keeper still in the database
+            //    rather than one that never landed, and the next reset can
+            //    still authenticate.
+            const keeper_account_id = keeper.account.id;
+            emit_after_commit(ctx, () => {
+                daemon_token_state.keeper_account_id = keeper_account_id;
+            });
             // 7. Fire domain-state reset (zzz workspaces/terminals/scratch,
             //    fuz_forge cell/fact/file truncation, or no-op for spine_stub).
             //    Pass the transactional `ctx.db` so DB-domain truncation runs
@@ -533,10 +554,8 @@ export const create_testing_actions = (deps, options) => {
             });
             return { hash };
         }),
-        create_testing_drain_effects_action(),
+        create_testing_drain_effects_action(deps.audit),
         create_testing_schema_snapshot_action(),
         create_testing_migration_tracker_action()
     ];
 };
-/** Set of auth-namespace tables `_testing_reset` wipes. Mirrored by the coverage test. */
-export const testing_reset_wiped_tables = auth_integration_truncate_tables;

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

@@ -1,5 +1,5 @@
 import '../assert_dev_env.js';
 import type { TestingServerAdapter } from './testing_server_core.js';
-/** Build the Bun {@link TestingServerAdapter}. */
+/** Build the Bun `TestingServerAdapter`. */
 export declare const create_bun_testing_adapter: () => TestingServerAdapter;
 //# sourceMappingURL=testing_server_bun.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"testing_server_bun.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_server_bun.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA6B9B,OAAO,KAAK,EAAe,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAelF,kDAAkD;AAClD,eAAO,MAAM,0BAA0B,QAAO,oBA8D5C,CAAC"}
+{"version":3,"file":"testing_server_bun.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_server_bun.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA8B9B,OAAO,KAAK,EAAe,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAyBlF,4CAA4C;AAC5C,eAAO,MAAM,0BAA0B,QAAO,oBAoE7C,CAAC"}

package/dist/testing/cross_backend/testing_server_bun.js

@@ -23,68 +23,84 @@ import '../assert_dev_env.js';
  */
 import process from 'node:process';
 import { getConnInfo, upgradeWebSocket, websocket } from '@hono/bun';
+import { DEFAULT_WS_MAX_MESSAGE_BYTES } from '../../actions/transports.js';
 import { create_node_runtime } from '../../runtime/node.js';
-/** Build the Bun {@link TestingServerAdapter}. */
-export const create_bun_testing_adapter = () => ({
-    runtime_label: 'Bun',
-    runtime: create_node_runtime(),
-    get_connection_ip: (c) => getConnInfo(c).remote.address,
-    // Bun's WS upgrade is module-level and stateless (like Deno) — no
-    // post-serve attach. The `websocket` handler is threaded into `serve`
-    // below, where `Bun.serve` wants it.
-    // TODO: `Bun.serve({websocket: {maxPayloadLength}})` (default 16 MiB) could
-    // carry the endpoint's `max_message_bytes` as a frame cap, like Node's
-    // `maxPayload`; until then the per-message check in `register_ws_endpoint`
-    // closes an oversized message with `WS_CLOSE_MESSAGE_TOO_BIG` (1009).
-    prepare_websocket: () => ({ create_upgrade_websocket: () => upgradeWebSocket }),
-    serve: ({ fetch, port, hostname }) => {
-        const server = Bun.serve({
-            fetch: fetch,
-            port,
-            hostname,
-            // Harmless for HTTP-only binaries — Bun only invokes it for sockets
-            // upgraded via `upgradeWebSocket`.
-            websocket
-        });
-        const handle = {
-            // Bun bug (1.3.14): after a *server-initiated* WebSocket close
-            // (`ServerWebSocket.close()` / `@hono/bun`'s `WSContext.close()`),
-            // `server.stop()` never resolves — Bun doesn't decrement its
-            // active-connection count for a server-closed socket, so the stop
-            // waits forever for a connection it already closed. The trigger is
-            // orthogonal to HTTP load, hono-vs-raw `Bun.serve`, in-vs-cross
-            // process, the force flag (`stop()`/`stop(false)`/`stop(true)` all
-            // hang), and the client runtime — a single server-closed WS is
-            // necessary and sufficient. Client-initiated close or leaving the
-            // socket open both stop cleanly in ~0ms. In this suite the trigger is
-            // any server-initiated WS close — a revocation's (the `ws.cross.test.ts`
-            // close-on-revoke cases), a cap eviction's, an oversized message's —
-            // which is why teardown hangs after those and not under HTTP-only or
-            // client-closed WS traffic.
-            //
-            // So initiate a force-close (`true` drops active connections, no
-            // drain) but DON'T await it: awaiting hangs `start_testing_server`'s
-            // shutdown forever — `built.close()` and `exit(0)` never run, and the
-            // spawning harness blocks on a child that never exits (observed as a
-            // multi-minute hang needing SIGKILL). The force-close still tears the
-            // live sockets down; the `exit(0)` the core fires immediately after
-            // does the real teardown a few ms later. Node/Deno don't need this —
-            // their `shutdown()`/`close()` resolve normally. The `.catch` guards a
-            // future Bun that rejects rather than hangs; if a future Bun resolves
-            // the promise after a server-initiated close, revert to
-            // `await server.stop(true)` to mirror the Node/Deno adapters.
-            shutdown: () => {
-                void Promise.resolve(server.stop(true)).catch(() => { });
-                return Promise.resolve();
-            },
-            native: server
-        };
-        return handle;
-    },
-    pid: process.pid,
-    register_shutdown_signals: (handler) => {
-        process.on('SIGINT', () => void handler());
-        process.on('SIGTERM', () => void handler());
-    },
-    exit: (code) => process.exit(code)
-});
+/**
+ * How far above the endpoint's message limit Bun's own frame cap sits. Bun
+ * drops a socket past `maxPayloadLength` without a close frame (the client sees
+ * 1006), unlike Node's `ws`, which closes with `WS_CLOSE_MESSAGE_TOO_BIG` — so
+ * the cap leaves headroom for the per-message check in `register_ws_endpoint`
+ * to answer a message just over the limit with that code, and still refuses a
+ * grossly oversized one before buffering it toward Bun's 16 MiB default.
+ */
+const BUN_WS_MAX_PAYLOAD_MULTIPLIER = 2;
+/** Build the Bun `TestingServerAdapter`. */
+export const create_bun_testing_adapter = () => {
+    // set by `prepare_websocket`, read by `serve` — the core prepares before it serves
+    let max_message_bytes = DEFAULT_WS_MAX_MESSAGE_BYTES;
+    return {
+        runtime_label: 'Bun',
+        runtime: create_node_runtime(),
+        get_connection_ip: (c) => getConnInfo(c).remote.address,
+        // Bun's WS upgrade is module-level and stateless (like Deno) — no
+        // post-serve attach. The `websocket` handler is threaded into `serve`
+        // below, where `Bun.serve` wants it, carrying the frame cap.
+        prepare_websocket: (options) => {
+            max_message_bytes = options?.max_message_bytes ?? DEFAULT_WS_MAX_MESSAGE_BYTES;
+            return { create_upgrade_websocket: () => upgradeWebSocket };
+        },
+        serve: ({ fetch, port, hostname }) => {
+            const server = Bun.serve({
+                fetch: fetch,
+                port,
+                hostname,
+                // Harmless for HTTP-only binaries — Bun only invokes it for sockets
+                // upgraded via `upgradeWebSocket`.
+                websocket: {
+                    ...websocket,
+                    maxPayloadLength: BUN_WS_MAX_PAYLOAD_MULTIPLIER * max_message_bytes
+                }
+            });
+            const handle = {
+                // Bun bug (1.3.14): after a *server-initiated* WebSocket close
+                // (`ServerWebSocket.close()` / `@hono/bun`'s `WSContext.close()`),
+                // `server.stop()` never resolves — Bun doesn't decrement its
+                // active-connection count for a server-closed socket, so the stop
+                // waits forever for a connection it already closed. The trigger is
+                // orthogonal to HTTP load, hono-vs-raw `Bun.serve`, in-vs-cross
+                // process, the force flag (`stop()`/`stop(false)`/`stop(true)` all
+                // hang), and the client runtime — a single server-closed WS is
+                // necessary and sufficient. Client-initiated close or leaving the
+                // socket open both stop cleanly in ~0ms. In this suite the trigger is
+                // any server-initiated WS close — a revocation's (the `ws.cross.test.ts`
+                // close-on-revoke cases), a cap eviction's, an oversized message's —
+                // which is why teardown hangs after those and not under HTTP-only or
+                // client-closed WS traffic.
+                //
+                // So initiate a force-close (`true` drops active connections, no
+                // drain) but DON'T await it: awaiting hangs `start_testing_server`'s
+                // shutdown forever — `built.close()` and `exit(0)` never run, and the
+                // spawning harness blocks on a child that never exits (observed as a
+                // multi-minute hang needing SIGKILL). The force-close still tears the
+                // live sockets down; the `exit(0)` the core fires immediately after
+                // does the real teardown a few ms later. Node/Deno don't need this —
+                // their `shutdown()`/`close()` resolve normally. The `.catch` guards a
+                // future Bun that rejects rather than hangs; if a future Bun resolves
+                // the promise after a server-initiated close, revert to
+                // `await server.stop(true)` to mirror the Node/Deno adapters.
+                shutdown: () => {
+                    void Promise.resolve(server.stop(true)).catch(() => { });
+                    return Promise.resolve();
+                },
+                native: server
+            };
+            return handle;
+        },
+        pid: process.pid,
+        register_shutdown_signals: (handler) => {
+            process.on('SIGINT', () => void handler());
+            process.on('SIGTERM', () => void handler());
+        },
+        exit: (code) => process.exit(code)
+    };
+};

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

@@ -56,10 +56,16 @@ export interface PrepareWebsocketOptions {
      * `WsEndpointSpec.max_message_bytes` of the mounted endpoints; a smaller
      * value refuses messages the endpoint would accept. Node's `ws` server takes
      * it as its frame cap (`maxPayload`), so an oversized message is refused
-     * before it is buffered whole; Deno and Bun ignore it, leaving the
-     * per-message check `register_ws_endpoint` makes (both close with
-     * `WS_CLOSE_MESSAGE_TOO_BIG`). The default sits far below `ws`'s own
-     * 100 MiB, so a build raising an endpoint's cap must pass it here too.
+     * before it is buffered whole. Bun takes twice it as its frame cap
+     * (`maxPayloadLength`): past its cap Bun drops the socket without a close
+     * frame, so the headroom leaves a message just over the limit to the
+     * per-message check `register_ws_endpoint` makes, while a grossly oversized
+     * one is still refused before it is buffered whole. Deno ignores it — its
+     * upgrade takes no frame cap — leaving that per-message check alone. Every
+     * runtime closes a message just over the limit with
+     * `WS_CLOSE_MESSAGE_TOO_BIG`. The default sits far below `ws`'s own 100 MiB
+     * and Bun's 16 MiB, so a build raising an endpoint's cap must pass it here
+     * too.
      *
      * @default DEFAULT_WS_MAX_MESSAGE_BYTES
      */

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

@@ -1 +1 @@
-{"version":3,"file":"testing_server_core.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_server_core.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,EAAU,KAAK,MAAM,IAAI,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAG5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC3B,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,iFAAiF;IACjF,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,4DAA4D;AAC5D,MAAM,WAAW,uBAAuB;IACvC;;;;;;;;;;;OAWG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,iBAAiB;IACjC,wBAAwB,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,gBAAgB,CAAC;IAC1D,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAC;CACjD;AAED;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACpC,6EAA6E;IAC7E,aAAa,EAAE,MAAM,CAAC;IACtB,0FAA0F;IAC1F,OAAO,EAAE,WAAW,CAAC;IACrB,6DAA6D;IAC7D,iBAAiB,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,MAAM,GAAG,SAAS,CAAC;IACtD,8EAA8E;IAC9E,iBAAiB,EAAE,CAAC,OAAO,CAAC,EAAE,uBAAuB,KAAK,iBAAiB,CAAC;IAC5E,wEAAwE;IACxE,KAAK,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,KAAK,WAAW,CAAC;IAC1F,+CAA+C;IAC/C,GAAG,EAAE,MAAM,CAAC;IACZ,yEAAyE;IACzE,yBAAyB,EAAE,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC;IAClE,oEAAoE;IACpE,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,KAAK,CAAC;CAC9B;AAED,wEAAwE;AACxE,MAAM,WAAW,sBAAsB;IACtC;;;;;;;;OAQG;IACH,iBAAiB,EAAE,CAAC,OAAO,CAAC,EAAE,uBAAuB,KAAK,CAAC,GAAG,EAAE,IAAI,KAAK,gBAAgB,CAAC;CAC1F;AAED,8EAA8E;AAC9E,MAAM,WAAW,eAAe;IAC/B,mFAAmF;IACnF,GAAG,EAAE,IAAI,CAAC;IACV;;;;OAIG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAED,0CAA0C;AAC1C,MAAM,WAAW,yBAAyB;IACzC,+CAA+C;IAC/C,OAAO,EAAE,oBAAoB,CAAC;IAC9B;;;;;;OAMG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,iBAAiB;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,SAAS,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IACzE,0EAA0E;IAC1E,GAAG,CAAC,EAAE,UAAU,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,KAAG,OAG/C,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,GAAU,SAAS,yBAAyB,KAAG,OAAO,CAAC,IAAI,CAkE3F,CAAC"}
+{"version":3,"file":"testing_server_core.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_server_core.ts"],"names":[],"mappings":"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"}

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

@@ -1,5 +1,5 @@
 import '../assert_dev_env.js';
 import type { TestingServerAdapter } from './testing_server_core.js';
-/** Build the Deno {@link TestingServerAdapter}. */
+/** Build the Deno `TestingServerAdapter`. */
 export declare const create_deno_testing_adapter: () => TestingServerAdapter;
 //# sourceMappingURL=testing_server_deno.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"testing_server_deno.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_server_deno.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAsB9B,OAAO,KAAK,EAAe,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAelF,mDAAmD;AACnD,eAAO,MAAM,2BAA2B,QAAO,oBAkB7C,CAAC"}
+{"version":3,"file":"testing_server_deno.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_server_deno.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAsB9B,OAAO,KAAK,EAAe,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAelF,6CAA6C;AAC7C,eAAO,MAAM,2BAA2B,QAAO,oBAkB7C,CAAC"}

package/dist/testing/cross_backend/testing_server_deno.js

@@ -17,7 +17,7 @@ import '../assert_dev_env.js';
  */
 import { upgradeWebSocket } from '@hono/deno';
 import { create_deno_runtime } from '../../runtime/deno.js';
-/** Build the Deno {@link TestingServerAdapter}. */
+/** Build the Deno `TestingServerAdapter`. */
 export const create_deno_testing_adapter = () => ({
     runtime_label: 'Deno',
     runtime: create_deno_runtime([]),

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

@@ -1,5 +1,5 @@
 import '../assert_dev_env.js';
 import type { TestingServerAdapter } from './testing_server_core.js';
-/** Build the Node {@link TestingServerAdapter}. */
+/** Build the Node `TestingServerAdapter`. */
 export declare const create_node_testing_adapter: () => TestingServerAdapter;
 //# sourceMappingURL=testing_server_node.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"testing_server_node.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_server_node.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA2B9B,OAAO,KAAK,EAAe,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAUlF,mDAAmD;AACnD,eAAO,MAAM,2BAA2B,QAAO,oBA+B7C,CAAC"}
+{"version":3,"file":"testing_server_node.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_server_node.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA2B9B,OAAO,KAAK,EAAe,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAUlF,6CAA6C;AAC7C,eAAO,MAAM,2BAA2B,QAAO,oBA+B7C,CAAC"}

package/dist/testing/cross_backend/testing_server_node.js

@@ -28,7 +28,7 @@ const node_serve_handle = (server) => ({
     }),
     native: server
 });
-/** Build the Node {@link TestingServerAdapter}. */
+/** Build the Node `TestingServerAdapter`. */
 export const create_node_testing_adapter = () => ({
     runtime_label: 'Node',
     runtime: create_node_runtime(),
@@ -48,7 +48,7 @@ export const create_node_testing_adapter = () => ({
             },
             attach_to_server: (handle) => {
                 // `handle.native` is the `ServerType` from `serve()` —
-                // type-erased at the {@link ServeHandle} seam, so it downcasts here.
+                // type-erased at the `ServeHandle` seam, so it downcasts here.
                 node_ws?.injectWebSocket(handle.native);
             }
         };

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

@@ -1,7 +1,7 @@
 import '../assert_dev_env.js';
 import { type BackendCapabilities } from './capabilities.js';
 import type { SetupTest } from './setup.js';
-/** Configuration for {@link describe_cross_process_ws_tests}. */
+/** Configuration for `describe_cross_process_ws_tests`. */
 export interface CrossProcessWsTestOptions {
     /**
      * Per-test fixture producer (`default_cross_process_setup(handle)`).
@@ -38,7 +38,8 @@ export interface CrossProcessWsTestOptions {
  * oversized message closing with `WS_CLOSE_MESSAGE_TOO_BIG`, anonymous-upgrade
  * refusal, disallowed-origin refusal, and — when `rpc_path` is supplied —
  * session revocation and account deletion closing the live socket, plus a
- * self-revoking socket reading its reply before its close.
+ * self-revoking socket reading its reply before its close, and a WS mutation's
+ * audit row read back after `_testing_drain_effects`.
  */
 export declare const describe_cross_process_ws_tests: (options: CrossProcessWsTestOptions) => void;
 //# sourceMappingURL=ws_round_trip.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ws_round_trip.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/ws_round_trip.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA6F9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAK5C,iEAAiE;AACjE,MAAM,WAAW,yBAAyB;IACzC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,uEAAuE;IACvE,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,oEAAoE;IACpE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B,GAAI,SAAS,yBAAyB,KAAG,IA+RpF,CAAC"}
+{"version":3,"file":"ws_round_trip.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/ws_round_trip.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA0G9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AAEtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAK5C,2DAA2D;AAC3D,MAAM,WAAW,yBAAyB;IACzC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,uEAAuE;IACvE,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,oEAAoE;IACpE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,+BAA+B,GAAI,SAAS,yBAAyB,KAAG,IAkVpF,CAAC"}