@fuzdev/fuz_app 0.128.0 → 0.130.0

package/dist/testing/cross_backend/peer_ping_ws.js

@@ -26,10 +26,10 @@ import '../assert_dev_env.js';
  * non-sensitive — see the design doc); the WS upgrade itself still
  * authenticates, so the suite drives it over the keeper's session.
  *
- * Gated on `capabilities.peer_request` — `true` only for the Rust spine
- * (server-initiated requests landed Rust-first canonical); the TS family
- * skips until its server transport's request path lands (deferred twin-impl
- * convergence). Cross-process only: `create_ws_transport` needs a real bound
+ * Gated on `capabilities.peer_request`, which a backend declares once it
+ * mounts `peer/ping` on a WS endpoint and the HTTP RPC endpoint — the TS
+ * spine binaries (`BackendWebsocketTransport.request_connection`) and the
+ * Rust spine both do. Cross-process only: `create_ws_transport` needs a real bound
  * socket, so wire it from a `*.cross.test.ts`.
  *
  * @module

package/dist/testing/cross_backend/role_grant_offer_notification_ws.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_role_grant_offer_notification_ws_tests}. */
+/** Configuration for `describe_role_grant_offer_notification_ws_tests`. */
 export interface RoleGrantOfferNotificationWsTestOptions {
     /** Per-test fixture producer (`default_cross_process_setup(handle, ...)`). */
     readonly setup_test: SetupTest;

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

@@ -1 +1 @@
-{"version":3,"file":"role_grant_offer_notification_ws.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/role_grant_offer_notification_ws.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAqE9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EAAE,SAAS,EAAmC,MAAM,YAAY,CAAC;AAK7E,iFAAiF;AACjF,MAAM,WAAW,uCAAuC;IACvD,8EAA8E;IAC9E,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;CACzB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,+CAA+C,GAC3D,SAAS,uCAAuC,KAC9C,IAuWF,CAAC"}
+{"version":3,"file":"role_grant_offer_notification_ws.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/role_grant_offer_notification_ws.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAqE9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EAAE,SAAS,EAAmC,MAAM,YAAY,CAAC;AAK7E,2EAA2E;AAC3E,MAAM,WAAW,uCAAuC;IACvD,8EAA8E;IAC9E,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;CACzB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,+CAA+C,GAC3D,SAAS,uCAAuC,KAC9C,IAuWF,CAAC"}

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

@@ -327,7 +327,7 @@ export interface BootstrappedBackendHandle extends BackendHandle {
  */
 export type ReconstructedBootstrappedBackendHandle = Omit<BootstrappedBackendHandle, 'child' | 'teardown'>;
 /**
- * Serializable subset of {@link BootstrappedBackendHandle} suitable for
+ * Serializable subset of `BootstrappedBackendHandle` suitable for
  * vitest's `project.provide()` — vitest 4 hard-rejects non-serializable
  * values, so the live `child: ChildProcess` + `teardown: () => Promise<void>`
  * + `keeper_transport: FetchTransport` (closure) must stay in the
@@ -335,8 +335,8 @@ export type ReconstructedBootstrappedBackendHandle = Omit<BootstrappedBackendHan
  * (`config`, `daemon_token`, `keeper_account`, `keeper_actor`,
  * `keeper_cookies`) round-trip through structured clone fine.
  *
- * `globalSetup` calls {@link serialize_bootstrapped_handle} before
- * `project.provide`; test files call {@link reconstruct_bootstrapped_handle}
+ * `globalSetup` calls `serialize_bootstrapped_handle` before
+ * `project.provide`; test files call `reconstruct_bootstrapped_handle`
  * on the injected value to rebuild a usable handle (without `child` /
  * `teardown` — lifecycle stays with `globalSetup`).
  */
@@ -354,7 +354,7 @@ export interface SerializableBootstrappedBackendHandle {
 export declare const serialize_bootstrapped_handle: (handle: BootstrappedBackendHandle) => SerializableBootstrappedBackendHandle;
 /**
  * Rebuild a usable handle from the serialized subset. Synthesizes a
- * fresh {@link FetchTransport} primed with the keeper's `Set-Cookie`
+ * fresh `FetchTransport` primed with the keeper's `Set-Cookie`
  * values so `_testing_reset` and other keeper-authenticated calls work.
  * The returned shape omits `child` and `teardown` — lifecycle stays
  * with `globalSetup`; tests that try to teardown themselves wouldn't

package/dist/testing/cross_backend/setup.js

@@ -67,7 +67,7 @@ export const serialize_bootstrapped_handle = (handle) => ({
 });
 /**
  * Rebuild a usable handle from the serialized subset. Synthesizes a
- * fresh {@link FetchTransport} primed with the keeper's `Set-Cookie`
+ * fresh `FetchTransport` primed with the keeper's `Set-Cookie`
  * values so `_testing_reset` and other keeper-authenticated calls work.
  * The returned shape omits `child` and `teardown` — lifecycle stays
  * with `globalSetup`; tests that try to teardown themselves wouldn't

package/dist/testing/cross_backend/sse_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_sse_tests}. */
+/** Configuration for `describe_cross_process_sse_tests`. */
 export interface CrossProcessSseTestOptions {
     /**
      * Per-test fixture producer (`default_cross_process_setup(handle)`). Each

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

@@ -1 +1 @@
-{"version":3,"file":"sse_round_trip.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/sse_round_trip.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA8E9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAK5C,kEAAkE;AAClE,MAAM,WAAW,0BAA0B;IAC1C;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,wEAAwE;IACxE,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,6DAA6D;IAC7D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvC;AA0BD;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,GAAI,SAAS,0BAA0B,KAAG,IA2PtF,CAAC"}
+{"version":3,"file":"sse_round_trip.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/sse_round_trip.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA8E9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAK5C,4DAA4D;AAC5D,MAAM,WAAW,0BAA0B;IAC1C;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,wEAAwE;IACxE,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,6DAA6D;IAC7D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvC;AA0BD;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,GAAI,SAAS,0BAA0B,KAAG,IA2PtF,CAAC"}

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

@@ -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
@@ -449,6 +448,18 @@ export declare const testing_action_manifest_action_spec: {
     readonly async: true;
     readonly description: string;
 };
+/**
+ * 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 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.
+ *
+ * @param mounted - every other action on the backend's live RPC mount
+ */
 export declare const create_testing_action_manifest_action: (mounted: ReadonlyArray<RpcAction>) => RpcAction;
 /** Options for `create_testing_actions`. */
 export interface CreateTestingActionsOptions {
@@ -460,9 +471,10 @@ export interface CreateTestingActionsOptions {
      */
     readonly session_options: SessionOptions<string>;
     /**
-     * Daemon-token runtime state — the reset action mutates
-     * `state.keeper_account_id` to point at the freshly seeded keeper
-     * after the old row is wiped. Pass the same `DaemonTokenState`
+     * Daemon-token runtime state — the reset action points
+     * `state.keeper_account_id` at the freshly seeded keeper once its
+     * transaction commits (a post-commit effect, so a reset that rolls back
+     * leaves the previous keeper cached). Pass the same `DaemonTokenState`
      * instance the daemon-token middleware reads.
      */
     readonly daemon_token_state: DaemonTokenState;
@@ -496,6 +508,4 @@ export interface CreateTestingActionsOptions {
  * without updating this handler fails CI.
  */
 export declare const create_testing_actions: (deps: AppDeps, options: CreateTestingActionsOptions) => Array<RpcAction>;
-/** Set of auth-namespace tables `_testing_reset` wipes. Mirrored by the coverage test. */
-export declare const testing_reset_wiped_tables: string[];
 //# sourceMappingURL=testing_reset_actions.d.ts.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,EAAc,KAAK,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAKzE,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;AAqCzC;;;;;;;;;;;;;;;;;;;;;;;;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;AAyB/C,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;;;;;OAKG;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,CAsIjB,CAAC;AAEF,0FAA0F;AAC1F,eAAO,MAAM,0BAA0B,UAAmC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

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`.
  */
@@ -385,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)),
@@ -510,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
@@ -549,5 +559,3 @@ export const create_testing_actions = (deps, options) => {
         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":"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"}
+{"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_inbound_dispatch.d.ts

@@ -0,0 +1,20 @@
+import '../assert_dev_env.js';
+import { type BackendCapabilities } from './capabilities.js';
+import type { SetupTest } from './setup.js';
+/** Configuration for `describe_ws_inbound_dispatch_cross_tests`. */
+export interface WsInboundDispatchCrossTestOptions {
+    /** Per-test fixture producer (`default_cross_process_setup(handle)`). */
+    readonly setup_test: SetupTest;
+    /** Backend capability flags; every case gates on `capabilities.peer_request`. */
+    readonly capabilities: BackendCapabilities;
+    /** Base URL the backend is reachable at (e.g. `http://localhost:1177`). */
+    readonly base_url: string;
+    /** WebSocket endpoint path on the backend (e.g. `/api/ws`). */
+    readonly ws_path: string;
+}
+/**
+ * Register the duplicate-id and in-flight-ceiling cases. Gated on
+ * `capabilities.peer_request` (the cases hold requests with `peer/ping`).
+ */
+export declare const describe_ws_inbound_dispatch_cross_tests: (options: WsInboundDispatchCrossTestOptions) => void;
+//# sourceMappingURL=ws_inbound_dispatch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ws_inbound_dispatch.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/ws_inbound_dispatch.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA2C9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAiB5C,oEAAoE;AACpE,MAAM,WAAW,iCAAiC;IACjD,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;CACzB;AAiED;;;GAGG;AACH,eAAO,MAAM,wCAAwC,GACpD,SAAS,iCAAiC,KACxC,IA8GF,CAAC"}