@fuzdev/fuz_app 0.148.0 → 0.150.0

package/dist/testing/cross_backend/spine_suites.js

@@ -17,7 +17,14 @@ import '../assert_dev_env.js';
  *
  * - `exclude` names a suite with the reason it can't run on this backend; the
  *   reason is required and shows in the run as a skipped test, so a skip is
- *   stated in code and visible in the report.
+ *   stated in code and visible in the report. `testing_backdoor` can't be
+ *   excluded, by suite or by case, nor its `capabilities.testing_backdoors`
+ *   changed: it checks the declaration the backdoor gating reads.
+ * - `exclude_cases` names single tests of a suite that does run, each by its
+ *   name path (describe titles and test name, joined with `' > '`) with a
+ *   required reason; one `beforeEach` skips them at run time, so each shows as
+ *   skipped with its reason, and an entry matching no collected test of its
+ *   suite fails the closing check test.
  * - `overrides` replaces a suite's derived options, field by field (a shallow
  *   merge over what the handle gives) — a role list the backend's WS upgrade
  *   requires, an `xfail` for a tracked divergence, a narrower capability set.
@@ -25,7 +32,10 @@ import '../assert_dev_env.js';
  *   built on a derived value. A required option the merge leaves `undefined`
  *   throws at collection.
  * - `rpc_success_fixtures` / `rpc_skip_methods` / `rpc_input_overrides` go to
- *   the standard bundle's RPC round-trip.
+ *   the standard bundle's RPC round-trip; `rpc_input_overrides` also seeds
+ *   `rpc_adversarial`'s params cases (each override is the valid base they
+ *   break one field of). A key naming a method on neither the declared surface
+ *   nor `live_rpc_endpoints` throws at collection.
  * - `ws_required_roles` names the roles the backend's WS upgrade requires, so the
  *   suites that open sockets for accounts they create give them those roles.
  * - `suite_roles` names the roles the role-shaped suites use when the backend's
@@ -41,6 +51,15 @@ import '../assert_dev_env.js';
  * config's `SECRET_FUZ_COOKIE_KEYS`), else from `overrides`; when neither has
  * it, the call throws naming the suite — provide it or exclude the suite.
  *
+ * **Backdoors.** The backend's `capabilities.testing_backdoors` must declare
+ * `SPINE_SUITES_REQUIRED_BACKDOORS` (the per-test reset and the audit
+ * barrier), and `_testing_put_fact` when it declares `fact_serving`; the call
+ * throws otherwise. A suite every case of which drives another backdoor
+ * (`credential_deadline`, `origin_conformance`, `ws_outbound_overflow`) skips
+ * itself on a backend not declaring it, shown like an exclude with a reason
+ * naming the backdoor — so an exclude, override or `exclude_cases` entry for
+ * it is refused as dead.
+ *
  * **Not in the one call** (`STANDALONE_CROSS_SUITES`, with the reasons): the
  * suites that need two handles (the differential), a backend spawned with live
  * limiters (`login_security`, `ws_action_rate_limit` — the standard suites would
@@ -48,11 +67,13 @@ import '../assert_dev_env.js';
  * cases. Each keeps its own entry point.
  *
  * Suites are registered without a wrapping `describe`, so their test names are
- * the same as when each is called on its own.
+ * the same as when each is called on its own — and an `exclude_cases` path is
+ * the name the reporter prints after the file and any `describe` wrapping the
+ * call.
  *
  * @module
  */
-import { describe, test } from 'vitest';
+import { beforeAll, beforeEach, describe, test, TestRunner } from 'vitest';
 import { ROLE_KEEPER, ROLE_ADMIN } from '../../auth/role_schema.js';
 import { resolve_rpc_endpoints_for_setup } from '../rpc_helpers.js';
 import { describe_account_lifecycle_cross_tests } from './account_lifecycle.js';
@@ -161,6 +182,16 @@ export const STANDALONE_CROSS_SUITES = {
     ws_action_rate_limit: 'needs a backend spawned with the action limiters enabled, which the standard suites would exhaust',
     conformance_table: "a runner over the consumer's own cases, not a suite"
 };
+/**
+ * The backdoors `describe_spine_cross_suites` requires of every backend, since
+ * the suites share them: `_testing_reset` is every `setup_test`'s per-test
+ * reset, and `_testing_drain_effects` the barrier every audit read waits on. A
+ * backend whose `capabilities.testing_backdoors` lacks one fails at collection.
+ */
+export const SPINE_SUITES_REQUIRED_BACKDOORS = Object.freeze([
+    '_testing_reset',
+    '_testing_drain_effects'
+]);
 /**
  * The suite options a handle's `config` supplies — the fields most cross
  * suites take beside `setup_test`. For a suite called on its own:
@@ -268,7 +299,8 @@ const SUITE_ENTRIES = {
             ws_account_roles: c.options.ws_required_roles
         }),
         describe: describe_credential_deadline_cross_tests,
-        required: { setup_test: true, capabilities: true, base_url: true, ws_path: true }
+        required: { setup_test: true, capabilities: true, base_url: true, ws_path: true },
+        backdoors: ['_testing_shorten_credential_expiry']
     },
     credential_header_robustness: {
         derive: (c) => ({
@@ -301,7 +333,8 @@ const SUITE_ENTRIES = {
     origin_conformance: {
         derive: (c) => ({ setup_test: c.setup(), rpc_path: c.config.rpc_path }),
         describe: describe_origin_conformance_cross_tests,
-        required: { setup_test: true }
+        required: { setup_test: true },
+        backdoors: ['_testing_origin_check']
     },
     origin_scope: {
         derive: (c) => ({
@@ -385,7 +418,8 @@ const SUITE_ENTRIES = {
             surface_source: c.options.surface_source,
             live_rpc_endpoints: c.options.live_rpc_endpoints &&
                 resolve_rpc_endpoints_for_setup(c.options.live_rpc_endpoints, c.options.session_options),
-            rpc_path: c.config.rpc_path
+            rpc_path: c.config.rpc_path,
+            input_overrides: c.options.rpc_input_overrides
         }),
         describe: describe_rpc_adversarial_cross_tests,
         required: { setup_test: true, surface_source: true }
@@ -451,9 +485,9 @@ const SUITE_ENTRIES = {
         }
     },
     testing_backdoor: {
-        derive: (c) => ({ setup_test: c.setup(), rpc_path: c.config.rpc_path, ws: c.ws }),
+        derive: (c) => ({ ...rpc_gated(c), ws: c.ws }),
         describe: describe_testing_backdoor_cross_tests,
-        required: { setup_test: true }
+        required: { setup_test: true, capabilities: true }
     },
     token_lifetime: {
         derive: (c) => ({ setup_test: c.setup(), rpc_path: c.config.rpc_path }),
@@ -506,7 +540,8 @@ const SUITE_ENTRIES = {
             rpc_path: c.config.rpc_path
         }),
         describe: describe_ws_outbound_overflow_cross_tests,
-        required: { setup_test: true, capabilities: true, base_url: true, ws_path: true }
+        required: { setup_test: true, capabilities: true, base_url: true, ws_path: true },
+        backdoors: ['_testing_flood_notifications']
     },
     ws_role_gated: {
         // the reference spines' role-gated endpoint; a backend mounting its own
@@ -553,12 +588,62 @@ const merge_setup_options = (base, seed) => ({
     extra_accounts: [...(base?.extra_accounts ?? []), ...(seed?.extra_accounts ?? [])],
     extra_actors: [...(base?.extra_actors ?? []), ...(seed?.extra_actors ?? [])]
 });
+/**
+ * The backdoors every case of `name` drives beyond
+ * `SPINE_SUITES_REQUIRED_BACKDOORS` — a backend not declaring one skips the
+ * suite.
+ *
+ * @param name - the suite
+ * @returns its `SuiteEntry.backdoors`, empty for a suite needing none
+ * @internal
+ */
+export const get_spine_suite_backdoors = (name) => SUITE_ENTRIES[name].backdoors ?? [];
 const is_suite_name = (name) => SUITE_NAMES.includes(name);
 /**
- * Refuse an exclude with an empty reason, an unknown suite name, and a suite
- * both excluded and overridden — before anything is registered.
+ * Each suite whose backdoors `declared` lacks, with the generated reason it is
+ * skipped — the suites whose every case drives a backdoor (`SuiteEntry.backdoors`).
  */
-const validate_spine_cross_suites_options = (options) => {
+const to_backdoor_skips = (declared) => {
+    const skips = new Map();
+    for (const name of SUITE_NAMES) {
+        const missing = get_spine_suite_backdoors(name).filter((m) => !declared.includes(m));
+        if (missing.length > 0) {
+            skips.set(name, `needs ${missing.map((m) => `\`${m}\``).join(', ')}, which capabilities.testing_backdoors doesn't declare`);
+        }
+    }
+    return skips;
+};
+/**
+ * Refuse an exclude with an empty reason, an unknown suite name, a suite both
+ * excluded and overridden, a backend missing a backdoor the suites share, an
+ * exclude or override of a suite that skips itself for an undeclared
+ * backdoor, any exclusion of `testing_backdoor`, and an `exclude_cases` entry
+ * naming a suite the call doesn't run or carrying no reason — before anything
+ * is registered.
+ */
+const validate_spine_cross_suites_options = (options, declared, backdoor_skips, capabilities) => {
+    if (options.rpc_input_overrides?.size) {
+        // a key the round-trip (the declared surface) and `rpc_adversarial` (that
+        // and the live mount) both lack would be ignored silently — a typo
+        const methods = new Set();
+        for (const endpoint of options.surface_source.surface.rpc_endpoints) {
+            for (const method of endpoint.methods)
+                methods.add(method.name);
+        }
+        if (options.live_rpc_endpoints) {
+            const live = resolve_rpc_endpoints_for_setup(options.live_rpc_endpoints, options.session_options);
+            for (const endpoint of live) {
+                for (const action of endpoint.actions)
+                    methods.add(action.spec.method);
+            }
+        }
+        for (const method of options.rpc_input_overrides.keys()) {
+            if (!methods.has(method)) {
+                throw new Error(`describe_spine_cross_suites: rpc_input_overrides names '${method}', ` +
+                    `a method on neither the declared surface nor the live mount`);
+            }
+        }
+    }
     for (const [name, reason] of Object.entries(options.exclude ?? {})) {
         if (!is_suite_name(name)) {
             throw new Error(`describe_spine_cross_suites: exclude names unknown suite '${name}'`);
@@ -569,11 +654,58 @@ const validate_spine_cross_suites_options = (options) => {
         if (options.overrides?.[name] !== undefined) {
             throw new Error(`describe_spine_cross_suites: '${name}' is both excluded and overridden`);
         }
+        if (name === 'testing_backdoor') {
+            throw new Error("describe_spine_cross_suites: 'testing_backdoor' can't be excluded — it checks the " +
+                'capabilities.testing_backdoors declaration the other suites gate on');
+        }
+        const skip = backdoor_skips.get(name);
+        if (skip !== undefined) {
+            throw new Error(`describe_spine_cross_suites: exclude '${name}' is redundant — the suite skips itself (${skip})`);
+        }
     }
     for (const name of Object.keys(options.overrides ?? {})) {
         if (!is_suite_name(name)) {
             throw new Error(`describe_spine_cross_suites: overrides names unknown suite '${name}'`);
         }
+        const skip = backdoor_skips.get(name);
+        if (skip !== undefined) {
+            throw new Error(`describe_spine_cross_suites: overrides names '${name}', which skips itself (${skip})`);
+        }
+    }
+    for (const [name, cases] of Object.entries(options.exclude_cases ?? {})) {
+        if (!is_suite_name(name)) {
+            throw new Error(`describe_spine_cross_suites: exclude_cases names unknown suite '${name}'`);
+        }
+        if (options.exclude?.[name] !== undefined) {
+            throw new Error(`describe_spine_cross_suites: '${name}' is excluded, so its exclude_cases entries name nothing`);
+        }
+        if (name === 'testing_backdoor') {
+            throw new Error("describe_spine_cross_suites: exclude_cases can't name 'testing_backdoor' — it checks the " +
+                'capabilities.testing_backdoors declaration the other suites gate on, and a declared ' +
+                'backdoor failing its credential row is a bug, not a case to skip');
+        }
+        const skip = backdoor_skips.get(name);
+        if (skip !== undefined) {
+            throw new Error(`describe_spine_cross_suites: exclude_cases names '${name}', which skips itself (${skip})`);
+        }
+        const entries = Object.entries(cases ?? {});
+        if (entries.length === 0) {
+            throw new Error(`describe_spine_cross_suites: exclude_cases '${name}' names no test`);
+        }
+        for (const [test_name, reason] of entries) {
+            if (typeof reason !== 'string' || reason.trim() === '') {
+                throw new Error(`describe_spine_cross_suites: exclude_cases '${name}' › '${test_name}' needs a reason`);
+            }
+        }
+    }
+    const missing = SPINE_SUITES_REQUIRED_BACKDOORS.filter((m) => !declared.includes(m));
+    if (missing.length > 0) {
+        throw new Error(`describe_spine_cross_suites: capabilities.testing_backdoors must declare ${missing.join(', ')} ` +
+            '— every suite resets through _testing_reset and reads audit rows behind _testing_drain_effects');
+    }
+    if (capabilities.fact_serving && !declared.includes('_testing_put_fact')) {
+        throw new Error('describe_spine_cross_suites: capabilities.fact_serving needs _testing_put_fact in ' +
+            'capabilities.testing_backdoors — the fact suites seed through it');
     }
 };
 const run_suite = (name, context) => {
@@ -589,21 +721,146 @@ const run_suite = (name, context) => {
                 `nor the override gives — pass \`overrides.${name}\` with it or exclude '${name}' with a reason`);
         }
     }
+    // the backdoor suite checks the declaration the gating read, so an override
+    // can't hand it another; it reads nothing else of `capabilities`, so a copy
+    // keeping the list passes
+    if (name === 'testing_backdoor') {
+        const checked = suite_options.capabilities
+            .testing_backdoors;
+        const declared = context.config.capabilities.testing_backdoors;
+        // the same entries, each as often, in any order
+        if ([...checked].sort().join(' ') !== [...declared].sort().join(' ')) {
+            throw new Error("describe_spine_cross_suites: overrides can't change 'testing_backdoor' " +
+                'capabilities.testing_backdoors — it checks the declaration the other suites gate on');
+        }
+    }
     entry.describe(suite_options);
 };
+/**
+ * Where `task` sits below `root`: its name path (its describe titles and its
+ * name) and its top-level ancestor, one of `root`'s own tasks — or `null`
+ * outside `root`.
+ */
+const locate_task = (task, root) => {
+    const path = [];
+    let current = task;
+    for (;;) {
+        path.unshift(current.name);
+        // a test or describe at a file's top level has no `suite`, only its `file`
+        const parent = current.suite ?? current.file;
+        if (parent === root)
+            return { path, top: current };
+        if (!parent || parent === current)
+            return null;
+        current = parent;
+    }
+};
+/** Every test under `task`, as name paths starting with `prefix`. */
+const collect_test_paths = (task, prefix, out) => {
+    const path = [...prefix, task.name];
+    if (task.type === 'suite') {
+        for (const child of task.tasks)
+            collect_test_paths(child, path, out);
+    }
+    else {
+        out.add(path.join(' > '));
+    }
+};
+/**
+ * Check every `exclude_cases` entry against the test paths each suite
+ * collected — the static half of the case exclusions, which the closing test
+ * `register_spine_case_exclusions` registers runs.
+ *
+ * @param exclude_cases - the entries, by suite
+ * @param collected - each run suite's collected test paths
+ * @throws Error - naming every entry whose suite collected no test at its path
+ * @internal
+ */
+export const check_spine_case_exclusions = (exclude_cases, collected) => {
+    const dead = [];
+    for (const [name, cases] of Object.entries(exclude_cases)) {
+        const paths = collected.get(name);
+        for (const test_name of Object.keys(cases ?? {})) {
+            if (!paths?.has(test_name))
+                dead.push(`${name} › ${test_name}`);
+        }
+    }
+    if (dead.length > 0) {
+        throw new Error(`exclude_cases entries naming no collected test of their suite (a renamed or removed ` +
+            `test, or a path missing a describe title): ${dead.join('; ')}`);
+    }
+};
+/**
+ * Skip the `exclude_cases` tests, and fail on an entry no collected test has.
+ * `describe_spine_cross_suites` calls it after registering the suites, in the
+ * same suite.
+ *
+ * One `beforeEach` on the calling suite: it finds the test's top-level task
+ * among the ranges the suites registered, and calls `ctx.skip(reason)` when
+ * that suite's entries name the test's path — so the suite files stay as they
+ * are, and the test shows as skipped with its reason. A closing test holds
+ * every entry to a test its suite collected (`check_spine_case_exclusions`;
+ * the paths are read at collection, so a filtered run still checks them).
+ * A skipped test's own `beforeEach` hooks don't run, but its `afterEach`
+ * hooks and its suite's `beforeAll` still do.
+ *
+ * @param exclude_cases - the entries, by suite
+ * @param ranges - each run suite's top-level tasks in the calling suite
+ * @internal
+ */
+export const register_spine_case_exclusions = (exclude_cases, ranges) => {
+    let root;
+    const collected = new Map();
+    const suite_of = (index) => ranges.find((r) => index >= r.start && index < r.end)?.name;
+    // vitest passes the suite a hook is registered on as the second argument,
+    // and requires the first be destructured
+    // eslint-disable-next-line no-empty-pattern
+    beforeAll(({}, suite) => {
+        root = suite;
+        for (const range of ranges) {
+            const paths = new Set();
+            for (const task of suite.tasks.slice(range.start, range.end)) {
+                collect_test_paths(task, [], paths);
+            }
+            collected.set(range.name, paths);
+        }
+    });
+    beforeEach((ctx) => {
+        if (!root)
+            return;
+        const located = locate_task(ctx.task, root);
+        if (!located)
+            return;
+        const name = suite_of(root.tasks.indexOf(located.top));
+        if (name === undefined)
+            return;
+        const reason = exclude_cases[name]?.[located.path.join(' > ')];
+        if (reason !== undefined)
+            ctx.skip(`excluded on this backend: ${reason}`);
+    });
+    test('spine cross suites: every exclude_cases entry names a collected test', () => {
+        check_spine_case_exclusions(exclude_cases, collected);
+    });
+};
 /**
  * Run every shipped single-backend cross suite against one spawned backend —
  * see the module doc for what the options add and what stays outside.
  *
  * @param handle - the backend, as `inject_backend_handle()` returns it
- * @param options - the declared surface, plus excludes and overrides
+ * @param options - the declared surface, plus excludes, case exclusions and overrides
  * @throws Error - on an exclude with no reason, an unknown suite name, a suite
- *   both excluded and overridden, or a suite missing an input the handle
- *   doesn't carry
+ *   both excluded and overridden, an excluded `testing_backdoor` (or one of
+ *   its cases, or an override changing its `capabilities.testing_backdoors`), an exclude,
+ *   override or `exclude_cases` entry for a suite that skips itself or isn't
+ *   run, a backend not declaring `SPINE_SUITES_REQUIRED_BACKDOORS` (or
+ *   `_testing_put_fact` with `fact_serving`), or a suite missing an input the
+ *   handle doesn't carry
  */
 export const describe_spine_cross_suites = (handle, options) => {
-    validate_spine_cross_suites_options(options);
     const config = to_cross_suite_options(handle);
+    const declared = config.capabilities.testing_backdoors;
+    const backdoor_skips = to_backdoor_skips(declared);
+    validate_spine_cross_suites_options(options, declared, backdoor_skips, config.capabilities);
     const context = {
         handle,
         config,
@@ -611,15 +868,29 @@ export const describe_spine_cross_suites = (handle, options) => {
         setup: (seed) => default_cross_process_setup(handle, merge_setup_options(options.setup, seed)),
         ws: config.capabilities.ws ? { base_url: config.base_url, ws_path: config.ws_path } : undefined
     };
-    const excluded = Object.entries(options.exclude ?? {});
+    // each suite's top-level tasks, by index, so the case exclusions know which
+    // suite a test belongs to
+    const collector = TestRunner.getCurrentSuite();
+    const ranges = [];
+    const skipped = Object.entries(options.exclude ?? {});
     for (const name of SUITE_NAMES) {
         if (options.exclude?.[name] !== undefined)
             continue;
+        const skip = backdoor_skips.get(name);
+        if (skip !== undefined) {
+            skipped.push([name, skip]);
+            continue;
+        }
+        const start = collector.tasks.length;
         run_suite(name, context);
+        ranges.push({ name, start, end: collector.tasks.length });
+    }
+    if (Object.keys(options.exclude_cases ?? {}).length > 0) {
+        register_spine_case_exclusions(options.exclude_cases, ranges);
     }
-    if (excluded.length > 0) {
+    if (skipped.length > 0) {
         describe('spine cross suites excluded on this backend', () => {
-            for (const [name, reason] of excluded)
+            for (const [name, reason] of skipped)
                 test.skip(`${name}: ${reason}`, () => { });
         });
     }

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

@@ -13,6 +13,21 @@ export declare const TESTING_ACTION_AUTH: {
     readonly actor: "none";
     readonly credential_types: readonly ["daemon_token"];
 };
+/**
+ * Every `_testing_*` backdoor the shipped cross suites know: the daemon-token
+ * actions a test binary may mount for the harness to drive. The one list a
+ * backend's `capabilities.testing_backdoors` declares from, the
+ * testing-backdoor suite probes, and `describe_spine_cross_suites` gates suites
+ * on. A consumer's own seams stay off it — the testing-backdoor suite takes
+ * those as `extra_methods`.
+ *
+ * `spine_surface_constants.testing_backdoors.test.ts` holds it to the `_testing_*` methods
+ * fuz_app's spine binary mounts, so an action added there fails until it is
+ * listed here.
+ */
+export declare const TESTING_BACKDOOR_METHODS: readonly ["_testing_reset", "_testing_drain_effects", "_testing_mint_session", "_testing_put_fact", "_testing_flood_notifications", "_testing_schema_snapshot", "_testing_migration_tracker", "_testing_action_manifest", "_testing_origin_check", "_testing_shorten_credential_expiry"];
+/** A `_testing_*` backdoor the shipped cross suites know — see `TESTING_BACKDOOR_METHODS`. */
+export type TestingBackdoorMethod = (typeof TESTING_BACKDOOR_METHODS)[number];
 /** RPC endpoint mount path — matches the binary's `/api/rpc`. */
 export declare const SPINE_RPC_PATH = "/api/rpc";
 /** Ungated WebSocket endpoint mount path — matches the binaries' `/api/ws`. */

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

@@ -1 +1 @@
-{"version":3,"file":"spine_surface_constants.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/spine_surface_constants.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA4B9B;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;;;;CAIF,CAAC;AAE/B,iEAAiE;AACjE,eAAO,MAAM,cAAc,aAAa,CAAC;AAEzC,+EAA+E;AAC/E,eAAO,MAAM,aAAa,YAAY,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,iBAAiB,CAAC;AAExD,wBAAwB;AACxB,eAAO,MAAM,wBAAwB,uBAAuB,CAAC;AAE7D,yBAAyB;AACzB,eAAO,MAAM,yBAAyB,wBAAwB,CAAC;AAE/D,kCAAkC;AAClC,eAAO,MAAM,2BAA2B,0BAA0B,CAAC;AAEnE,iCAAiC;AACjC,eAAO,MAAM,yBAAyB,wBAAwB,CAAC;AAE/D,yBAAyB;AACzB,eAAO,MAAM,yBAAyB,wBAAwB,CAAC;AAE/D,yEAAyE;AACzE,eAAO,MAAM,4BAA4B,2BAA2B,CAAC;AAErE;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,4BAA4B,CAAC;AAExD;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B,QAAc,CAAC;AAE1D;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,gBAAgB,CAAC;AAEpD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,gBAAgB,CAAC;AAEpD;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,kBAAkB,CAAC;AAExD;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,EAAE,aAAa,CAAC,MAAM,CAG1D,CAAC;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,EAAE,GAAwD,CAAC;AAEjG;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,iCAAiC,CAAC;AAE3E;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,kCAAkC,CAAC;AAE7E;;;;;;GAMG;AACH,eAAO,MAAM,kCAAkC,uCAAuC,CAAC;AAEvF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,6BAA6B,CAAC"}
+{"version":3,"file":"spine_surface_constants.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/spine_surface_constants.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA4B9B;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;;;;CAIF,CAAC;AAE/B;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,0RAW3B,CAAC;AAEX,8FAA8F;AAC9F,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9E,iEAAiE;AACjE,eAAO,MAAM,cAAc,aAAa,CAAC;AAEzC,+EAA+E;AAC/E,eAAO,MAAM,aAAa,YAAY,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,iBAAiB,CAAC;AAExD,wBAAwB;AACxB,eAAO,MAAM,wBAAwB,uBAAuB,CAAC;AAE7D,yBAAyB;AACzB,eAAO,MAAM,yBAAyB,wBAAwB,CAAC;AAE/D,kCAAkC;AAClC,eAAO,MAAM,2BAA2B,0BAA0B,CAAC;AAEnE,iCAAiC;AACjC,eAAO,MAAM,yBAAyB,wBAAwB,CAAC;AAE/D,yBAAyB;AACzB,eAAO,MAAM,yBAAyB,wBAAwB,CAAC;AAE/D,yEAAyE;AACzE,eAAO,MAAM,4BAA4B,2BAA2B,CAAC;AAErE;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,4BAA4B,CAAC;AAExD;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B,QAAc,CAAC;AAE1D;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,gBAAgB,CAAC;AAEpD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,gBAAgB,CAAC;AAEpD;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,kBAAkB,CAAC;AAExD;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,EAAE,aAAa,CAAC,MAAM,CAG1D,CAAC;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,EAAE,GAAwD,CAAC;AAEjG;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,iCAAiC,CAAC;AAE3E;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,kCAAkC,CAAC;AAE7E;;;;;;GAMG;AACH,eAAO,MAAM,kCAAkC,uCAAuC,CAAC;AAEvF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,6BAA6B,CAAC"}

package/dist/testing/cross_backend/spine_surface_constants.js

@@ -13,6 +13,30 @@ export const TESTING_ACTION_AUTH = {
     actor: 'none',
     credential_types: ['daemon_token']
 };
+/**
+ * Every `_testing_*` backdoor the shipped cross suites know: the daemon-token
+ * actions a test binary may mount for the harness to drive. The one list a
+ * backend's `capabilities.testing_backdoors` declares from, the
+ * testing-backdoor suite probes, and `describe_spine_cross_suites` gates suites
+ * on. A consumer's own seams stay off it — the testing-backdoor suite takes
+ * those as `extra_methods`.
+ *
+ * `spine_surface_constants.testing_backdoors.test.ts` holds it to the `_testing_*` methods
+ * fuz_app's spine binary mounts, so an action added there fails until it is
+ * listed here.
+ */
+export const TESTING_BACKDOOR_METHODS = [
+    '_testing_reset',
+    '_testing_drain_effects',
+    '_testing_mint_session',
+    '_testing_put_fact',
+    '_testing_flood_notifications',
+    '_testing_schema_snapshot',
+    '_testing_migration_tracker',
+    '_testing_action_manifest',
+    '_testing_origin_check',
+    '_testing_shorten_credential_expiry'
+];
 /** RPC endpoint mount path — matches the binary's `/api/rpc`. */
 export const SPINE_RPC_PATH = '/api/rpc';
 /** Ungated WebSocket endpoint mount path — matches the binaries' `/api/ws`. */

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

@@ -9,38 +9,37 @@ export declare const SPACE_CELL_KIND = "space";
  */
 export declare const PARTICIPATION_ROLE = "participant";
 /**
- * A space `data.policy` mirroring the test ladder: gated `post` (moderated) +
+ * A space `policy` mirroring the test ladder: gated `post` (moderated) +
  * `react` (live) + `comment` (live), each on `PARTICIPATION_ROLE`. `comment`
  * exists so a suite can create a comment under a post (`root_id !==
  * parent_id`) and prove the policy resolves from the governing root (the
  * space), not the immediate parent. Shared by the gated-create and moderate
- * cross suites.
+ * cross suites, which pass it as a root's `cell_create` `policy`.
  */
 export declare const TEST_SPACE_POLICY: {
-    readonly policy: {
-        readonly post: {
-            readonly min_role: "participant";
-            readonly moderation_required: true;
-        };
-        readonly react: {
-            readonly min_role: "participant";
-            readonly moderation_required: false;
-        };
-        readonly comment: {
-            readonly min_role: "participant";
-            readonly moderation_required: false;
-        };
+    readonly post: {
+        readonly min_role: "participant";
+        readonly moderation_required: true;
+    };
+    readonly react: {
+        readonly min_role: "participant";
+        readonly moderation_required: false;
+    };
+    readonly comment: {
+        readonly min_role: "participant";
+        readonly moderation_required: false;
     };
 };
-/** A space's per-kind contribution rule (the shape stamped into `space.data.policy`). */
+/** A space's per-kind contribution rule (the shape of each `policy` entry). */
 export interface ContributionRule {
     min_role?: string;
     moderation_required?: boolean;
 }
 /**
- * The directory-model test authorizer — a **pure** function of the input (it
- * reads the governing root's policy off `input.root_data`, supplied by the
- * handler). Byte-equivalent with the Rust `TestCellGatedCreateAuthorize`.
+ * The directory-model test authorizer — `authorize` is a **pure** function of
+ * the input (it reads the governing root's policy off `input.root_policy`,
+ * supplied by the handler). Byte-equivalent with the Rust
+ * `TestCellGatedCreateAuthorize`.
  */
 export declare const test_cell_gated_create_authorize: CellCreateAuthorize;
 //# sourceMappingURL=test_cell_gated_create_authorize.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"test_cell_gated_create_authorize.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/test_cell_gated_create_authorize.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA4B9B,OAAO,KAAK,EACX,mBAAmB,EAGnB,MAAM,4BAA4B,CAAC;AAGpC,8EAA8E;AAC9E,eAAO,MAAM,eAAe,UAAU,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,gBAAyB,CAAC;AAEzD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;CAMpB,CAAC;AAEX,yFAAyF;AACzF,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAYD;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,EAAE,mBAsB9C,CAAC"}
+{"version":3,"file":"test_cell_gated_create_authorize.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/test_cell_gated_create_authorize.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAiC9B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAKtE,8EAA8E;AAC9E,eAAO,MAAM,eAAe,UAAU,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,gBAAyB,CAAC;AAEzD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;CAIpB,CAAC;AAEX,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAwBD;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,EAAE,mBA8B9C,CAAC"}