@fuzdev/fuz_app 0.82.0 → 0.84.0

package/dist/testing/CLAUDE.md

@@ -853,7 +853,8 @@ source of truth for wire-shape conformance.
 
 - `testing/cross_backend/capabilities.ts` — `BackendCapabilities` vocabulary
   (`bearer_auth` / `trusted_proxy` / `login_rate_limit` / `ws` / `sse` /
-  `cell_crud` / `cell_relations` / `account_lifecycle` / `fact_serving`),
+  `cell_crud` / `cell_relations` / `account_lifecycle` / `fact_serving` /
+  `ready`),
   `test_if(cond, name, fn)`
   for capability-gated cases, and `in_process_capabilities` preset. `cell_crud`
   gates the CRUD parity suite, `cell_relations` the relation / ACL / audit
@@ -866,7 +867,10 @@ source of truth for wire-shape conformance.
   gates `describe_fact_serving_cross_tests` (the cell-scoped per-reference +
   admin-only bare-hash fact-serving parity suite); like cells it stays off the
   declared surface and is `true` on every spine that mounts the serve routes +
-  the `_testing_put_fact` seeder.
+  the `_testing_put_fact` seeder. `ready` gates `describe_ready_cross_tests`
+  (anonymous `GET /ready` → `200 {ready: true}` on a clean spine bootstrap);
+  like cells/sse the `/ready` deploy gate stays off the declared surface, `true`
+  on every spine that live-mounts it over the shared `expected_schema.json`.
 
 ### `cross_backend/standard.ts` — `describe_standard_cross_process_tests`
 
@@ -1071,8 +1075,8 @@ in-process legs (plain `gro test`) are `src/test/auth/cell_crud_parity.db.test.t
 - `testing/cross_backend/backend_config.ts` — `BackendConfig` +
   `BackendBootstrapConfig` interfaces. Consumer factories
   (`deno_backend_config()`, `rust_backend_config()`,
-  `spine_stub_backend_config()`) produce these; fuz_app ships
-  `spine_stub_backend_config()` as a convenience preset for the non-domain
+  `rust_spine_stub_backend_config()`) produce these; fuz_app ships
+  `rust_spine_stub_backend_config()` as a convenience preset for the non-domain
   third spine consumer, but otherwise backend-specific paths and env are a
   consumer concern.
 - `testing/cross_backend/spawn_backend.ts` — `spawn_backend(config) => BackendHandle`.
@@ -1180,6 +1184,31 @@ in-process `auth/origin_parity.db.test.ts` + the cross-process
 Rust spine returned a plain-text body — now converged to the canonical TS
 `{error: "forbidden_origin"}` via `fuz_http::forbidden_origin_response()`.
 
+### Readiness probe parity — `cross_backend/ready.ts`
+
+`describe_ready_cross_tests({setup_test, capabilities, ready_path?})` — the
+imperative `/ready` deploy-gate suite: an anonymous, cookie-jar-free,
+no-Origin `GET /ready` → `200 {ready: true}` on a clean spine bootstrap (the
+deploy-poll shape a gate like zap uses). The `/ready` mechanism + its
+drift → `503` path are per-impl unit tests already (TS `db/schema_ready.ts`,
+Rust `fuz_db::schema_ready` / `fuz_http::ready`); this is the cross-impl
+success-path gate. Gated on `capabilities.ready`. Imperative (not a
+`conformance_table` row) because `/ready` is a public flat-REST route, not a
+JSON-RPC envelope, and the probe needs `fresh_transport({origin: null})` —
+the same reasons the sibling `cross_backend/origin.ts` suite is imperative.
+`$lib`-free; runs both legs (`cross_backend/ready_parity.db.test.ts` +
+`cross_backend/ready.cross.test.ts`).
+
+Both backends read the **same** committed
+`testing/cross_backend/expected_schema.json` (column-presence is engine-portable,
+so one fixture is the cross-impl contract): the TS spine via
+`create_spine_ready_route_spec` (an `import.meta.url` URL off `default_spine_surface.ts`),
+the Rust `testing_spine_stub` via the absolute path `rust_spine_stub_backend_config`
+passes through `FUZ_RUST_SPINE_STUB_EXPECTED_SCHEMA_PATH`. The fixture covers the full
+spine bootstrap (auth + cell + cell_history + fact) and is regenerated +
+drift-guarded by `src/test/cross_backend/spine_expected_schema.db.test.ts`
+(`UPDATE_SCHEMA_READY=1`, then `gro format`).
+
 ### Building a TS test-server binary — `testing_server_core.ts` + adapters
 
 The reusable shape for standing up a **spawnable TS** cross-process test
@@ -1191,7 +1220,7 @@ re-roll the serve / daemon-info / WS-attach / drain boilerplate:
 - `testing/cross_backend/testing_server_deno.ts` — `create_deno_testing_adapter()` (`Deno.serve` + `hono/deno`; `Deno` declared locally so it typechecks under the Node toolchain). Spawn the entry with `--sloppy-imports` (Deno doesn't do `.js`→`.ts`; Gro's loader does, so the Node path needs no flag).
 - `testing/cross_backend/testing_server_bun.ts` — `create_bun_testing_adapter()` (`Bun.serve` + `hono/bun`'s module-level `upgradeWebSocket` + `websocket`; `Bun.serve` declared locally so it typechecks under the Node toolchain). **No extra deps** (`hono/bun` ships with `hono`; `Bun.serve` is built in, unlike Node's `@hono/node-server` + `@hono/node-ws`), and Bun resolves `.js`→`.ts` natively (no flag, unlike Deno). Reuses `create_node_runtime` (Bun implements the `node:fs`/`node:process` surface). WS is module-level + stateless (like Deno) — the `websocket` handler is threaded into `serve`, where `Bun.serve` wants it, so no post-serve attach.
 - `testing/cross_backend/default_spine_surface.ts` — the canonical no-domain spine surface (account/admin/audit/signup + bootstrap): `spine_session_options`, `spine_roles`, `create_spine_route_specs`, `spine_rpc_endpoints`, `create_spine_surface_spec`. `$lib`-free (it's reached by the spawned binary under Gro's loader, which doesn't resolve `$lib`), so keep it on relative imports. Shared by the spine_stub cross test, the TS cross tests, and the binary.
-- `testing/cross_backend/ts_spine_backend_config.ts` — `ts_spine_node_backend_config()` / `ts_spine_deno_backend_config()` / `ts_spine_bun_backend_config()` presets (in-memory PGlite, no external infra), the TS analog of `spine_stub_backend_config()`.
+- `testing/cross_backend/ts_spine_backend_config.ts` — `ts_spine_node_backend_config()` / `ts_spine_deno_backend_config()` / `ts_spine_bun_backend_config()` presets (in-memory PGlite, no external infra), the TS analog of `rust_spine_stub_backend_config()`.
 
 fuz_app's own binary wiring (`src/test/cross_backend/testing_spine_server{,_node,_deno,_bun}.ts`) is the worked example: ~one `build_app` over `create_app_backend` + `create_app_server` + `_testing_reset` + a WS mount, reusing `default_spine_surface`. The `_node`/`_deno`/`_bun` entries differ only in which adapter they wire — `build_spine_app` is runtime-agnostic.
 
@@ -1234,7 +1263,7 @@ no stats engine reinvented. fuz_app ships the primitive; consumers wire
 scenarios + the run (zzz's `npm run benchmark:cross-impl` was the first).
 fuz_app also ships its **own** `npm run benchmark:cross-impl`
 (`src/benchmarks/cross_impl.bench.ts`) on the back of its TS spine binary —
-ts-node + ts-deno + ts-bun (+ the Rust `spine_stub` when `FUZ_TESTING_SPINE_STUB_BIN`
+ts-node + ts-deno + ts-bun (+ the Rust `spine_stub` when `FUZ_TESTING_RUST_SPINE_STUB_BIN`
 is set). The three TS runtimes are apples-to-apples with each other (same
 PGlite driver); TS-vs-Rust carries the PGlite-vs-Postgres DB-layer caveat
 (documented in the run). The artifact (`*.latest.json`) is gitignored.

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

@@ -6,10 +6,10 @@ import '../assert_dev_env.js';
  * env vars, bootstrap credentials, daemon-token discovery path, declared
  * capabilities. Consumer projects ship per-backend factories
  * (`deno_backend_config()`, `rust_backend_config()`,
- * `spine_stub_backend_config()`) that produce this shape; `spawn_backend`
+ * `rust_spine_stub_backend_config()`) that produce this shape; `spawn_backend`
  * consumes it.
  *
- * fuz_app ships `spine_stub_backend_config()` as a convenience preset
+ * fuz_app ships `rust_spine_stub_backend_config()` as a convenience preset
  * (operational dep on `testing_spine_stub` — path-based discovery, no
  * `package.json` coupling to the stub's source package). Otherwise backend-specific
  * knowledge (binary paths, port choices, env vars) is a consumer

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

@@ -76,6 +76,16 @@ export interface BackendCapabilities {
      * the serve routes stay off the standard declared surface.
      */
     readonly fact_serving: boolean;
+    /**
+     * The `/ready` readiness deploy gate (`GET /ready`) is live-mounted on the
+     * backend — the public column-presence schema-drift probe over the committed
+     * `expected_schema.json`. Gates `describe_ready_cross_tests` (anonymous
+     * `GET /ready` → `200 {ready: true}` on a clean spine bootstrap). Like
+     * ws/sse/cells, the route stays off the standard declared surface
+     * (`create_spine_surface_spec`); this flag opts a backend into the dedicated
+     * readiness parity coverage. The drift → `503` path stays per-impl unit tests.
+     */
+    readonly ready: boolean;
 }
 /**
  * Capability declarations for the in-process Hono transport. Every flag

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

@@ -1 +1 @@
-{"version":3,"file":"capabilities.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/capabilities.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAmB9B;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IACnC;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB;;;;;;;OAOG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC;;;;;;;;OAQG;IACH,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC;;;;;;;;OAQG;IACH,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;CAC/B;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAUpC,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,GAAI,MAAM,OAAO,EAAE,MAAM,MAAM,EAAE,IAAI,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,KAAG,IAMrF,CAAC"}
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/capabilities.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAmB9B;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IACnC;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB;;;;;;;OAOG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC;;;;;;;;OAQG;IACH,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC;;;;;;;;OAQG;IACH,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B;;;;;;;;OAQG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACxB;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAWpC,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,GAAI,MAAM,OAAO,EAAE,MAAM,MAAM,EAAE,IAAI,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,KAAG,IAMrF,CAAC"}

package/dist/testing/cross_backend/capabilities.js

@@ -30,6 +30,7 @@ export const in_process_capabilities = Object.freeze({
     cell_relations: true,
     account_lifecycle: true,
     fact_serving: true,
+    ready: true,
 });
 /**
  * Conditional `test()` wrapper — registers a vitest case only when

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;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"}
+{"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,mBAapC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,EAAE,mBAatC,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

@@ -17,6 +17,9 @@ export const ts_default_capabilities = Object.freeze({
     cell_relations: true,
     account_lifecycle: true,
     fact_serving: true,
+    // Off by default like `sse` — a generic TS consumer backend may not mount
+    // `/ready`. fuz_app's own spine configs (`ts_spine_*`) opt in.
+    ready: false,
 });
 /**
  * Capabilities for the Rust family. Adds `trusted_proxy: true` (the
@@ -34,6 +37,9 @@ export const rust_default_capabilities = Object.freeze({
     cell_relations: true,
     account_lifecycle: true,
     fact_serving: true,
+    // Off by default like `sse`; the spine-stub preset opts in (it mounts
+    // `/ready` over the env-supplied fixture path).
+    ready: false,
 });
 /** Bootstrap block built from the default secrets + supplied paths. */
 const build_default_bootstrap = (paths, overrides) => ({

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

@@ -1,4 +1,29 @@
 import '../assert_dev_env.js';
+/**
+ * Canonical no-domain spine surface — the standard fuz_app
+ * auth/account/admin/audit surface with no consumer domain layer on top.
+ *
+ * This is the single source of truth for "the standard spine surface",
+ * shared by:
+ *
+ * - the Rust `testing_spine_stub` cross-process self-tests (which build the
+ *   `AppSurfaceSpec` via `create_spine_surface_spec` and drive the binary's
+ *   wire shape),
+ * - the TS `testing_spine_server` cross-process binary (which feeds
+ *   `create_spine_route_specs` + `spine_rpc_endpoints` into a live
+ *   `create_app_server`), and
+ * - the `cross_backend_ts_*` self-test projects.
+ *
+ * **`$lib`-free by contract.** This module and everything it imports use
+ * relative specifiers (no `$lib` SvelteKit alias) so the spawned TS test
+ * binary — run under Gro's loader, which resolves `.js`→`.ts` and package
+ * imports but **not** the `$lib` alias — can import it transitively. Keep
+ * it that way: a `$lib` import anywhere in this graph breaks the binary
+ * spawn while still typechecking under vitest.
+ *
+ * @module
+ */
+import type { Logger } from '@fuzdev/fuz_util/log.js';
 import type { NotificationSender } from '../../auth/role_grant_offer_notifications.js';
 import { type RoleSchemaResult } from '../../auth/role_schema.js';
 import { type SessionOptions } from '../../auth/session_cookie.js';
@@ -84,6 +109,29 @@ export declare const spine_rpc_endpoints: (ctx: AppServerContext, options?: Spin
  * the stream at `SPINE_SSE_PATH`.
  */
 export declare const create_spine_route_specs: (ctx: AppServerContext) => Array<RouteSpec>;
+/**
+ * Committed expected-schema fixture for the spine `/ready` deploy gate — the
+ * column map a fresh full spine bootstrap (auth + cell + cell_history + fact)
+ * produces. Resolved relative to this module so the spawned TS binary (which
+ * imports this source under its loader) reads it off disk via `node:fs`.
+ * Regenerated + guarded by `src/test/cross_backend/spine_expected_schema.db.test.ts`.
+ *
+ * The Rust `testing_spine_stub` reads the **same** committed file (its absolute
+ * path passed via env by `rust_spine_stub_backend_config`) — column-presence is
+ * engine-portable, so one fixture is the cross-impl contract.
+ */
+export declare const SPINE_EXPECTED_SCHEMA_URL: URL;
+/**
+ * The spine's `/ready` route spec — the column-presence schema-drift deploy
+ * gate, reading {@link SPINE_EXPECTED_SCHEMA_URL}. Mounted **live** by the TS
+ * spine binary (in `build_spine_app`) and the in-process readiness parity leg,
+ * but kept **off** the declared surface (`create_spine_surface_spec`) like the
+ * fact-serving / ws / sse behaviors — `describe_ready_cross_tests` (gated on
+ * `capabilities.ready`) is its explicit coverage, not the generic round-trip.
+ *
+ * @param log - optional logger for server-side drift diagnostics
+ */
+export declare const create_spine_ready_route_spec: (log?: Logger) => RouteSpec;
 /**
  * The `AppSurfaceSpec` for the standard spine surface — the wire-shape
  * source the cross-process round-trip + RPC-round-trip suites validate

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,KAAK,EAAC,kBAAkB,EAAC,MAAM,8CAA8C,CAAC;AACrF,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,oCAAoC,CAAC;AAGzE;;;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,+CAA+C;AAC/C,MAAM,WAAW,wBAAwB;IACxC;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAC;CACzD;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,GAC/B,KAAK,gBAAgB,EACrB,UAAU,wBAAwB,KAChC,KAAK,CAAC,eAAe,CAQvB,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"}
+{"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;AAE9B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAIpD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,8CAA8C,CAAC;AACrF,OAAO,EAAqB,KAAK,gBAAgB,EAAC,MAAM,2BAA2B,CAAC;AACpF,OAAO,EAAwB,KAAK,cAAc,EAAC,MAAM,8BAA8B,CAAC;AAIxF,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,oCAAoC,CAAC;AAGzE;;;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,+CAA+C;AAC/C,MAAM,WAAW,wBAAwB;IACxC;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAC;CACzD;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,GAC/B,KAAK,gBAAgB,EACrB,UAAU,wBAAwB,KAChC,KAAK,CAAC,eAAe,CAQvB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,GAAI,KAAK,gBAAgB,KAAG,KAAK,CAAC,SAAS,CAiB/E,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,EAAE,GAAwD,CAAC;AAEjG;;;;;;;;;GASG;AACH,eAAO,MAAM,6BAA6B,GAAI,MAAM,MAAM,KAAG,SAC6B,CAAC;AAE3F;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,QAAO,cAM1C,CAAC"}

package/dist/testing/cross_backend/default_spine_surface.js

@@ -1,34 +1,11 @@
 import '../assert_dev_env.js';
-/**
- * Canonical no-domain spine surface — the standard fuz_app
- * auth/account/admin/audit surface with no consumer domain layer on top.
- *
- * This is the single source of truth for "the standard spine surface",
- * shared by:
- *
- * - the Rust `testing_spine_stub` cross-process self-tests (which build the
- *   `AppSurfaceSpec` via `create_spine_surface_spec` and drive the binary's
- *   wire shape),
- * - the TS `testing_spine_server` cross-process binary (which feeds
- *   `create_spine_route_specs` + `spine_rpc_endpoints` into a live
- *   `create_app_server`), and
- * - the `cross_backend_ts_*` self-test projects.
- *
- * **`$lib`-free by contract.** This module and everything it imports use
- * relative specifiers (no `$lib` SvelteKit alias) so the spawned TS test
- * binary — run under Gro's loader, which resolves `.js`→`.ts` and package
- * imports but **not** the `$lib` alias — can import it transitively. Keep
- * it that way: a `$lib` import anywhere in this graph breaks the binary
- * spawn while still typechecking under vitest.
- *
- * @module
- */
 import { create_account_route_specs } from '../../auth/account_routes.js';
 import { create_audit_log_route_specs } from '../../auth/audit_log_routes.js';
 import { create_role_schema } from '../../auth/role_schema.js';
 import { create_session_config } from '../../auth/session_cookie.js';
 import { create_signup_route_specs } from '../../auth/signup_routes.js';
 import { create_standard_rpc_actions } from '../../auth/standard_rpc_actions.js';
+import { create_ready_route_spec, load_expected_schema } from '../../http/common_routes.js';
 import { prefix_route_specs } from '../../http/route_spec.js';
 import { create_test_app_surface_spec } from '../stubs.js';
 /**
@@ -114,6 +91,29 @@ export const create_spine_route_specs = (ctx) => [
         ? prefix_route_specs('/api/admin', create_audit_log_route_specs({ stream: ctx.audit_sse }))
         : []),
 ];
+/**
+ * Committed expected-schema fixture for the spine `/ready` deploy gate — the
+ * column map a fresh full spine bootstrap (auth + cell + cell_history + fact)
+ * produces. Resolved relative to this module so the spawned TS binary (which
+ * imports this source under its loader) reads it off disk via `node:fs`.
+ * Regenerated + guarded by `src/test/cross_backend/spine_expected_schema.db.test.ts`.
+ *
+ * The Rust `testing_spine_stub` reads the **same** committed file (its absolute
+ * path passed via env by `rust_spine_stub_backend_config`) — column-presence is
+ * engine-portable, so one fixture is the cross-impl contract.
+ */
+export const SPINE_EXPECTED_SCHEMA_URL = new URL('./expected_schema.json', import.meta.url);
+/**
+ * The spine's `/ready` route spec — the column-presence schema-drift deploy
+ * gate, reading {@link SPINE_EXPECTED_SCHEMA_URL}. Mounted **live** by the TS
+ * spine binary (in `build_spine_app`) and the in-process readiness parity leg,
+ * but kept **off** the declared surface (`create_spine_surface_spec`) like the
+ * fact-serving / ws / sse behaviors — `describe_ready_cross_tests` (gated on
+ * `capabilities.ready`) is its explicit coverage, not the generic round-trip.
+ *
+ * @param log - optional logger for server-side drift diagnostics
+ */
+export const create_spine_ready_route_spec = (log) => create_ready_route_spec({ expected: load_expected_schema(SPINE_EXPECTED_SCHEMA_URL), log });
 /**
  * The `AppSurfaceSpec` for the standard spine surface — the wire-shape
  * source the cross-process round-trip + RPC-round-trip suites validate

package/dist/testing/cross_backend/expected_schema.json

@@ -0,0 +1,113 @@
+{
+	"account": [
+		"created_at",
+		"created_by",
+		"deleted_at",
+		"deleted_by",
+		"email",
+		"email_verified",
+		"id",
+		"password_hash",
+		"updated_at",
+		"updated_by",
+		"username"
+	],
+	"actor": [
+		"account_id",
+		"created_at",
+		"deleted_at",
+		"deleted_by",
+		"id",
+		"name",
+		"updated_at",
+		"updated_by"
+	],
+	"api_token": [
+		"account_id",
+		"created_at",
+		"expires_at",
+		"id",
+		"last_used_at",
+		"last_used_ip",
+		"name",
+		"token_hash"
+	],
+	"app_settings": ["id", "open_signup", "updated_at", "updated_by"],
+	"audit_log": [
+		"account_id",
+		"actor_id",
+		"created_at",
+		"event_type",
+		"id",
+		"ip",
+		"metadata",
+		"outcome",
+		"seq",
+		"target_account_id",
+		"target_actor_id"
+	],
+	"auth_session": ["account_id", "created_at", "expires_at", "id", "last_seen_at"],
+	"bootstrap_lock": ["bootstrapped", "id"],
+	"cell": [
+		"created_at",
+		"created_by",
+		"data",
+		"deleted_at",
+		"id",
+		"path",
+		"refs",
+		"updated_at",
+		"updated_by",
+		"visibility"
+	],
+	"cell_field": ["created_at", "name", "source_id", "target_id"],
+	"cell_grant": [
+		"actor_id",
+		"cell_id",
+		"created_at",
+		"granted_by",
+		"id",
+		"level",
+		"role",
+		"scope_id"
+	],
+	"cell_history": ["action_id", "cell_id", "created_at", "fact_hash", "id"],
+	"cell_item": ["child_id", "created_at", "parent_id", "position"],
+	"fact": ["bytes", "content_type", "created_at", "external_url", "hash", "size"],
+	"fact_ref": ["source_hash", "target_hash"],
+	"invite": ["claimed_at", "claimed_by", "created_at", "created_by", "email", "id", "username"],
+	"memo": ["created_at", "fn_id", "input_hash", "output_hash"],
+	"role_grant": [
+		"actor_id",
+		"created_at",
+		"expires_at",
+		"granted_by",
+		"id",
+		"revoked_at",
+		"revoked_by",
+		"revoked_reason",
+		"role",
+		"scope_id",
+		"scope_kind",
+		"source_offer_id"
+	],
+	"role_grant_offer": [
+		"accepted_at",
+		"created_at",
+		"decline_reason",
+		"declined_at",
+		"expires_at",
+		"from_actor_id",
+		"id",
+		"message",
+		"resulting_role_grant_id",
+		"retracted_at",
+		"role",
+		"scope_id",
+		"scope_kind",
+		"superseded_at",
+		"to_account_id",
+		"to_actor_id"
+	],
+	"schema_version": ["applied_at", "name", "namespace", "sequence"]
+}

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

@@ -0,0 +1,14 @@
+import '../assert_dev_env.js';
+import { type BackendCapabilities } from './capabilities.js';
+import type { SetupTest } from './setup.js';
+/** Options for the readiness-probe parity suite. */
+export interface ReadyCrossTestOptions {
+    /** Per-test fixture-producing function (fresh keeper + db per call). */
+    readonly setup_test: SetupTest;
+    /** Backend capability declarations — the suite gates on `capabilities.ready`. */
+    readonly capabilities: BackendCapabilities;
+    /** Readiness probe path. Default `/ready`. */
+    readonly ready_path?: string;
+}
+export declare const describe_ready_cross_tests: (options: ReadyCrossTestOptions) => void;
+//# sourceMappingURL=ready.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ready.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/ready.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAiC9B,OAAO,EAAU,KAAK,mBAAmB,EAAC,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,YAAY,CAAC;AAE1C,oDAAoD;AACpD,MAAM,WAAW,qBAAqB;IACrC,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,iFAAiF;IACjF,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,8CAA8C;IAC9C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,eAAO,MAAM,0BAA0B,GAAI,SAAS,qBAAqB,KAAG,IAuB3E,CAAC"}

package/dist/testing/cross_backend/ready.js

@@ -0,0 +1,50 @@
+import '../assert_dev_env.js';
+/**
+ * Cross-backend parity suite for the `/ready` schema-drift deploy gate.
+ *
+ * The `/ready` mechanism already ships on both twins (TS `create_ready_route_spec`
+ * / `db/schema_ready.ts`; Rust `fuz_http::ready` / `fuz_db::schema_ready`), each
+ * with its own drift → `503` unit tests. This suite is the missing automated
+ * cross-impl gate: an anonymous `GET /ready` returns `200 {ready: true}` over
+ * real HTTP on **both** spine test servers, proving the success path is wire-
+ * identical and that both backends read the same committed `expected_schema.json`
+ * (column-presence is engine-portable, so one fixture is the cross-impl contract).
+ *
+ * `/ready` is a plain public REST route — not an RPC method, not one of the six
+ * REST auth routes — and it's deliberately **off** the declared spine surface
+ * (`create_spine_surface_spec`), like ws/sse/cells/fact-serving. So it needs a
+ * bespoke imperative suite (à la `origin.cross.test.ts`), gated on
+ * `capabilities.ready`, rather than a `conformance_table` row or generic
+ * round-trip enumeration. The drift → `503` path stays per-impl unit tests.
+ *
+ * Runs both legs via the shared `{setup_test, capabilities}` protocol: the
+ * in-process leg (`cross_backend/ready_parity.db.test.ts`, plain `gro test`) and
+ * the cross-process leg (`cross_backend/ready.cross.test.ts`, the TS spine
+ * binaries + Rust `testing_spine_stub` over real HTTP).
+ *
+ * `$lib`-free by contract (relative specifiers only), like the sibling
+ * cross-backend suites.
+ *
+ * @module
+ */
+import { describe, assert } from 'vitest';
+import { test_if } from './capabilities.js';
+export const describe_ready_cross_tests = (options) => {
+    const { setup_test, capabilities } = options;
+    const ready_path = options.ready_path ?? '/ready';
+    describe('readiness probe parity', () => {
+        test_if(capabilities.ready, 'anonymous GET /ready → 200 {ready: true} on a clean spine bootstrap', async () => {
+            const fixture = await setup_test();
+            // Anonymous deploy-poll shape: cookie-jar-free, no Origin, no auth.
+            // `/ready` is public and outside `/api`, so neither the session /
+            // bearer middleware nor the RPC dispatcher sits in the path — exactly
+            // how a deploy gate (zap) polls it post-deploy. A freshly bootstrapped
+            // spine covers the committed expected column map, so the drift check
+            // passes.
+            const res = await fixture.fresh_transport({ origin: null })(ready_path, { method: 'GET' });
+            assert.strictEqual(res.status, 200, 'a clean spine bootstrap must report ready');
+            const body = (await res.json().catch(() => undefined));
+            assert.strictEqual(body?.ready, true);
+        });
+    });
+};

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

@@ -0,0 +1,39 @@
+import '../assert_dev_env.js';
+import type { BackendConfig } from './backend_config.js';
+/** Env var naming the prebuilt `testing_spine_stub` binary. Required when `binary_path` is omitted. */
+export declare const RUST_SPINE_STUB_BIN_ENV = "FUZ_TESTING_RUST_SPINE_STUB_BIN";
+/**
+ * Env var the stub reads for the absolute path of the committed
+ * `expected_schema.json` its `/ready` gate introspects against. Pointed at the
+ * **same** fixture the TS spine reads ({@link SPINE_EXPECTED_SCHEMA_URL}) —
+ * column-presence is engine-portable, so one file is the cross-impl contract.
+ */
+export declare const RUST_SPINE_STUB_EXPECTED_SCHEMA_PATH_ENV = "FUZ_RUST_SPINE_STUB_EXPECTED_SCHEMA_PATH";
+/** Default listening port — slots beside zzz's 1175/1176; matches the binary's `DEFAULT_PORT`. */
+export declare const RUST_SPINE_STUB_DEFAULT_PORT = 1177;
+/** Default Postgres database — real PG (PGlite isn't reachable from `tokio-postgres`). */
+export declare const RUST_SPINE_STUB_DEFAULT_DATABASE_URL = "postgres://localhost/fuz_app_test_rust_spine_stub";
+export interface SpineStubBackendConfigOptions {
+    /** Listening port. Default `RUST_SPINE_STUB_DEFAULT_PORT`. */
+    readonly port?: number;
+    /** Postgres connection URL. Default `RUST_SPINE_STUB_DEFAULT_DATABASE_URL`. */
+    readonly database_url?: string;
+    /**
+     * Prebuilt binary path. Overrides the `FUZ_TESTING_RUST_SPINE_STUB_BIN` env
+     * var. When neither is set the preset throws.
+     */
+    readonly binary_path?: string;
+}
+/**
+ * Build the `BackendConfig` for `testing_spine_stub`. Resolves the binary
+ * from `options.binary_path` or `FUZ_TESTING_RUST_SPINE_STUB_BIN`; throws when
+ * neither is set so a missing build surfaces as a clear error rather than
+ * a confusing spawn failure. Reconciles the binary's env contract: port
+ * via `--port` (and `FUZ_RUST_SPINE_STUB_PORT`), daemon-token dir via
+ * `FUZ_RUST_SPINE_STUB_DIR` (anchored to `paths.root` so the written
+ * `{dir}/run/daemon_token` matches the path `spawn_backend` reads).
+ *
+ * @throws Error when no binary path is available.
+ */
+export declare const rust_spine_stub_backend_config: (options?: SpineStubBackendConfigOptions) => BackendConfig;
+//# sourceMappingURL=rust_spine_stub_backend_config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rust_spine_stub_backend_config.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/rust_spine_stub_backend_config.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAuC9B,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAQvD,uGAAuG;AACvG,eAAO,MAAM,uBAAuB,oCAAoC,CAAC;AAEzE;;;;;GAKG;AACH,eAAO,MAAM,wCAAwC,6CAA6C,CAAC;AAEnG,kGAAkG;AAClG,eAAO,MAAM,4BAA4B,OAAO,CAAC;AAEjD,0FAA0F;AAC1F,eAAO,MAAM,oCAAoC,sDACG,CAAC;AAErD,MAAM,WAAW,6BAA6B;IAC7C,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,+EAA+E;IAC/E,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,8BAA8B,GAC1C,UAAS,6BAAkC,KACzC,aA6CF,CAAC"}

package/dist/testing/cross_backend/rust_spine_stub_backend_config.js

@@ -0,0 +1,103 @@
+import '../assert_dev_env.js';
+/**
+ * Cross-process `BackendConfig` preset for the non-domain spine consumer,
+ * `testing_spine_stub` — a Rust binary that mounts only the spine surface
+ * (auth / account / admin / audit / role-grant offers) with no domain
+ * layer. fuz_app drives it from `src/test/cross_backend/*.cross.test.ts`
+ * to verify its TS spec against the Rust spine end-to-end with no domain
+ * implementation in the loop — drift becomes a fuz_app failure rather than
+ * a downstream consumer's failure with mixed signals.
+ *
+ * **Binary discovery — env-supplied, never hardcoded.** The binary lives
+ * in a sibling Rust workspace, not in fuz_app, so the preset never bakes a
+ * path in. `FUZ_TESTING_RUST_SPINE_STUB_BIN` (or the `binary_path` option) must
+ * point at a prebuilt binary; the preset throws a clear error when neither
+ * is set rather than guessing. Build once with
+ * `cargo build -p testing_spine_stub --release` and point the env var at
+ * the resulting `target/release/testing_spine_stub`; operators / CI cache
+ * the binary across runs for fast spawns.
+ *
+ * **Operator setup** — the target Postgres database must exist before the
+ * harness runs (the harness never issues `CREATE DATABASE`, to avoid
+ * forcing a `CREATEDB` grant on the test role):
+ *
+ * ```bash
+ * createdb fuz_app_test_rust_spine_stub 2>/dev/null || true
+ * ```
+ *
+ * The binary self-wipes the auth-namespace schema on every boot
+ * (`FUZ_TESTING_RESET_DB_ON_STARTUP=true`, set by the Rust-family builder),
+ * so no manual `DROP TABLE` between sessions is needed; per-test reset is
+ * the orthogonal `_testing_reset` RPC action `default_cross_process_setup`
+ * fires.
+ *
+ * @module
+ */
+import { fileURLToPath } from 'node:url';
+import { build_test_backend_paths } from './build_test_backend_paths.js';
+import { SPINE_EXPECTED_SCHEMA_URL } from './default_spine_surface.js';
+import { make_default_rust_backend_config, rust_default_capabilities, } from './default_backend_configs.js';
+/** Env var naming the prebuilt `testing_spine_stub` binary. Required when `binary_path` is omitted. */
+export const RUST_SPINE_STUB_BIN_ENV = 'FUZ_TESTING_RUST_SPINE_STUB_BIN';
+/**
+ * Env var the stub reads for the absolute path of the committed
+ * `expected_schema.json` its `/ready` gate introspects against. Pointed at the
+ * **same** fixture the TS spine reads ({@link SPINE_EXPECTED_SCHEMA_URL}) —
+ * column-presence is engine-portable, so one file is the cross-impl contract.
+ */
+export const RUST_SPINE_STUB_EXPECTED_SCHEMA_PATH_ENV = 'FUZ_RUST_SPINE_STUB_EXPECTED_SCHEMA_PATH';
+/** Default listening port — slots beside zzz's 1175/1176; matches the binary's `DEFAULT_PORT`. */
+export const RUST_SPINE_STUB_DEFAULT_PORT = 1177;
+/** Default Postgres database — real PG (PGlite isn't reachable from `tokio-postgres`). */
+export const RUST_SPINE_STUB_DEFAULT_DATABASE_URL = 'postgres://localhost/fuz_app_test_rust_spine_stub';
+/**
+ * Build the `BackendConfig` for `testing_spine_stub`. Resolves the binary
+ * from `options.binary_path` or `FUZ_TESTING_RUST_SPINE_STUB_BIN`; throws when
+ * neither is set so a missing build surfaces as a clear error rather than
+ * a confusing spawn failure. Reconciles the binary's env contract: port
+ * via `--port` (and `FUZ_RUST_SPINE_STUB_PORT`), daemon-token dir via
+ * `FUZ_RUST_SPINE_STUB_DIR` (anchored to `paths.root` so the written
+ * `{dir}/run/daemon_token` matches the path `spawn_backend` reads).
+ *
+ * @throws Error when no binary path is available.
+ */
+export const rust_spine_stub_backend_config = (options = {}) => {
+    const { port = RUST_SPINE_STUB_DEFAULT_PORT, database_url = RUST_SPINE_STUB_DEFAULT_DATABASE_URL, binary_path = process.env[RUST_SPINE_STUB_BIN_ENV], } = options;
+    if (!binary_path) {
+        throw new Error(`rust_spine_stub_backend_config: no binary path — set ${RUST_SPINE_STUB_BIN_ENV} to a prebuilt ` +
+            '`testing_spine_stub` binary (build it with `cargo build -p testing_spine_stub --release`) ' +
+            'or pass `binary_path`.');
+    }
+    const name = 'spine_stub';
+    const paths = build_test_backend_paths(name);
+    return make_default_rust_backend_config({
+        name,
+        port,
+        // `--port` is the binary's authoritative port input; the
+        // `FUZ_RUST_SPINE_STUB_PORT` env the builder also sets (via `port_env_var`)
+        // is the lower-precedence fallback — both carry the same value.
+        start_command: [binary_path, '--port', String(port)],
+        database_url,
+        // The stub serves `GET /api/admin/audit/stream` (the spine
+        // `fuz_realtime::SseRegistry` + audit listener), so it advertises `sse`
+        // like the TS spines — the cross-process SSE suite's three cases run. It
+        // also live-mounts `/ready` over the env-supplied fixture path, so it
+        // advertises `ready` for `describe_ready_cross_tests`.
+        capabilities: { ...rust_default_capabilities, sse: true, ready: true },
+        port_env_var: 'FUZ_RUST_SPINE_STUB_PORT',
+        rust_log: 'info,testing_spine_stub=info',
+        paths,
+        extra_env: {
+            // The binary writes its daemon-token JSON to
+            // `{FUZ_RUST_SPINE_STUB_DIR}/run/daemon_token`; anchoring the dir to
+            // `paths.root` makes that equal `paths.daemon_token_path`, which
+            // `spawn_backend` reads after the health probe.
+            FUZ_RUST_SPINE_STUB_DIR: paths.root,
+            // Absolute path to the committed spine `expected_schema.json` — the
+            // stub's `/ready` gate introspects the live DB against it. The SAME
+            // file the TS spine reads, so the two backends share one cross-impl
+            // contract.
+            [RUST_SPINE_STUB_EXPECTED_SCHEMA_PATH_ENV]: fileURLToPath(SPINE_EXPECTED_SCHEMA_URL),
+        },
+    });
+};

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

@@ -3,7 +3,7 @@ import '../assert_dev_env.js';
  * Cross-process `BackendConfig` presets for fuz_app's domain-free **TS**
  * spine test binary (`src/test/cross_backend/testing_spine_server_{node,deno,bun}.ts`).
  *
- * The TS analog of `spine_stub_backend_config` (which spawns the Rust spine):
+ * The TS analog of `rust_spine_stub_backend_config` (which spawns the Rust spine):
  * these spawn fuz_app's own TS impl over real HTTP with no domain layer, so
  * the `cross_backend_ts_node` / `cross_backend_ts_deno` / `cross_backend_ts_bun`
  * self-test projects verify fuz_app's wire path in its own repo across all