@fuzdev/fuz_app 0.68.0 → 0.70.0

package/dist/testing/cross_backend/conformance_table.js

@@ -0,0 +1,199 @@
+import '../assert_dev_env.js';
+/**
+ * Table runner for the declarative cross-backend conformance suite.
+ *
+ * `describe_conformance_table_tests` takes a list of `ConformanceCase`
+ * rows plus the standard `{setup_test, surface_source, capabilities}`
+ * fixture protocol every Tier 1 suite uses — so **one runner drives both
+ * transports**: in-process via `default_in_process_setup` (fast, every
+ * `gro test`) and cross-process via `default_cross_process_setup` (the
+ * conformance gate, exercising each impl's real auth resolution over real
+ * HTTP). Same case definition, transport-parameterized.
+ *
+ * Each row references a `method`; the runner resolves its `input` /
+ * `output` schema from the live spec registry (RPC) or `RouteSpec` (the 6
+ * REST auth routes) — the row never carries a schema. The principal the
+ * row runs `as` resolves to a `TestFixture` accessor via
+ * `resolve_principal` — no inline credential minting.
+ *
+ * @module
+ */
+import { assert, describe, test } from 'vitest';
+import { find_auth_route, rest_auth_route_suffixes, } from '../integration_helpers.js';
+import { find_rpc_action, rpc_call, resolve_rpc_endpoints_for_setup, } from '../rpc_helpers.js';
+import {} from './conformance_case.js';
+import { xfail_until } from './xfail.js';
+/**
+ * Map a `ConformancePrincipal` onto the transport + headers it
+ * authenticates with, reading exclusively from the per-test `TestFixture`.
+ *
+ * The five always-available principals resolve from fixture accessors;
+ * `role_holder` / `wrong_role` read a seeded `extra_accounts` entry named
+ * via `options.principals` (throws a clear setup error when unconfigured).
+ */
+const resolve_principal = async (fixture, as, principals) => {
+    switch (as) {
+        case 'keeper':
+            // Keeper carries its session cookie via `create_session_headers`
+            // (in-process the transport is stateless; cross-process the jar
+            // also holds it — the explicit header is the same value).
+            return { transport: fixture.transport, headers: fixture.create_session_headers() };
+        case 'daemon':
+            // Daemon-token is a non-browser credential — empty jar + no Origin.
+            return {
+                transport: fixture.fresh_transport({ origin: null }),
+                headers: fixture.create_daemon_token_headers(),
+                suppress_default_origin: true,
+            };
+        case 'token':
+            // Bearer is discarded in a browser context — empty jar + no Origin.
+            return {
+                transport: fixture.fresh_transport({ origin: null }),
+                headers: fixture.create_bearer_headers(),
+                suppress_default_origin: true,
+            };
+        case 'anonymous':
+            // Fresh jar so the keeper cookie (cross-process) can't leak in.
+            return { transport: fixture.fresh_transport(), headers: {} };
+        case 'fresh_non_admin': {
+            const account = await fixture.create_account();
+            return { transport: fixture.fresh_transport(), headers: account.create_session_headers() };
+        }
+        case 'expired_session': {
+            // The keeper presented via an expired server-side session — fresh
+            // jar so only the (expired) cookie this seam returns is sent. The
+            // minted cookie payload is valid; the backdated `auth_session` row
+            // is what the DB-row expiry gate refuses.
+            const cookie = await fixture.mint_expired_session();
+            return { transport: fixture.fresh_transport(), headers: { cookie } };
+        }
+        case 'role_holder':
+        case 'wrong_role': {
+            const username = principals?.[as];
+            if (!username) {
+                throw new Error(`conformance: principal '${as}' requires options.principals.${as} naming a seeded ` +
+                    `extra_accounts username (declare the account at setup via extra_accounts).`);
+            }
+            const extra = fixture.extra_accounts[username];
+            if (!extra) {
+                throw new Error(`conformance: extra_accounts['${username}'] not seeded for principal '${as}' — ` +
+                    `declare it in the suite's extra_accounts option.`);
+            }
+            return { transport: fixture.fresh_transport(), headers: extra.create_session_headers() };
+        }
+    }
+};
+/** Assert each expected field deep-equals the corresponding response field. */
+const assert_fields = (actual, fields, label) => {
+    assert.ok(actual !== null && typeof actual === 'object', `${label}: expected an object to read fields from, got ${JSON.stringify(actual)}`);
+    const record = actual;
+    for (const [key, expected] of Object.entries(fields)) {
+        assert.deepEqual(record[key], expected, `${label}: field '${key}'`);
+    }
+};
+const is_success_status = (status) => status >= 200 && status < 300;
+/**
+ * Run one conformance case end-to-end: resolve the principal, dispatch the
+ * request, and assert the expected status / reason / fields.
+ */
+const run_case = async (c, options, resolved_rpc_endpoints) => {
+    const fixture = await options.setup_test();
+    const { transport, headers, suppress_default_origin } = await resolve_principal(fixture, c.request.as, options.principals);
+    if (c.request.method.startsWith('/')) {
+        await run_rest_case(c, options, transport, headers);
+        return;
+    }
+    await run_rpc_case(c, transport, headers, suppress_default_origin, resolved_rpc_endpoints);
+};
+/** Dispatch + assert a case targeting an RPC method. */
+const run_rpc_case = async (c, transport, headers, suppress_default_origin, resolved_rpc_endpoints) => {
+    const found = find_rpc_action(resolved_rpc_endpoints, c.request.method);
+    if (!found) {
+        throw new Error(`conformance: RPC method '${c.request.method}' not found on the surface — ` +
+            `check the method name or that the action is registered on rpc_endpoints.`);
+    }
+    const res = await rpc_call({
+        app: transport,
+        path: found.path,
+        method: c.request.method,
+        params: c.request.params,
+        headers,
+        ...(c.request.verb && { verb: c.request.verb }),
+        ...(suppress_default_origin && { suppress_default_origin: true }),
+    });
+    if (is_success_status(c.expect.status)) {
+        assert.ok(res.ok, `${c.name}: expected success (${c.expect.status}) but got error ${JSON.stringify(res.ok ? undefined : res.error)}`);
+        assert.strictEqual(res.status, c.expect.status, `${c.name}: status`);
+        const parsed = found.action.spec.output.safeParse(res.result);
+        assert.ok(parsed.success, `${c.name}: result does not match spec.output: ${JSON.stringify(parsed.success ? undefined : parsed.error.issues)}`);
+        if (c.expect.fields)
+            assert_fields(res.result, c.expect.fields, c.name);
+        return;
+    }
+    assert.ok(!res.ok, `${c.name}: expected error status ${c.expect.status} but got success`);
+    assert.strictEqual(res.status, c.expect.status, `${c.name}: error status`);
+    if (c.expect.error_reason !== undefined) {
+        const reason = res.error.data?.reason;
+        // Most RPC denials carry `error.data.reason` (incl. the pre-validation
+        // 401 now); a denial that genuinely omits it falls back to the status
+        // assertion above to pin the denial class.
+        if (reason !== undefined) {
+            assert.strictEqual(reason, c.expect.error_reason, `${c.name}: error.data.reason`);
+        }
+    }
+    if (c.expect.fields)
+        assert_fields(res.error.data, c.expect.fields, c.name);
+};
+/** Dispatch + assert a case targeting one of the 6 REST auth routes. */
+const run_rest_case = async (c, options, transport, headers) => {
+    const suffix = c.request.method;
+    if (!rest_auth_route_suffixes.includes(suffix)) {
+        throw new Error(`conformance: REST method '${c.request.method}' is not a known auth-route suffix ` +
+            `(${rest_auth_route_suffixes.join(', ')}). Use an RPC method name for RPC actions.`);
+    }
+    const verb = c.request.verb ?? 'POST';
+    const route = find_auth_route(options.surface_source.route_specs, suffix, verb);
+    if (!route) {
+        throw new Error(`conformance: no REST route spec for ${verb} ${suffix} on the surface.`);
+    }
+    const init = {
+        method: verb,
+        headers: { 'Content-Type': 'application/json', ...headers },
+        ...(verb !== 'GET' &&
+            c.request.params !== undefined && { body: JSON.stringify(c.request.params) }),
+    };
+    const response = await transport(route.path, init);
+    assert.strictEqual(response.status, c.expect.status, `${c.name}: status`);
+    const body = await response.json().catch(() => undefined);
+    if (is_success_status(c.expect.status)) {
+        const parsed = route.output.safeParse(body);
+        assert.ok(parsed.success, `${c.name}: body does not match route output: ${JSON.stringify(parsed.success ? undefined : parsed.error.issues)}`);
+    }
+    else if (c.expect.error_reason !== undefined) {
+        const error = body?.error;
+        assert.strictEqual(error, c.expect.error_reason, `${c.name}: body.error`);
+    }
+    if (c.expect.fields)
+        assert_fields(body, c.expect.fields, c.name);
+};
+/**
+ * Register a `describe` block running every `ConformanceCase` as a
+ * vitest `test` (or `xfail_until` for deferred-by-design rows). Drives
+ * either transport via the shared `{setup_test, surface_source,
+ * capabilities}` protocol.
+ */
+export const describe_conformance_table_tests = (options) => {
+    const resolved_rpc_endpoints = resolve_rpc_endpoints_for_setup(options.rpc_endpoints, options.session_options);
+    describe(options.suite_name ?? 'conformance table', () => {
+        for (const c of options.cases) {
+            const label = c.note ? `${c.name} — ${c.note}` : c.name;
+            const body = () => run_case(c, options, resolved_rpc_endpoints);
+            if (c.xfail) {
+                xfail_until(c.xfail.tracking_id, c.xfail.reason, label, body);
+            }
+            else {
+                test(label, body);
+            }
+        }
+    });
+};

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

@@ -0,0 +1,57 @@
+import '../assert_dev_env.js';
+/**
+ * Generic vitest `globalSetup` factory for cross-backend integration suites.
+ *
+ * Pairs with `make_cross_backend_project`: each cross-backend vitest project
+ * sets its own `test.name`, and this factory derives the backend name from
+ * that project name (vitest 4 passes the `TestProject` to globalSetup), picks
+ * the matching `BackendConfig`, spawns + bootstraps it via `bootstrap_backend`,
+ * and `provide`s a serializable handle that `*.cross.test.ts` files
+ * `inject` and rebuild with `reconstruct_bootstrapped_handle`.
+ *
+ * A consumer's `global_setup.ts` collapses to:
+ *
+ * ```ts
+ * import {create_cross_backend_global_setup} from
+ *   '@fuzdev/fuz_app/testing/cross_backend/create_cross_backend_global_setup.js';
+ * import {deno_backend_config, rust_backend_config} from './my_backend_config.js';
+ * import './cross_test_types.js'; // augments inject('backend_handle')
+ *
+ * export default create_cross_backend_global_setup({
+ *   configs: {deno: deno_backend_config, rust: rust_backend_config},
+ * });
+ * ```
+ *
+ * vitest 4's `provide` hard-rejects non-serializable values, so the live
+ * `child` / `teardown` / `keeper_transport` are stripped via
+ * `serialize_bootstrapped_handle`; the teardown closure stays in the
+ * globalSetup process and is returned for vitest to fire after the suite.
+ *
+ * @module
+ */
+import type { TestProject } from 'vitest/node';
+import type { BackendConfig } from './backend_config.js';
+export interface CrossBackendGlobalSetupOptions {
+    /**
+     * Map of derived backend name → `BackendConfig` factory. The derived
+     * name (see `derive_name`) selects the factory; unknown names throw with
+     * the full supported list so a misnamed project surfaces clearly.
+     */
+    readonly configs: Readonly<Record<string, () => BackendConfig>>;
+    /**
+     * Derive the backend name from the vitest project name. Default strips
+     * `cross_backend_(ts_)?`.
+     */
+    readonly derive_name?: (project_name: string) => string;
+    /**
+     * Key passed to `project.provide` (and read by `inject` in test files).
+     * Default `'backend_handle'`. Augment vitest's `ProvidedContext` for it.
+     */
+    readonly provide_key?: string;
+}
+/**
+ * Build a vitest `globalSetup` default export. Returns the
+ * `(project) => teardown` function vitest 4 expects.
+ */
+export declare const create_cross_backend_global_setup: ({ configs, derive_name, provide_key, }: CrossBackendGlobalSetupOptions) => ((project: TestProject) => Promise<() => Promise<void>>);
+//# sourceMappingURL=create_cross_backend_global_setup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create_cross_backend_global_setup.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/create_cross_backend_global_setup.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAYvD,MAAM,WAAW,8BAA8B;IAC9C;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,aAAa,CAAC,CAAC,CAAC;IAChE;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,MAAM,CAAC;IACxD;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;GAGG;AACH,eAAO,MAAM,iCAAiC,GAAI,wCAI/C,8BAA8B,KAAG,CAAC,CAAC,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAqB1F,CAAC"}

package/dist/testing/cross_backend/create_cross_backend_global_setup.js

@@ -0,0 +1,31 @@
+import '../assert_dev_env.js';
+import { bootstrap_backend } from './bootstrap_backend.js';
+import { serialize_bootstrapped_handle } from './setup.js';
+/**
+ * Default project-name → backend-name reduction: strips the
+ * `cross_backend_` prefix plus an optional `ts_` discriminator (the TS
+ * canonical backends carry it to distinguish JS runtimes). So
+ * `cross_backend_ts_deno` → `deno` and `cross_backend_rust` → `rust`.
+ */
+const DEFAULT_PROJECT_NAME_PREFIX = /^cross_backend_(?:ts_)?/;
+/**
+ * Build a vitest `globalSetup` default export. Returns the
+ * `(project) => teardown` function vitest 4 expects.
+ */
+export const create_cross_backend_global_setup = ({ configs, derive_name = (project_name) => project_name.replace(DEFAULT_PROJECT_NAME_PREFIX, ''), provide_key = 'backend_handle', }) => {
+    return async (project) => {
+        const name = derive_name(project.name);
+        const factory = configs[name];
+        if (!factory) {
+            throw new Error(`Could not derive backend config from vitest project '${project.name}' ` +
+                `(derived name '${name}') — expected one of: ${Object.keys(configs).join(', ')}`);
+        }
+        const bootstrapped = await bootstrap_backend(factory());
+        // vitest's `provide` is keyed on the consumer-augmented `ProvidedContext`;
+        // the generic key is a plain string, so cast past the keyof constraint.
+        project.provide(provide_key, serialize_bootstrapped_handle(bootstrapped));
+        return async () => {
+            await bootstrapped.teardown();
+        };
+    };
+};

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

@@ -70,6 +70,14 @@ export interface MakeDefaultTsBackendConfigOptions {
      * override.
      */
     readonly port_env_var?: string;
+    /**
+     * Session cookie name the binary's `create_session_config` uses.
+     * Defaults to `'fuz_session'`. Must match the consumer's session config
+     * — the harness threads the `_testing_reset`-returned keeper cookie into
+     * its jar under this name, so a mismatch surfaces as 401s on the
+     * `create_account` path (e.g. fuz_forge uses `'fuz_forge_session'`).
+     */
+    readonly cookie_name?: string;
 }
 /**
  * Shared builder for TS-family backends (Deno + Node). Owns the common
@@ -111,6 +119,11 @@ export interface MakeDefaultRustBackendConfigOptions {
      * (e.g. `'info,zzz_server=info,testing_zzz_server=info'`).
      */
     readonly rust_log?: string;
+    /**
+     * Session cookie name the binary uses. Defaults to `'fuz_session'`.
+     * Must match the consumer's session config (see the TS builder's note).
+     */
+    readonly cookie_name?: string;
 }
 /**
  * Shared builder for Rust-family backends. Owns the common env baseline

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

@@ -1 +1 @@
-{"version":3,"file":"default_backend_configs.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/default_backend_configs.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAC,sBAAsB,EAAE,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAC/E,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAA2B,KAAK,gBAAgB,EAAC,MAAM,+BAA+B,CAAC;AAQ9F;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAUpC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,EAAE,mBAUtC,CAAC;AAeH,MAAM,WAAW,iCAAiC;IACjD,gFAAgF;IAChF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sCAAsC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4DAA4D;IAC5D,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9C,oDAAoD;IACpD,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,iEAAiE;IACjE,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACtD,6CAA6C;IAC7C,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAC;IAC5C,wEAAwE;IACxE,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC;IAClC,sEAAsE;IACtE,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAC/D;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,GAC1C,MAAM,iCAAiC,KACrC,aAmCF,CAAC;AAEF,MAAM,WAAW,mCAAmC;IACnD,gFAAgF;IAChF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sCAAsC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4DAA4D;IAC5D,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9C;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,iEAAiE;IACjE,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACtD,+CAA+C;IAC/C,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAC;IAC5C,wEAAwE;IACxE,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC;IAClC,sEAAsE;IACtE,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAC/D;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,GAC5C,MAAM,mCAAmC,KACvC,aA2CF,CAAC"}
+{"version":3,"file":"default_backend_configs.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/default_backend_configs.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAC,sBAAsB,EAAE,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAC/E,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAA2B,KAAK,gBAAgB,EAAC,MAAM,+BAA+B,CAAC;AAQ9F;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBASpC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,EAAE,mBAStC,CAAC;AAeH,MAAM,WAAW,iCAAiC;IACjD,gFAAgF;IAChF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sCAAsC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4DAA4D;IAC5D,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9C,oDAAoD;IACpD,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,iEAAiE;IACjE,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACtD,6CAA6C;IAC7C,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAC;IAC5C,wEAAwE;IACxE,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC;IAClC,sEAAsE;IACtE,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAC/D;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,GAC1C,MAAM,iCAAiC,KACrC,aAoCF,CAAC;AAEF,MAAM,WAAW,mCAAmC;IACnD,gFAAgF;IAChF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sCAAsC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4DAA4D;IAC5D,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9C;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,iEAAiE;IACjE,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACtD,+CAA+C;IAC/C,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAC;IAC5C,wEAAwE;IACxE,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC;IAClC,sEAAsE;IACtE,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAC/D;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,GAC5C,MAAM,mCAAmC,KACvC,aA4CF,CAAC"}

package/dist/testing/cross_backend/default_backend_configs.js

@@ -16,7 +16,6 @@ export const ts_default_capabilities = Object.freeze({
     cell_crud: true,
     cell_relations: true,
     account_lifecycle: true,
-    in_process_only: false,
 });
 /**
  * Capabilities for the Rust family. Adds `trusted_proxy: true` (the
@@ -33,7 +32,6 @@ export const rust_default_capabilities = Object.freeze({
     cell_crud: true,
     cell_relations: true,
     account_lifecycle: true,
-    in_process_only: false,
 });
 /** Bootstrap block built from the default secrets + supplied paths. */
 const build_default_bootstrap = (paths, overrides) => ({
@@ -51,7 +49,7 @@ const build_default_bootstrap = (paths, overrides) => ({
  * genuinely differs.
  */
 export const make_default_ts_backend_config = (opts) => {
-    const { name, port, start_command, database_url = 'memory://', extra_env, capabilities = ts_default_capabilities, paths = build_test_backend_paths(name), bootstrap_overrides, port_env_var = 'PORT', } = opts;
+    const { name, port, start_command, database_url = 'memory://', extra_env, capabilities = ts_default_capabilities, paths = build_test_backend_paths(name), bootstrap_overrides, port_env_var = 'PORT', cookie_name = 'fuz_session', } = opts;
     return {
         name,
         start_command,
@@ -60,7 +58,7 @@ export const make_default_ts_backend_config = (opts) => {
         ws_path: '/api/ws',
         health_path: '/health',
         bootstrap_path: '/api/account/bootstrap',
-        cookie_name: 'fuz_session',
+        cookie_name,
         startup_timeout_ms: 30_000,
         env: {
             NODE_ENV: 'development',
@@ -83,7 +81,7 @@ export const make_default_ts_backend_config = (opts) => {
  * the 120s startup window for cargo's first-run build cost.
  */
 export const make_default_rust_backend_config = (opts) => {
-    const { name, port, start_command, database_url, extra_env, capabilities = rust_default_capabilities, paths = build_test_backend_paths(name), bootstrap_overrides, port_env_var = 'PORT', rust_log = 'info', } = opts;
+    const { name, port, start_command, database_url, extra_env, capabilities = rust_default_capabilities, paths = build_test_backend_paths(name), bootstrap_overrides, port_env_var = 'PORT', rust_log = 'info', cookie_name = 'fuz_session', } = opts;
     return {
         name,
         start_command,
@@ -92,7 +90,7 @@ export const make_default_rust_backend_config = (opts) => {
         ws_path: '/api/ws',
         health_path: '/health',
         bootstrap_path: '/api/account/bootstrap',
-        cookie_name: 'fuz_session',
+        cookie_name,
         startup_timeout_ms: 120_000,
         env: {
             RUST_LOG: rust_log,

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

@@ -10,10 +10,19 @@ import type { AppServerContext } from '../../server/app_server.js';
  */
 export declare const spine_session_options: SessionOptions<string>;
 /**
- * Built-in roles only — the standard spine registers no app-defined role
- * specs. When the spine grows additional grantable roles, thread their
- * registry through `create_role_schema` here so the admin suite picks up
- * grant-path coverage.
+ * App role the role-shaped-`cell_grant` cross suite exercises. Registered
+ * with no grant path (`grant_paths: []`) so it stays a valid registry member
+ * without entering the admin / self-service grant flows — holders are seeded
+ * directly via `extra_accounts`. Must match the `cell_editor` entry in the
+ * Rust `testing_spine_stub`'s `known_roles` (cross-language test contract).
+ */
+export declare const SPINE_CELL_EDITOR_ROLE = "cell_editor";
+/**
+ * The spine's closed role registry: built-ins plus `SPINE_CELL_EDITOR_ROLE`.
+ * Threaded into the cell spec set's role-validity gate; the Rust stub mirrors
+ * the same membership. When the spine grows additional grantable roles,
+ * thread their registry through `create_role_schema` here so the admin suite
+ * picks up grant-path coverage.
  */
 export declare const spine_roles: RoleSchemaResult;
 /** RPC endpoint mount path — matches the binary's `/api/rpc`. */
@@ -27,11 +36,10 @@ export declare const SPINE_RPC_PATH = "/api/rpc";
  */
 export declare const SPINE_SSE_PATH = "/api/admin/audit/stream";
 /**
- * Factory-form RPC endpoints so the `app_settings_update` handler closes
- * over the per-test `ctx.app_settings`. `create_app_server` (in the binary)
- * owns live dispatch; the surface builder invokes the factory once with a
- * stub ctx for setup-time path/method lookup, so the handler closures are
- * never called across the process boundary.
+ * Factory-form RPC endpoints over the per-test `ctx.deps`. `create_app_server`
+ * (in the binary) owns live dispatch; the surface builder invokes the factory
+ * once with a stub ctx for setup-time path/method lookup, so the handler
+ * closures are never called across the process boundary.
  *
  * Test binaries append their own `_testing_reset` action to this endpoint's
  * `actions` (see `testing_reset_actions.ts`); it is intentionally excluded

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

@@ -1 +1 @@
-{"version":3,"file":"default_spine_surface.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/default_spine_surface.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA6B9B,OAAO,EAAqB,KAAK,gBAAgB,EAAC,MAAM,2BAA2B,CAAC;AACpF,OAAO,EAAwB,KAAK,cAAc,EAAC,MAAM,8BAA8B,CAAC;AAGxF,OAAO,EAAqB,KAAK,SAAS,EAAC,MAAM,0BAA0B,CAAC;AAC5E,OAAO,KAAK,EAAC,cAAc,EAAE,eAAe,EAAC,MAAM,uBAAuB,CAAC;AAC3E,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,4BAA4B,CAAC;AAGjE;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,MAAM,CAAwC,CAAC;AAElG;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,gBAAyC,CAAC;AAEpE,iEAAiE;AACjE,eAAO,MAAM,cAAc,aAAa,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,4BAA4B,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,GAAI,KAAK,gBAAgB,KAAG,KAAK,CAAC,eAAe,CAQhF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,GAAI,KAAK,gBAAgB,KAAG,KAAK,CAAC,SAAS,CAkB/E,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,QAAO,cAM1C,CAAC"}
+{"version":3,"file":"default_spine_surface.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/default_spine_surface.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA6B9B,OAAO,EAAqB,KAAK,gBAAgB,EAAC,MAAM,2BAA2B,CAAC;AACpF,OAAO,EAAwB,KAAK,cAAc,EAAC,MAAM,8BAA8B,CAAC;AAGxF,OAAO,EAAqB,KAAK,SAAS,EAAC,MAAM,0BAA0B,CAAC;AAC5E,OAAO,KAAK,EAAC,cAAc,EAAE,eAAe,EAAC,MAAM,uBAAuB,CAAC;AAC3E,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,4BAA4B,CAAC;AAGjE;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,MAAM,CAAwC,CAAC;AAElG;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,gBAAgB,CAAC;AAEpD;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,EAAE,gBAExB,CAAC;AAEH,iEAAiE;AACjE,eAAO,MAAM,cAAc,aAAa,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,4BAA4B,CAAC;AAExD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAAI,KAAK,gBAAgB,KAAG,KAAK,CAAC,eAAe,CAOhF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,GAAI,KAAK,gBAAgB,KAAG,KAAK,CAAC,SAAS,CAiB/E,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,QAAO,cAM1C,CAAC"}

package/dist/testing/cross_backend/default_spine_surface.js

@@ -37,12 +37,23 @@ import { create_test_app_surface_spec } from '../stubs.js';
  */
 export const spine_session_options = create_session_config('fuz_session');
 /**
- * Built-in roles only — the standard spine registers no app-defined role
- * specs. When the spine grows additional grantable roles, thread their
- * registry through `create_role_schema` here so the admin suite picks up
- * grant-path coverage.
+ * App role the role-shaped-`cell_grant` cross suite exercises. Registered
+ * with no grant path (`grant_paths: []`) so it stays a valid registry member
+ * without entering the admin / self-service grant flows — holders are seeded
+ * directly via `extra_accounts`. Must match the `cell_editor` entry in the
+ * Rust `testing_spine_stub`'s `known_roles` (cross-language test contract).
  */
-export const spine_roles = create_role_schema([]);
+export const SPINE_CELL_EDITOR_ROLE = 'cell_editor';
+/**
+ * The spine's closed role registry: built-ins plus `SPINE_CELL_EDITOR_ROLE`.
+ * Threaded into the cell spec set's role-validity gate; the Rust stub mirrors
+ * the same membership. When the spine grows additional grantable roles,
+ * thread their registry through `create_role_schema` here so the admin suite
+ * picks up grant-path coverage.
+ */
+export const spine_roles = create_role_schema([
+    { name: SPINE_CELL_EDITOR_ROLE, grant_paths: [] },
+]);
 /** RPC endpoint mount path — matches the binary's `/api/rpc`. */
 export const SPINE_RPC_PATH = '/api/rpc';
 /**
@@ -54,11 +65,10 @@ export const SPINE_RPC_PATH = '/api/rpc';
  */
 export const SPINE_SSE_PATH = '/api/admin/audit/stream';
 /**
- * Factory-form RPC endpoints so the `app_settings_update` handler closes
- * over the per-test `ctx.app_settings`. `create_app_server` (in the binary)
- * owns live dispatch; the surface builder invokes the factory once with a
- * stub ctx for setup-time path/method lookup, so the handler closures are
- * never called across the process boundary.
+ * Factory-form RPC endpoints over the per-test `ctx.deps`. `create_app_server`
+ * (in the binary) owns live dispatch; the surface builder invokes the factory
+ * once with a stub ctx for setup-time path/method lookup, so the handler
+ * closures are never called across the process boundary.
  *
  * Test binaries append their own `_testing_reset` action to this endpoint's
  * `actions` (see `testing_reset_actions.ts`); it is intentionally excluded
@@ -69,7 +79,6 @@ export const spine_rpc_endpoints = (ctx) => [
     {
         path: SPINE_RPC_PATH,
         actions: create_standard_rpc_actions(ctx.deps, {
-            app_settings: ctx.app_settings,
             roles: spine_roles,
         }),
     },
@@ -97,7 +106,6 @@ export const create_spine_route_specs = (ctx) => [
             session_options: spine_session_options,
             ip_rate_limiter: null,
             signup_account_rate_limiter: null,
-            app_settings: ctx.app_settings,
         }),
     ]),
     ...(ctx.audit_sse

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

@@ -0,0 +1,72 @@
+/**
+ * Generic vitest project factory for cross-backend integration suites.
+ *
+ * One vitest project per spawned backend; each runs the consumer's shared
+ * `*.cross.test.ts` files against its own bootstrapped binary. The paired
+ * `create_cross_backend_global_setup` (in `global_setup.ts`) reads the
+ * project's `name` to pick which `BackendConfig` to spawn, so the project
+ * name is the single source of truth for backend selection.
+ *
+ * Consumers compose these into their `vite.config.ts`:
+ *
+ * ```ts
+ * const cross_backend_projects = process.env.FUZ_TEST_CROSS_BACKEND
+ *   ? [
+ *       make_cross_backend_project({name: 'cross_backend_ts_deno', global_setup: GLOBAL_SETUP}),
+ *       make_cross_backend_project({name: 'cross_backend_rust', global_setup: GLOBAL_SETUP}),
+ *     ]
+ *   : [];
+ * ```
+ *
+ * where `GLOBAL_SETUP = './src/test/cross_backend/global_setup.ts'`.
+ *
+ * This module is intentionally dependency-free and `assert_dev_env`-free:
+ * it runs at vite **config** time (including production builds, where the
+ * consumer gates the projects behind an env flag), so it must not pull in
+ * the DEV-only test runtime.
+ *
+ * @module
+ */
+export interface CrossBackendProjectOptions {
+    /**
+     * vitest project name. `create_cross_backend_global_setup` derives the
+     * backend name from it (by default stripping a `cross_backend_(ts_)?`
+     * prefix), so name projects `cross_backend_<backend>` (e.g.
+     * `cross_backend_rust`, `cross_backend_ts_deno`).
+     */
+    readonly name: string;
+    /**
+     * Path to the consumer's vitest `globalSetup` module, relative to the
+     * consumer repo root (e.g. `'./src/test/cross_backend/global_setup.ts'`).
+     * That module is expected to export a `create_cross_backend_global_setup`
+     * result as its default.
+     */
+    readonly global_setup: string;
+    /** Test-file globs. Default: `['src/test/cross_backend/*.cross.test.ts']`. */
+    readonly include?: ReadonlyArray<string>;
+    /** Globs to exclude from `include` (e.g. a backend-specific variant file). Default: `[]`. */
+    readonly exclude?: ReadonlyArray<string>;
+    /** vitest `sequence.groupOrder`. Default: `3` (runs after unit + db). */
+    readonly group_order?: number;
+}
+/**
+ * Build a single cross-backend vitest project config. Spread the results
+ * into `test.projects` in the consumer's `vite.config.ts`. `isolate: false`
+ * + `fileParallelism: false` because a project shares one spawned backend
+ * across its files.
+ */
+export declare const make_cross_backend_project: ({ name, global_setup, include, exclude, group_order, }: CrossBackendProjectOptions) => {
+    extends: true;
+    test: {
+        name: string;
+        include: Array<string>;
+        exclude: Array<string>;
+        globalSetup: Array<string>;
+        isolate: false;
+        fileParallelism: false;
+        sequence: {
+            groupOrder: number;
+        };
+    };
+};
+//# sourceMappingURL=make_cross_backend_project.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"make_cross_backend_project.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/make_cross_backend_project.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAQH,MAAM,WAAW,0BAA0B;IAC1C;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACzC,6FAA6F;IAC7F,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACzC,yEAAyE;IACzE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,GAAI,wDAMxC,0BAA0B,KAAG;IAC/B,OAAO,EAAE,IAAI,CAAC;IACd,IAAI,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QACvB,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QACvB,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QAC3B,OAAO,EAAE,KAAK,CAAC;QACf,eAAe,EAAE,KAAK,CAAC;QACvB,QAAQ,EAAE;YAAC,UAAU,EAAE,MAAM,CAAA;SAAC,CAAC;KAC/B,CAAC;CAYD,CAAC"}

package/dist/testing/cross_backend/make_cross_backend_project.js

@@ -0,0 +1,51 @@
+/**
+ * Generic vitest project factory for cross-backend integration suites.
+ *
+ * One vitest project per spawned backend; each runs the consumer's shared
+ * `*.cross.test.ts` files against its own bootstrapped binary. The paired
+ * `create_cross_backend_global_setup` (in `global_setup.ts`) reads the
+ * project's `name` to pick which `BackendConfig` to spawn, so the project
+ * name is the single source of truth for backend selection.
+ *
+ * Consumers compose these into their `vite.config.ts`:
+ *
+ * ```ts
+ * const cross_backend_projects = process.env.FUZ_TEST_CROSS_BACKEND
+ *   ? [
+ *       make_cross_backend_project({name: 'cross_backend_ts_deno', global_setup: GLOBAL_SETUP}),
+ *       make_cross_backend_project({name: 'cross_backend_rust', global_setup: GLOBAL_SETUP}),
+ *     ]
+ *   : [];
+ * ```
+ *
+ * where `GLOBAL_SETUP = './src/test/cross_backend/global_setup.ts'`.
+ *
+ * This module is intentionally dependency-free and `assert_dev_env`-free:
+ * it runs at vite **config** time (including production builds, where the
+ * consumer gates the projects behind an env flag), so it must not pull in
+ * the DEV-only test runtime.
+ *
+ * @module
+ */
+/** Default test-file globs — the convention is `src/test/cross_backend/*.cross.test.ts`. */
+const DEFAULT_INCLUDE = ['src/test/cross_backend/*.cross.test.ts'];
+/** vitest `sequence.groupOrder` for cross-backend projects — after unit (1) + db (2). */
+const DEFAULT_GROUP_ORDER = 3;
+/**
+ * Build a single cross-backend vitest project config. Spread the results
+ * into `test.projects` in the consumer's `vite.config.ts`. `isolate: false`
+ * + `fileParallelism: false` because a project shares one spawned backend
+ * across its files.
+ */
+export const make_cross_backend_project = ({ name, global_setup, include = DEFAULT_INCLUDE, exclude = [], group_order = DEFAULT_GROUP_ORDER, }) => ({
+    extends: true,
+    test: {
+        name,
+        include: [...include],
+        exclude: [...exclude],
+        globalSetup: [global_setup],
+        isolate: false,
+        fileParallelism: false,
+        sequence: { groupOrder: group_order },
+    },
+});

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

@@ -0,0 +1,10 @@
+import '../assert_dev_env.js';
+import type { CellCrossTestOptions } from './cell_cross_helpers.js';
+/**
+ * Options for the origin parity suite. Shares the shape of the cell /
+ * account-lifecycle suites (`setup_test` / `capabilities` / `rpc_path`);
+ * reuses `CellCrossTestOptions` rather than minting a structural duplicate.
+ */
+export type OriginCrossTestOptions = CellCrossTestOptions;
+export declare const describe_origin_cross_tests: (options: OriginCrossTestOptions) => void;
+//# sourceMappingURL=origin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"origin.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/origin.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAkC9B,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,yBAAyB,CAAC;AAGlE;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,oBAAoB,CAAC;AAM1D,eAAO,MAAM,2BAA2B,GAAI,SAAS,sBAAsB,KAAG,IAwC7E,CAAC"}