@fuzdev/fuz_app 0.83.0 → 0.84.0

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

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

@@ -1 +1 @@
-{"version":3,"file":"ts_spine_backend_config.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/ts_spine_backend_config.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAOvD,8GAA8G;AAC9G,eAAO,MAAM,gBAAgB,6BAA6B,CAAC;AAE3D;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,4BAA4B,CAAC;AAK3D,6FAA6F;AAC7F,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C,iDAAiD;AACjD,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C,gDAAgD;AAChD,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,wDAAwD,CAAC;AAEzF,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,wDAAwD,CAAC;AAEzF,wDAAwD;AACxD,eAAO,MAAM,kBAAkB,uDAAuD,CAAC;AAEvF,MAAM,WAAW,2BAA2B;IAC3C,mFAAmF;IACnF,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,8DAA8D;IAC9D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;;GAGG;AACH,eAAO,MAAM,4BAA4B,GACxC,UAAS,2BAAgC,KACvC,aAgBF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,GACvC,UAAS,2BAAgC,KACvC,aAgBF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B,GACxC,UAAS,2BAAgC,KACvC,aA6BF,CAAC"}
+{"version":3,"file":"ts_spine_backend_config.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/ts_spine_backend_config.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAOvD,8GAA8G;AAC9G,eAAO,MAAM,gBAAgB,6BAA6B,CAAC;AAE3D;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,4BAA4B,CAAC;AAS3D,6FAA6F;AAC7F,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C,iDAAiD;AACjD,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C,gDAAgD;AAChD,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,wDAAwD,CAAC;AAEzF,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,wDAAwD,CAAC;AAEzF,wDAAwD;AACxD,eAAO,MAAM,kBAAkB,uDAAuD,CAAC;AAEvF,MAAM,WAAW,2BAA2B;IAC3C,mFAAmF;IACnF,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,8DAA8D;IAC9D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;;GAGG;AACH,eAAO,MAAM,4BAA4B,GACxC,UAAS,2BAAgC,KACvC,aAgBF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,GACvC,UAAS,2BAAgC,KACvC,aAgBF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B,GACxC,UAAS,2BAAgC,KACvC,aA6BF,CAAC"}

package/dist/testing/cross_backend/ts_spine_backend_config.js

@@ -11,8 +11,12 @@ export const TS_SPINE_DIR_ENV = 'FUZ_TESTING_TS_SPINE_DIR';
  * the stream, so the shared `ts_default_capabilities` stays `sse: false`.
  */
 export const TS_SPINE_SSE_PATH = '/api/admin/audit/stream';
-/** Capabilities for the TS spine binary — `ts_default_capabilities` plus `sse` (the binary wires `audit_log_sse`). */
-const ts_spine_capabilities = Object.freeze({ ...ts_default_capabilities, sse: true });
+/**
+ * Capabilities for the TS spine binary — `ts_default_capabilities` plus `sse`
+ * (the binary wires `audit_log_sse`) and `ready` (the binary live-mounts the
+ * `/ready` deploy gate in `build_spine_app`).
+ */
+const ts_spine_capabilities = Object.freeze({ ...ts_default_capabilities, sse: true, ready: true });
 /** Default port for the Node TS spine binary — slots beside the Rust `spine_stub` (1177). */
 export const TS_SPINE_NODE_DEFAULT_PORT = 1178;
 /** Default port for the Deno TS spine binary. */

package/dist/testing/schema_ready_fixture.d.ts

@@ -0,0 +1,46 @@
+import './assert_dev_env.js';
+import type { Db } from '../db/db.js';
+import { type ExpectedSchema } from '../db/schema_ready.js';
+/** Options for `sync_expected_schema_fixture`. */
+export interface SyncExpectedSchemaFixtureOptions {
+    /** A bootstrapped DB — the consumer has run its full migration chain on it. */
+    db: Db;
+    /** Committed fixture location — an `import.meta.url`-relative URL or a path. */
+    fixture_url: URL | string;
+    /**
+     * When true, overwrite the fixture with the live column map instead of just
+     * reading it. Drive from an env flag (e.g. `UPDATE_SCHEMA_READY === '1'`).
+     */
+    update?: boolean;
+}
+/** The live column map and the committed fixture, for a `deepEqual` assertion. */
+export interface SyncExpectedSchemaFixtureResult {
+    /** Columns introspected from the live, freshly-bootstrapped DB. */
+    live: Record<string, Array<string>>;
+    /** The committed fixture (re-read after writing when `update`). */
+    committed: ExpectedSchema;
+}
+/**
+ * Introspect the live (bootstrapped) DB's columns, write them to the committed
+ * fixture when `update`, then read the committed fixture back. The caller
+ * asserts `deepEqual(live, committed)`:
+ *
+ * ```ts
+ * const {live, committed} = await sync_expected_schema_fixture({
+ *   db,
+ *   fixture_url: new URL('../../lib/server/expected_schema.json', import.meta.url),
+ *   update: process.env.UPDATE_SCHEMA_READY === '1',
+ * });
+ * assert.deepEqual(live, committed);
+ * ```
+ *
+ * When `update` writes the fixture it emits raw `JSON.stringify` (one array
+ * element per line); Prettier collapses short arrays inline, so run `gro format`
+ * after `UPDATE_SCHEMA_READY=1` before committing or the format check will flag
+ * the regenerated file. (The content is identical either way — the regen test
+ * compares values, not formatting.)
+ *
+ * @returns the live column map and the committed map (post-write when `update`)
+ */
+export declare const sync_expected_schema_fixture: (options: SyncExpectedSchemaFixtureOptions) => Promise<SyncExpectedSchemaFixtureResult>;
+//# sourceMappingURL=schema_ready_fixture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema_ready_fixture.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/schema_ready_fixture.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAmB7B,OAAO,KAAK,EAAC,EAAE,EAAC,MAAM,aAAa,CAAC;AACpC,OAAO,EAAuB,KAAK,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAEhF,kDAAkD;AAClD,MAAM,WAAW,gCAAgC;IAChD,+EAA+E;IAC/E,EAAE,EAAE,EAAE,CAAC;IACP,gFAAgF;IAChF,WAAW,EAAE,GAAG,GAAG,MAAM,CAAC;IAC1B;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,kFAAkF;AAClF,MAAM,WAAW,+BAA+B;IAC/C,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;IACpC,mEAAmE;IACnE,SAAS,EAAE,cAAc,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,4BAA4B,GACxC,SAAS,gCAAgC,KACvC,OAAO,CAAC,+BAA+B,CAQzC,CAAC"}