@fuzdev/fuz_app 0.146.1 → 0.148.0

package/dist/testing/cross_backend/ws_endpoint.js

@@ -0,0 +1,54 @@
+import '../assert_dev_env.js';
+/**
+ * Where a spawned backend's WebSocket endpoint is, and how the cross suites
+ * open a socket on it as one account's session.
+ *
+ * The socket-driving cross suites take `WsEndpointTarget` as their endpoint
+ * options (flat, or nested as `ws` on a suite whose socket cases are
+ * optional), and open a socket on a fixture account's session through
+ * `open_session_ws`, so the cookie read, the missing-cookie assertion and the
+ * transport choice are written once. Sockets on another credential — a daemon
+ * token, a bearer, a session a case logged in on its own transport — and the
+ * raw-socket cases open their own way.
+ *
+ * @module
+ */
+import { assert } from 'vitest';
+import { create_admitted_ws_transport, create_ws_transport } from '../transports/ws_transport.js';
+/**
+ * The account's session cookie (`<name>=<value>`), asserted present.
+ *
+ * @param account - the account whose session headers carry the cookie
+ * @returns the `Cookie` header value
+ */
+export const to_session_cookie = (account) => {
+    const { cookie } = account.create_session_headers();
+    assert.ok(cookie, 'expected a session cookie for the WS upgrade');
+    return cookie;
+};
+/**
+ * Open a real-upgrade socket on `target` as `account`'s session: its session
+ * cookie on the upgrade, `target.origin` (or `base_url`) as the `Origin`.
+ *
+ * The cookie is the static one `account.create_session_headers` carries, not
+ * whatever `fixture.transport`'s jar holds now, so a case that rotates the
+ * session through `fixture.transport` first upgrades on the stale cookie.
+ *
+ * @param target - the backend's WebSocket endpoint
+ * @param account - the account whose session the socket upgrades on
+ * @param options - whether to wait for admission, plus transport extras
+ * @returns the open socket
+ * @throws Error if the account carries no session cookie, or the upgrade (or
+ *   the admission heartbeat) fails
+ */
+export const open_session_ws = (target, account, options) => {
+    const { admitted, ...transport_options } = options;
+    const open = admitted ? create_admitted_ws_transport : create_ws_transport;
+    return open({
+        base_url: target.base_url,
+        ws_path: target.ws_path,
+        cookies: [to_session_cookie(account)],
+        origin: target.origin ?? target.base_url,
+        ...transport_options
+    });
+};

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

@@ -1,16 +1,13 @@
 import '../assert_dev_env.js';
 import { type BackendCapabilities } from './capabilities.js';
 import type { SetupTest } from './setup.js';
+import { type WsEndpointTarget } from './ws_endpoint.js';
 /** Configuration for `describe_ws_inbound_dispatch_cross_tests`. */
-export interface WsInboundDispatchCrossTestOptions {
+export interface WsInboundDispatchCrossTestOptions extends WsEndpointTarget {
     /** 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

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

@@ -1 +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"}
+{"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;AA0C9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,YAAY,CAAC;AACzD,OAAO,EAAmB,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAiB1E,oEAAoE;AACpE,MAAM,WAAW,iCAAkC,SAAQ,gBAAgB;IAC1E,yEAAyE;IACzE,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,iFAAiF;IACjF,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;CAC3C;AAiED;;;GAGG;AACH,eAAO,MAAM,wCAAwC,GACpD,SAAS,iCAAiC,KACxC,IAsGF,CAAC"}

package/dist/testing/cross_backend/ws_inbound_dispatch.js

@@ -30,9 +30,9 @@ import '../assert_dev_env.js';
  */
 import { assert, describe } from 'vitest';
 import { create_jsonrpc_request } from '../../http/jsonrpc_helpers.js';
-import { create_ws_transport } from '../transports/ws_transport.js';
 import { is_response_for } from '../transports/ws_client.js';
 import { test_if } from './capabilities.js';
+import { open_session_ws } from './ws_endpoint.js';
 /** `data.reason` of the duplicate-id refusal. */
 const REASON_DUPLICATE_REQUEST_ID = 'duplicate_request_id';
 /** The per-socket in-flight ceiling on both spines. */
@@ -92,18 +92,12 @@ const is_error_for = (id) => (msg) => is_response_for(id)(msg) && 'error' in msg
  * `capabilities.peer_request` (the cases hold requests with `peer/ping`).
  */
 export const describe_ws_inbound_dispatch_cross_tests = (options) => {
-    const { setup_test, capabilities, base_url, ws_path } = options;
-    const open_ws = (cookie, on_request) => {
-        assert.ok(cookie, 'expected a session cookie for the WS upgrade');
-        return create_ws_transport({
-            base_url,
-            ws_path,
-            cookies: [cookie],
-            origin: base_url,
-            on_request,
-            default_timeout_ms: FRAME_TIMEOUT_MS
-        });
-    };
+    const { setup_test, capabilities } = options;
+    const open_ws = (fixture, on_request) => open_session_ws(options, fixture, {
+        admitted: false,
+        on_request,
+        default_timeout_ms: FRAME_TIMEOUT_MS
+    });
     const send_ping = (ws, id, nonce) => ws.send(create_jsonrpc_request(PEER_PING_METHOD, { nonce }, id));
     const send_heartbeat = (ws, id) => ws.send(create_jsonrpc_request(HEARTBEAT_METHOD, undefined, id));
     const assert_duplicate_refusal = (frame, id) => {
@@ -117,7 +111,7 @@ export const describe_ws_inbound_dispatch_cross_tests = (options) => {
         test_if(capabilities.peer_request, 'a request reusing a live id is refused with that id; the first keeps it, then the id frees', async () => {
             const fixture = await setup_test();
             const { responder, release, pinged } = create_holding_responder();
-            const ws = await open_ws(fixture.create_session_headers().cookie, responder);
+            const ws = await open_ws(fixture, responder);
             try {
                 const id = 'held';
                 await send_ping(ws, id, 41);
@@ -147,7 +141,7 @@ export const describe_ws_inbound_dispatch_cross_tests = (options) => {
         test_if(capabilities.peer_request, 'past the in-flight ceiling a request is shed with queue_overflow and the socket keeps serving', async () => {
             const fixture = await setup_test();
             const { responder, release } = create_holding_responder();
-            const ws = await open_ws(fixture.create_session_headers().cookie, responder);
+            const ws = await open_ws(fixture, responder);
             try {
                 for (let n = 0; n < MAX_INBOUND_DISPATCHES; n++) {
                     await send_ping(ws, n, n);

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

@@ -1,18 +1,13 @@
 import '../assert_dev_env.js';
 import { type BackendCapabilities } from './capabilities.js';
 import type { SetupTest } from './setup.js';
+import { type WsEndpointTarget } from './ws_endpoint.js';
 /** Options for the outbound-overflow parity suite. */
-export interface WsOutboundOverflowCrossTestOptions {
+export interface WsOutboundOverflowCrossTestOptions extends WsEndpointTarget {
     /** 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.

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

@@ -1 +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;AAwE9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AAEtE,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,YAAY,CAAC;AAoFzD,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,IA0NF,CAAC"}
+{"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;AAwE9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AAEtE,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,YAAY,CAAC;AACzD,OAAO,EAAmB,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAoF1E,sDAAsD;AACtD,MAAM,WAAW,kCAAmC,SAAQ,gBAAgB;IAC3E,yEAAyE;IACzE,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,iFAAiF;IACjF,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;GAKG;AACH,eAAO,MAAM,yCAAyC,GACrD,SAAS,kCAAkC,KACzC,IAqNF,CAAC"}

package/dist/testing/cross_backend/ws_outbound_overflow.js

@@ -62,7 +62,8 @@ 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';
+import { cross_rpc_call } from './cross_rpc.js';
+import { open_session_ws } from './ws_endpoint.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. */
@@ -139,7 +140,7 @@ const CLOSE_TIMEOUT_MS = 15_000;
  * connection is unaffected.
  */
 export const describe_ws_outbound_overflow_cross_tests = (options) => {
-    const { setup_test, capabilities, base_url, ws_path, origin, rpc_path } = options;
+    const { setup_test, capabilities, base_url, ws_path, 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,
@@ -156,7 +157,7 @@ export const describe_ws_outbound_overflow_cross_tests = (options) => {
         assert.deepStrictEqual(await client.request(id, HEARTBEAT_METHOD, {}), {}, message);
         assert.strictEqual(client.close_code, null, message);
     };
-    describe('websocket outbound overflow parity', { timeout: 30_000 }, () => {
+    describe('websocket outbound overflow parity', () => {
         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);
@@ -206,12 +207,7 @@ export const describe_ws_outbound_overflow_cross_tests = (options) => {
         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 bystander = await open_session_ws(options, fixture, { admitted: true });
             const client = await open_flooder(fixture);
             try {
                 await client.send(create_jsonrpc_request(FLOOD_METHOD, OVERFLOWS, 'overflows'));

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

@@ -1,16 +1,15 @@
 import '../assert_dev_env.js';
 import { type BackendCapabilities } from './capabilities.js';
 import type { SetupTest } from './setup.js';
+import { type WsEndpointTarget } from './ws_endpoint.js';
 /** Configuration for `describe_ws_role_gated_cross_tests`. */
-export interface WsRoleGatedCrossTestOptions {
+export interface WsRoleGatedCrossTestOptions extends WsEndpointTarget {
+    /** The ungated WebSocket endpoint path (e.g. `/api/ws`). */
+    readonly ws_path: string;
     /** Per-test fixture producer (`default_cross_process_setup(handle)`). */
     readonly setup_test: SetupTest;
     /** Backend capability flags; every case gates on `ws` and `ws_role_gated`. */
     readonly capabilities: BackendCapabilities;
-    /** Base URL the backend is reachable at. */
-    readonly base_url: string;
-    /** The ungated WebSocket endpoint path (e.g. `/api/ws`). */
-    readonly ws_path: string;
     /** The role-gated WebSocket endpoint path. */
     readonly gated_ws_path: string;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"ws_role_gated.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/ws_role_gated.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAwC9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AAKtE,OAAO,KAAK,EAAE,SAAS,EAAmC,MAAM,YAAY,CAAC;AAM7E,8DAA8D;AAC9D,MAAM,WAAW,2BAA2B;IAC3C,yEAAyE;IACzE,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,4CAA4C;IAC5C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,4DAA4D;IAC5D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,8CAA8C;IAC9C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5C,2EAA2E;IAC3E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kCAAkC,GAAI,SAAS,2BAA2B,KAAG,IA2IzF,CAAC"}
+{"version":3,"file":"ws_role_gated.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/ws_role_gated.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAuC9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AAMtE,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,YAAY,CAAC;AAEzD,OAAO,EAAmB,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAK1E,8DAA8D;AAC9D,MAAM,WAAW,2BAA4B,SAAQ,gBAAgB;IACpE,4DAA4D;IAC5D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,yEAAyE;IACzE,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,8CAA8C;IAC9C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5C,2EAA2E;IAC3E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kCAAkC,GAAI,SAAS,2BAA2B,KAAG,IA+HzF,CAAC"}

package/dist/testing/cross_backend/ws_role_gated.js

@@ -31,10 +31,10 @@ import { ROLE_ADMIN } from '../../auth/role_schema.js';
 import { ROLE_GRANT_OFFER_RECEIVED_NOTIFICATION_METHOD } from '../../auth/role_grant_offer_notifications.js';
 import { rpc_call } from '../rpc_helpers.js';
 import { is_notification_with } from '../transports/ws_client.js';
-import { create_admitted_ws_transport, create_ws_transport } from '../transports/ws_transport.js';
 import { test_if } from './capabilities.js';
 import { create_active_role_grant, create_pending_role_grant_offer } from './role_grant_cross_helpers.js';
 import { SPINE_RPC_PATH } from './spine_surface_constants.js';
+import { open_session_ws } from './ws_endpoint.js';
 /** How long a socket that must stay open is watched for a close it must not get. */
 const STAYS_OPEN_MS = 1500;
 /**
@@ -49,30 +49,26 @@ const STAYS_OPEN_MS = 1500;
  * it: each spine's own transport tests pin it.
  */
 export const describe_ws_role_gated_cross_tests = (options) => {
-    const { setup_test, capabilities, base_url, ws_path, gated_ws_path, gated_roles, scoped_role, rpc_path = SPINE_RPC_PATH } = options;
+    const { setup_test, capabilities, gated_ws_path, gated_roles, scoped_role, rpc_path = SPINE_RPC_PATH } = options;
     const enabled = capabilities.ws && capabilities.ws_role_gated;
     if (enabled && (!gated_roles.includes(ROLE_ADMIN) || !gated_roles.includes(scoped_role))) {
         throw new Error(`describe_ws_role_gated_cross_tests: gated_roles must include ${ROLE_ADMIN} and ${scoped_role}`);
     }
     const rpc = (fixture, method, params, headers = fixture.create_session_headers()) => rpc_call({ app: fixture.transport, path: rpc_path, method, params, headers });
-    const cookie_of = (account) => {
-        const { cookie } = account.create_session_headers();
-        assert.ok(cookie, 'expected a session cookie for the WS upgrade');
-        return cookie;
+    /** The role-gated endpoint, on the ungated one's backend and origin. */
+    const gated_target = {
+        base_url: options.base_url,
+        ws_path: gated_ws_path,
+        ...(options.origin !== undefined && { origin: options.origin })
     };
-    const open = (path, account) => create_admitted_ws_transport({
-        base_url,
-        ws_path: path,
-        cookies: [cookie_of(account)],
-        origin: base_url
-    });
+    const open = (target, account) => open_session_ws(target, account, { admitted: true });
     describe('role-gated websocket (cross-process)', () => {
         test_if(enabled, 'revoking a global grant of a gating role closes the gated socket with WS_CLOSE_PERMISSION_REVOKED', async () => {
             const fixture = await setup_test();
             const target = await fixture.create_account({ roles: [ROLE_ADMIN] });
             const role_grant_id = await create_active_role_grant(fixture, target, { rpc_path });
-            const gated = await open(gated_ws_path, target);
-            const ungated = await open(ws_path, target);
+            const gated = await open(gated_target, target);
+            const ungated = await open(options, target);
             try {
                 const revoked = await rpc(fixture, 'role_grant_revoke', {
                     actor_id: target.actor.id,
@@ -92,12 +88,7 @@ export const describe_ws_role_gated_cross_tests = (options) => {
                 assert.strictEqual(ungated.close_code, null);
                 assert.deepStrictEqual(await ungated.request(2, heartbeat_action_spec.method, {}), {});
                 // and the gate refuses the account a new gated socket
-                await assert_rejects(() => create_ws_transport({
-                    base_url,
-                    ws_path: gated_ws_path,
-                    cookies: [cookie_of(target)],
-                    origin: base_url
-                }), /403/);
+                await assert_rejects(() => open_session_ws(gated_target, target, { admitted: false }), /403/);
             }
             finally {
                 await gated.close();
@@ -124,7 +115,7 @@ export const describe_ws_role_gated_cross_tests = (options) => {
                 scope_kind: 'space',
                 scope_id: '33333333-3333-4333-8333-333333333333'
             });
-            const gated = await open(gated_ws_path, target);
+            const gated = await open(gated_target, target);
             try {
                 const revoked = await rpc(fixture, 'role_grant_revoke', {
                     actor_id: target.actor.id,

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

@@ -1,22 +1,17 @@
 import '../assert_dev_env.js';
 import { type BackendCapabilities } from './capabilities.js';
 import type { SetupTest } from './setup.js';
+import { type WsEndpointTarget } from './ws_endpoint.js';
 /** Configuration for `describe_cross_process_ws_tests`. */
-export interface CrossProcessWsTestOptions {
+export interface CrossProcessWsTestOptions extends WsEndpointTarget {
     /**
      * Per-test fixture producer (`default_cross_process_setup(handle)`).
-     * The authenticated case reads the fresh-per-test keeper's session
-     * cookies from `fixture.transport.cookies()` to thread onto the upgrade.
+     * The authenticated cases upgrade on the fresh-per-test keeper's session
+     * cookie (`open_session_ws`).
      */
     readonly setup_test: SetupTest;
     /** Backend capability flags; every 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 authenticated upgrade. Defaults to `base_url`. */
-    readonly origin?: string;
     /**
      * RPC endpoint path (e.g. `/api/rpc`) used by the close-on-revoke case to
      * fire `account_session_revoke_all` over the keeper's session channel.
@@ -41,6 +36,14 @@ export interface CrossProcessWsTestOptions {
      * cap disabled) skips the case.
      */
     readonly max_tokens?: number | null;
+    /**
+     * Roles each second account whose socket a revocation case watches is created
+     * with, for a
+     * backend whose WS upgrade requires a role (an admin-gated `/api/ws`
+     * refuses a roleless account's upgrade). Each must be admin-grantable — the
+     * fixture offers it. Default none.
+     */
+    readonly ws_account_roles?: ReadonlyArray<string>;
 }
 /**
  * Register the cross-process WS round-trip suite over a real upgrade: authed

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;AAyH9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AAGtE,OAAO,KAAK,EAAE,SAAS,EAAmC,MAAM,YAAY,CAAC;AAK7E,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;IACpC,wFAAwF;IACxF,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,4FAA4F;IAC5F,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,+BAA+B,GAAI,SAAS,yBAAyB,KAAG,IA4epF,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;AAsH9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AAItE,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,YAAY,CAAC;AAKzD,OAAO,EAAmB,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAK1E,2DAA2D;AAC3D,MAAM,WAAW,yBAA0B,SAAQ,gBAAgB;IAClE;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,uEAAuE;IACvE,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,wFAAwF;IACxF,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,4FAA4F;IAC5F,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC;;;;;;OAMG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAClD;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,+BAA+B,GAAI,SAAS,yBAAyB,KAAG,IAsdpF,CAAC"}

package/dist/testing/cross_backend/ws_round_trip.js

@@ -85,16 +85,19 @@ import { heartbeat_action_spec } from '../../actions/heartbeat.js';
 import { DEFAULT_WS_MAX_MESSAGE_BYTES, WS_CLOSE_MESSAGE_TOO_BIG, WS_CLOSE_SESSION_REVOKED, WS_CLOSE_SESSION_REVOKED_REASON } from '../../actions/transports.js';
 import { account_session_revoke_all_action_spec, account_token_create_action_spec, account_token_revoke_action_spec, TokenCreateOutput, TokenRevokeOutput } from '../../auth/account_action_specs.js';
 import { DEFAULT_MAX_TOKENS } from '../../auth/account_route_schema.js';
-import { account_delete_action_spec, audit_log_list_action_spec, AuditLogListOutput } from '../../auth/admin_action_specs.js';
+import { account_delete_action_spec } from '../../auth/admin_action_specs.js';
 import { JSONRPC_ERROR_CODES } from '../../http/jsonrpc_errors.js';
 import { is_response_for } from '../transports/ws_client.js';
 import { create_admitted_ws_transport, create_ws_transport } from '../transports/ws_transport.js';
 import { connect_raw_ws, is_raw_ws_close, RAW_WS_OPCODE_TEXT } from '../transports/ws_raw_client.js';
 import { create_rpc_post_init } from '../rpc_helpers.js';
 import { DEFAULT_TEST_PASSWORD } from '../test_credentials.js';
+import { list_audit_events } from './audit_cross_helpers.js';
 import { test_if } from './capabilities.js';
-import { cross_rpc_call, expect_output } from './cell_cross_helpers.js';
+import { cross_rpc_call, expect_output } from './cross_rpc.js';
 import { create_account_revocations } from './revocation_drivers.js';
+import { SPINE_ACCOUNT_LOGOUT_PATH, SPINE_ACCOUNT_PASSWORD_PATH } from './spine_surface_constants.js';
+import { open_session_ws } from './ws_endpoint.js';
 /** Origin guaranteed to fail the `http://localhost:*` allowlist the test backends run with. */
 const DISALLOWED_ORIGIN = 'http://disallowed.example';
 /**
@@ -109,11 +112,11 @@ const DISALLOWED_ORIGIN = 'http://disallowed.example';
  * audit row read back after `_testing_drain_effects`.
  */
 export const describe_cross_process_ws_tests = (options) => {
-    const { setup_test, capabilities, base_url, ws_path, origin, rpc_path, max_message_bytes = DEFAULT_WS_MAX_MESSAGE_BYTES, logout_path = '/api/account/logout', password_path = '/api/account/password' } = options;
+    const { setup_test, capabilities, base_url, ws_path, origin, rpc_path, max_message_bytes = DEFAULT_WS_MAX_MESSAGE_BYTES, logout_path = SPINE_ACCOUNT_LOGOUT_PATH, password_path = SPINE_ACCOUNT_PASSWORD_PATH, ws_account_roles = [] } = options;
     const max_tokens = options.max_tokens === undefined ? DEFAULT_MAX_TOKENS : options.max_tokens;
     const open_authed = async () => {
         const fixture = await setup_test();
-        return create_ws_transport({ base_url, ws_path, cookies: fixture.transport.cookies(), origin });
+        return open_session_ws(options, fixture, { admitted: false });
     };
     describe('cross-process websocket', () => {
         test_if(capabilities.ws, 'authenticated upgrade round-trips heartbeat', async () => {
@@ -260,11 +263,7 @@ export const describe_cross_process_ws_tests = (options) => {
             origin: null,
             headers: { Authorization: `Bearer ${token}` }
         });
-        const open_session = (account) => {
-            const { cookie } = account.create_session_headers();
-            assert.ok(cookie, 'expected a session cookie');
-            return create_admitted_ws_transport({ base_url, ws_path, cookies: [cookie], origin });
-        };
+        const open_session = (account) => open_session_ws(options, account, { admitted: true });
         /**
          * Open each socket in turn, run `fn` over them, and close every socket
          * that opened — also when a later open fails, so a refused upgrade leaves
@@ -299,12 +298,7 @@ export const describe_cross_process_ws_tests = (options) => {
         // account actions on the RPC endpoint).
         test_if(capabilities.ws && rpc_path !== undefined, 'session revocation closes the live socket', async () => {
             const fixture = await setup_test();
-            const client = await create_ws_transport({
-                base_url,
-                ws_path,
-                cookies: fixture.transport.cookies(),
-                origin
-            });
+            const client = await open_session_ws(options, fixture, { admitted: false });
             try {
                 // Confirm the socket dispatches before revoking, so a failed
                 // close assertion can't be confused with a dead connection.
@@ -323,10 +317,11 @@ export const describe_cross_process_ws_tests = (options) => {
         // committed. The keeper deletes a second account whose socket is open.
         test_if(capabilities.ws && capabilities.account_lifecycle && rpc_path !== undefined, 'an account delete closes the live socket of the deleted account', async () => {
             const fixture = await setup_test();
-            const target = await fixture.create_account({ username: 'ws_delete_target', roles: [] });
-            const cookie = target.create_session_headers().cookie;
-            assert.ok(cookie, 'expected a session cookie for the target account');
-            const client = await create_ws_transport({ base_url, ws_path, cookies: [cookie], origin });
+            const target = await fixture.create_account({
+                username: 'ws_delete_target',
+                roles: [...ws_account_roles]
+            });
+            const client = await open_session_ws(options, target, { admitted: false });
             try {
                 // admitted and dispatching before the delete, so a failed close
                 // assertion can't be confused with a dead connection
@@ -350,7 +345,10 @@ export const describe_cross_process_ws_tests = (options) => {
         // others: a socket on the account's other token stays open.
         test_if(capabilities.ws && rpc_path !== undefined, "account_token_revoke closes the revoked token's bearer socket only", async () => {
             const fixture = await setup_test();
-            const target = await fixture.create_account({ username: 'ws_token_revoke' });
+            const target = await fixture.create_account({
+                username: 'ws_token_revoke',
+                roles: [...ws_account_roles]
+            });
             const minted = await mint_token(fixture, target, 'ws revoke probe');
             await with_sockets([() => open_bearer(minted.token), () => open_bearer(target.api_token)], async (revoked, other) => {
                 const res = expect_output(await cross_rpc_call(fixture.fresh_transport(), rpc_path, account_token_revoke_action_spec.method, { token_id: minted.id }, target.create_session_headers()), TokenRevokeOutput);
@@ -377,7 +375,8 @@ export const describe_cross_process_ws_tests = (options) => {
                 const fixture = await setup_test();
                 const target = await fixture.create_account({
                     username: `ws_revoke_${slug}`,
-                    password_value: DEFAULT_TEST_PASSWORD
+                    password_value: DEFAULT_TEST_PASSWORD,
+                    roles: [...ws_account_roles]
                 });
                 await with_sockets([() => open_bearer(target.api_token), () => open_session(target)], async (bearer, session) => {
                     await revoke(fixture, target);
@@ -391,7 +390,10 @@ export const describe_cross_process_ws_tests = (options) => {
         // before it, and its socket closes once the evicting mint commits.
         test_if(capabilities.ws && rpc_path !== undefined && max_tokens !== null, 'a token the cap evicts has its bearer socket closed', async () => {
             const fixture = await setup_test();
-            const target = await fixture.create_account({ username: 'ws_token_cap' });
+            const target = await fixture.create_account({
+                username: 'ws_token_cap',
+                roles: [...ws_account_roles]
+            });
             const watched = await mint_token(fixture, target, 'ws cap victim');
             const client = await open_bearer(watched.token);
             try {
@@ -437,12 +439,7 @@ export const describe_cross_process_ws_tests = (options) => {
         // it returns, the row is visible on either spine.
         test_if(capabilities.ws && capabilities.ws_account_actions && rpc_path !== undefined, "a WS mutation's audit row is visible after _testing_drain_effects", async () => {
             const fixture = await setup_test();
-            const client = await create_ws_transport({
-                base_url,
-                ws_path,
-                cookies: fixture.transport.cookies(),
-                origin
-            });
+            const client = await open_session_ws(options, fixture, { admitted: false });
             try {
                 await client.request(1, account_token_create_action_spec.method, {
                     name: 'ws drain probe',
@@ -453,14 +450,12 @@ export const describe_cross_process_ws_tests = (options) => {
             finally {
                 await client.close();
             }
-            const drained = await cross_rpc_call(fixture.fresh_transport({ origin: null }), rpc_path, '_testing_drain_effects', undefined, fixture.create_daemon_token_headers());
-            assert.ok(drained.ok, `_testing_drain_effects failed: ${JSON.stringify(drained.error)}`);
             // `_testing_reset` wiped audit_log at setup, so the mint is the only
             // token_create event
-            const listed = expect_output(await cross_rpc_call(fixture.transport, rpc_path, audit_log_list_action_spec.method, { event_type: 'token_create' }, fixture.create_session_headers()), AuditLogListOutput);
-            assert.strictEqual(listed.events.length, 1, JSON.stringify(listed.events));
-            assert.strictEqual(listed.events[0].outcome, 'success');
-            assert.strictEqual(listed.events[0].account_id, fixture.account.id);
+            const events = await list_audit_events(fixture, { event_type: 'token_create' }, rpc_path);
+            assert.strictEqual(events.length, 1, JSON.stringify(events));
+            assert.strictEqual(events[0].outcome, 'success');
+            assert.strictEqual(events[0].account_id, fixture.account.id);
         });
     });
 };

package/dist/testing/db_entities.d.ts

@@ -43,9 +43,22 @@ export declare const create_test_role_grant_direct: (db: Db, input: CreateRoleGr
 /**
  * Add a second `actor` to an existing test account — the multi-actor edge.
  *
- * Wraps the production `query_create_actor`; the TS twin of the Rust
- * `tests/common` `seed_extra_actor` helper. Lets a `.db.test.ts` suite build a
- * multi-actor account without reimplementing the raw insert.
+ * Its `created_at` is read from the wall clock (`clock_timestamp()`) rather
+ * than the transaction-fixed `NOW()` default the production
+ * `query_create_actor` relies on. Actors listed for an account sort by
+ * `created_at ASC, id ASC`, so an extra actor seeded in the transaction that
+ * created the account's first one would share its `created_at` and order by
+ * random id, and the multi-actor `actor_required` `available` list would come
+ * out in a random order. Seeded through here, the first actor sorts first and
+ * the extras in insert order. The bootstrap-cradle seeding of `extra_actors`
+ * uses it — the `_testing_reset` action and the in-process setup — as the Rust
+ * reset seeds them with `query_create_actor_with_clock_timestamp`.
+ *
+ * @param db - the database, or the transaction the account was seeded in
+ * @param account_id - the account the actor joins
+ * @param name - the actor's name
+ * @returns the created actor
+ * @mutates `actor` table - inserts the new row
  */
 export declare const create_test_extra_actor: (db: Db, account_id: string, name: string) => Promise<Actor>;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"db_entities.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/db_entities.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AA0B7B,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACjG,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEtC,oFAAoF;AACpF,MAAM,WAAW,oBAAoB;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC;CACb;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B,GAC1C,IAAI,EAAE,EACN,SAAS;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,KACnD,OAAO,CAAC,oBAAoB,CAI7B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,6BAA6B,GACzC,IAAI,EAAE,EACN,OAAO,oBAAoB,KACzB,OAAO,CAAC,SAAS,CAA2C,CAAC;AAEhE;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,GACnC,IAAI,EAAE,EACN,YAAY,MAAM,EAClB,MAAM,MAAM,KACV,OAAO,CAAC,KAAK,CAAiD,CAAC;AAElE;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GAAU,IAAI,EAAE,EAAE,UAAU,MAAM,KAAG,OAAO,CAAC,OAAO,CACvC,CAAC"}
+{"version":3,"file":"db_entities.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/db_entities.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AA0B7B,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACjG,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEtC,oFAAoF;AACpF,MAAM,WAAW,oBAAoB;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC;CACb;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B,GAC1C,IAAI,EAAE,EACN,SAAS;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,KACnD,OAAO,CAAC,oBAAoB,CAI7B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,6BAA6B,GACzC,IAAI,EAAE,EACN,OAAO,oBAAoB,KACzB,OAAO,CAAC,SAAS,CAA2C,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,uBAAuB,GACnC,IAAI,EAAE,EACN,YAAY,MAAM,EAClB,MAAM,MAAM,KACV,OAAO,CAAC,KAAK,CAWf,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GAAU,IAAI,EAAE,EAAE,UAAU,MAAM,KAAG,OAAO,CAAC,OAAO,CACvC,CAAC"}

package/dist/testing/db_entities.js

@@ -16,7 +16,7 @@ import './assert_dev_env.js';
  *
  * @module
  */
-import { query_create_account_with_actor, query_create_actor, query_actor_soft_delete } from '../auth/account_queries.js';
+import { query_create_account_with_actor, query_actor_by_id, query_actor_soft_delete } from '../auth/account_queries.js';
 import { query_create_role_grant } from '../auth/role_grant_queries.js';
 /**
  * Create an `account` + `actor` row pair in the database for tests.
@@ -52,11 +52,34 @@ export const create_test_role_grant_direct = async (db, input) => query_create_r
 /**
  * Add a second `actor` to an existing test account — the multi-actor edge.
  *
- * Wraps the production `query_create_actor`; the TS twin of the Rust
- * `tests/common` `seed_extra_actor` helper. Lets a `.db.test.ts` suite build a
- * multi-actor account without reimplementing the raw insert.
+ * Its `created_at` is read from the wall clock (`clock_timestamp()`) rather
+ * than the transaction-fixed `NOW()` default the production
+ * `query_create_actor` relies on. Actors listed for an account sort by
+ * `created_at ASC, id ASC`, so an extra actor seeded in the transaction that
+ * created the account's first one would share its `created_at` and order by
+ * random id, and the multi-actor `actor_required` `available` list would come
+ * out in a random order. Seeded through here, the first actor sorts first and
+ * the extras in insert order. The bootstrap-cradle seeding of `extra_actors`
+ * uses it — the `_testing_reset` action and the in-process setup — as the Rust
+ * reset seeds them with `query_create_actor_with_clock_timestamp`.
+ *
+ * @param db - the database, or the transaction the account was seeded in
+ * @param account_id - the account the actor joins
+ * @param name - the actor's name
+ * @returns the created actor
+ * @mutates `actor` table - inserts the new row
  */
-export const create_test_extra_actor = async (db, account_id, name) => query_create_actor({ db }, account_id, name);
+export const create_test_extra_actor = async (db, account_id, name) => {
+    // two steps: the actor projection's timestamp expression is private to
+    // `account_queries.ts`, so the row is read back through `query_actor_by_id`
+    const inserted = await db.query_one(`INSERT INTO actor (account_id, name, created_at) VALUES ($1, $2, clock_timestamp()) RETURNING id`, [account_id, name]);
+    if (!inserted)
+        throw new Error('create_test_extra_actor: INSERT returned no row');
+    const actor = await query_actor_by_id({ db }, inserted.id);
+    if (!actor)
+        throw new Error('create_test_extra_actor: inserted actor not found');
+    return actor;
+};
 /**
  * Soft-delete (tombstone) one actor via the production `query_actor_soft_delete`
  * — returns `true` when an active row flipped. The TS twin of the Rust