@fuzdev/fuz_app 0.102.0 → 0.104.0

package/dist/testing/cross_backend/cell_relations.js

@@ -100,9 +100,9 @@ export const describe_cell_relations_cross_tests = (options) => {
             const t = fixture.fresh_transport();
             const owner_h = owner.create_session_headers();
             const editor_h = editor.create_session_headers();
-            const cell = expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { data: { kind: 'note' } }, owner_h), CellCreateOutput).cell;
+            const cell = expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { kind: 'note', data: {} }, owner_h), CellCreateOutput).cell;
             // Before the grant the editor can't even see the private cell.
-            const pre = await cross_rpc_call(t, rpc_path, 'cell_update', { cell_id: cell.id, data: { kind: 'note', label: 'x' } }, editor_h);
+            const pre = await cross_rpc_call(t, rpc_path, 'cell_update', { cell_id: cell.id, data: { label: 'x' } }, editor_h);
             assert.ok(!pre.ok, 'non-grantee edited a private cell');
             assert.strictEqual(error_reason(pre), 'cell_not_found');
             // Owner (manage-tier) grants the editor an actor-shaped editor grant.
@@ -115,7 +115,7 @@ export const describe_cell_relations_cross_tests = (options) => {
             assert.strictEqual(grant.actor_id, editor.actor.id);
             assert.strictEqual(grant.role, null);
             // The editor can now edit content.
-            const edited = expect_output(await cross_rpc_call(t, rpc_path, 'cell_update', { cell_id: cell.id, data: { kind: 'note', label: 'by editor' } }, editor_h), CellUpdateOutput);
+            const edited = expect_output(await cross_rpc_call(t, rpc_path, 'cell_update', { cell_id: cell.id, data: { label: 'by editor' } }, editor_h), CellUpdateOutput);
             assert.strictEqual(edited.cell.updated_by, editor.actor.id);
             // grant_list is manage-tier: owner sees the grant.
             const owner_grants = expect_output(await cross_rpc_call(t, rpc_path, 'cell_grant_list', { cell_id: cell.id }, owner_h), CellGrantListOutput);
@@ -127,7 +127,7 @@ export const describe_cell_relations_cross_tests = (options) => {
             // Revoke and confirm the edit path is gone.
             const revoked = expect_output(await cross_rpc_call(t, rpc_path, 'cell_grant_revoke', { grant_id: grant.id }, owner_h), CellGrantRevokeOutput);
             assert.strictEqual(revoked.ok, true);
-            const post = await cross_rpc_call(t, rpc_path, 'cell_update', { cell_id: cell.id, data: { kind: 'note', label: 'y' } }, editor_h);
+            const post = await cross_rpc_call(t, rpc_path, 'cell_update', { cell_id: cell.id, data: { label: 'y' } }, editor_h);
             assert.ok(!post.ok, 'revoked editor still edited');
             assert.strictEqual(error_reason(post), 'cell_not_found');
         });
@@ -138,14 +138,14 @@ export const describe_cell_relations_cross_tests = (options) => {
             const t = fixture.fresh_transport();
             const owner_h = owner.create_session_headers();
             const editor_h = editor.create_session_headers();
-            const cell = expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { data: { kind: 'note' } }, owner_h), CellCreateOutput).cell;
+            const cell = expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { kind: 'note', data: {} }, owner_h), CellCreateOutput).cell;
             expect_output(await cross_rpc_call(t, rpc_path, 'cell_grant_create', {
                 cell_id: cell.id,
                 level: 'editor',
                 principal: { kind: 'actor', actor_id: editor.actor.id },
             }, owner_h), CellGrantCreateOutput);
             // Content edits pass (editor tier); a visibility write is manage-tier.
-            expect_output(await cross_rpc_call(t, rpc_path, 'cell_update', { cell_id: cell.id, data: { kind: 'note', label: 'ok' } }, editor_h), CellUpdateOutput);
+            expect_output(await cross_rpc_call(t, rpc_path, 'cell_update', { cell_id: cell.id, data: { label: 'ok' } }, editor_h), CellUpdateOutput);
             const vis = await cross_rpc_call(t, rpc_path, 'cell_update', { cell_id: cell.id, visibility: 'public' }, editor_h);
             assert.ok(!vis.ok, 'editor flipped visibility');
             assert.strictEqual(error_reason(vis), 'cell_visibility_manage_only');
@@ -155,8 +155,8 @@ export const describe_cell_relations_cross_tests = (options) => {
             const owner = await fixture.create_account({ username: 'cell_field_owner' });
             const t = fixture.fresh_transport();
             const h = owner.create_session_headers();
-            const source = expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { data: { kind: 'note' } }, h), CellCreateOutput).cell;
-            const target = expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { data: { kind: 'note' } }, h), CellCreateOutput).cell;
+            const source = expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { kind: 'note', data: {} }, h), CellCreateOutput).cell;
+            const target = expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { kind: 'note', data: {} }, h), CellCreateOutput).cell;
             const set = expect_output(await cross_rpc_call(t, rpc_path, 'cell_field_set', { source_id: source.id, name: 'cover', target_id: target.id }, h), CellFieldSetOutput);
             assert.strictEqual(set.field.name, 'cover');
             assert.strictEqual(set.field.source_id, source.id);
@@ -175,7 +175,7 @@ export const describe_cell_relations_cross_tests = (options) => {
             const owner = await fixture.create_account({ username: 'cell_item_owner' });
             const t = fixture.fresh_transport();
             const h = owner.create_session_headers();
-            const make = async () => expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { data: { kind: 'note' } }, h), CellCreateOutput).cell.id;
+            const make = async () => expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { kind: 'note', data: {} }, h), CellCreateOutput).cell.id;
             const parent = await make();
             const child_a = await make();
             const child_b = await make();
@@ -208,7 +208,7 @@ export const describe_cell_relations_cross_tests = (options) => {
             const owner = await fixture.create_account({ username: 'cell_clone_owner' });
             const t = fixture.fresh_transport();
             const h = owner.create_session_headers();
-            const make = async (label) => expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { data: { kind: 'note', ...(label === undefined ? {} : { label }) } }, h), CellCreateOutput).cell.id;
+            const make = async (label) => expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { kind: 'note', data: { ...(label === undefined ? {} : { label }) } }, h), CellCreateOutput).cell.id;
             const source = await make('orig');
             const child = await make('child');
             const field_target = await make('target');
@@ -244,9 +244,9 @@ export const describe_cell_relations_cross_tests = (options) => {
             const t = fixture.fresh_transport();
             const owner_h = owner.create_session_headers();
             const viewer_h = viewer.create_session_headers();
-            const cell = expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { data: { kind: 'note' } }, owner_h), CellCreateOutput).cell;
+            const cell = expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { kind: 'note', data: {} }, owner_h), CellCreateOutput).cell;
             // A mutation so the timeline has at least the create + update events.
-            expect_output(await cross_rpc_call(t, rpc_path, 'cell_update', { cell_id: cell.id, data: { kind: 'note', label: 'v2' } }, owner_h), CellUpdateOutput);
+            expect_output(await cross_rpc_call(t, rpc_path, 'cell_update', { cell_id: cell.id, data: { label: 'v2' } }, owner_h), CellUpdateOutput);
             // Owner (manage-tier) reads the timeline.
             const timeline = expect_output(await cross_rpc_call(t, rpc_path, 'cell_audit_list', { cell_id: cell.id }, owner_h), CellAuditListOutput);
             assert.ok(timeline.events.length > 0, 'owner audit timeline empty');
@@ -273,14 +273,16 @@ export const describe_cell_relations_cross_tests = (options) => {
             // items and fields. The private child is owned by `owner`, so only
             // `owner` (and admin) can view it.
             const parent = await create_cell(t, rpc_path, owner_h, {
-                data: { kind: 'collection' },
+                kind: 'collection',
+                data: {},
                 visibility: 'public',
             });
             const pub_child = await create_cell(t, rpc_path, owner_h, {
-                data: { kind: 'note' },
+                kind: 'note',
+                data: {},
                 visibility: 'public',
             });
-            const priv_child = await create_cell(t, rpc_path, owner_h, { data: { kind: 'note' } });
+            const priv_child = await create_cell(t, rpc_path, owner_h, { kind: 'note', data: {} });
             await wire_children(t, rpc_path, owner_h, parent, pub_child, priv_child);
             // Anonymous: only the public child surfaces in the bundle …
             const anon = fixture.fresh_transport({ origin: null });
@@ -301,9 +303,9 @@ export const describe_cell_relations_cross_tests = (options) => {
             const owner_h = owner.create_session_headers();
             const viewer_h = viewer.create_session_headers();
             // Private parent; one child the viewer will be granted, one they won't.
-            const parent = await create_cell(t, rpc_path, owner_h, { data: { kind: 'collection' } });
-            const shared_child = await create_cell(t, rpc_path, owner_h, { data: { kind: 'note' } });
-            const priv_child = await create_cell(t, rpc_path, owner_h, { data: { kind: 'note' } });
+            const parent = await create_cell(t, rpc_path, owner_h, { kind: 'collection', data: {} });
+            const shared_child = await create_cell(t, rpc_path, owner_h, { kind: 'note', data: {} });
+            const priv_child = await create_cell(t, rpc_path, owner_h, { kind: 'note', data: {} });
             await wire_children(t, rpc_path, owner_h, parent, shared_child, priv_child);
             // Grant the viewer on parent AND shared_child — but not priv_child.
             for (const cell_id of [parent, shared_child]) {
@@ -325,14 +327,16 @@ export const describe_cell_relations_cross_tests = (options) => {
             // The keeper holds [keeper, admin], so its headers are the admin probe.
             const admin_h = fixture.create_session_headers();
             const parent = await create_cell(t, rpc_path, owner_h, {
-                data: { kind: 'collection' },
+                kind: 'collection',
+                data: {},
                 visibility: 'public',
             });
             const pub_child = await create_cell(t, rpc_path, owner_h, {
-                data: { kind: 'note' },
+                kind: 'note',
+                data: {},
                 visibility: 'public',
             });
-            const priv_child = await create_cell(t, rpc_path, owner_h, { data: { kind: 'note' } });
+            const priv_child = await create_cell(t, rpc_path, owner_h, { kind: 'note', data: {} });
             await wire_children(t, rpc_path, owner_h, parent, pub_child, priv_child);
             // The cloner can read the public parent but not the private child.
             const clone = expect_output(await cross_rpc_call(t, rpc_path, 'cell_clone', { source_id: parent }, cloner_h), CellCloneOutput).cell;
@@ -362,14 +366,16 @@ export const describe_cell_relations_cross_tests = (options) => {
             const cloner_h = cloner.create_session_headers();
             const admin_h = fixture.create_session_headers();
             const parent = await create_cell(t, rpc_path, owner_h, {
-                data: { kind: 'collection' },
+                kind: 'collection',
+                data: {},
                 visibility: 'public',
             });
             const pub_child = await create_cell(t, rpc_path, owner_h, {
-                data: { kind: 'note' },
+                kind: 'note',
+                data: {},
                 visibility: 'public',
             });
-            const priv_child = await create_cell(t, rpc_path, owner_h, { data: { kind: 'note' } });
+            const priv_child = await create_cell(t, rpc_path, owner_h, { kind: 'note', data: {} });
             await wire_children(t, rpc_path, owner_h, parent, pub_child, priv_child);
             const clone = expect_output(await cross_rpc_call(t, rpc_path, 'cell_clone', { source_id: parent, deep: true }, cloner_h), CellCloneOutput).cell;
             // Deep clone copies viewable children into fresh cells; the

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAC,sBAAsB,EAAE,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAC/E,OAAO,KAAK,EAAC,mBAAmB,EAAE,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAC9E,OAAO,EAA2B,KAAK,gBAAgB,EAAC,MAAM,+BAA+B,CAAC;AAQ9F;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B,iCAAiC,CAAC;AAE3E;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAuBpC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,EAAE,mBAmBtC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EAAE,iBAInC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,EAAE,iBAIrC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAC,sBAAsB,EAAE,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAC/E,OAAO,KAAK,EAAC,mBAAmB,EAAE,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAC9E,OAAO,EAA2B,KAAK,gBAAgB,EAAC,MAAM,+BAA+B,CAAC;AAQ9F;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B,iCAAiC,CAAC;AAE3E;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBA2BpC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,EAAE,mBAsBtC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EAAE,iBAInC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,EAAE,iBAIrC,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

@@ -41,6 +41,10 @@ export const ts_default_capabilities = Object.freeze({
     // the HTTP RPC endpoint (the no-transport case). The TS spine config opts in;
     // a generic consumer enables it once it wires that mount.
     peer_request: false,
+    // Off by default — the `cell_gated_create` test policy is a fuz_app test
+    // fixture, mounted only on the spine binaries (`ts_spine_*`), not generic
+    // consumers.
+    cell_gated_create: false,
 });
 /**
  * Capabilities for the Rust family. The non-gating wiring facts live in
@@ -66,6 +70,9 @@ export const rust_default_capabilities = Object.freeze({
     // Server-initiated requests landed Rust-first canonical — the Rust spine
     // drives the `peer/ping` round-trip, so the family opts into the suite.
     peer_request: true,
+    // Off by default — the `testing_spine_stub` preset opts in (it mounts the
+    // `TestCellGatedCreateAuthorize` policy); a generic Rust consumer doesn't.
+    cell_gated_create: false,
 });
 /**
  * Shape notes for TS-family backends — wiring facts, not gating flags.

package/dist/testing/cross_backend/expected_schema.json

@@ -54,8 +54,12 @@
 		"data",
 		"deleted_at",
 		"id",
+		"kind",
+		"moderation",
+		"parent_id",
 		"path",
 		"refs",
+		"root_id",
 		"updated_at",
 		"updated_by",
 		"visibility"

package/dist/testing/cross_backend/fact_serving.js

@@ -80,8 +80,8 @@ export const describe_fact_serving_cross_tests = (options) => {
      * disambiguate or the authorization phase rejects with `actor_required`.
      */
     const create_cell_with_ref = async (transport, headers, hash, visibility, acting) => expect_output(await cross_rpc_call(transport, rpc_path, 'cell_create', acting === undefined
-        ? { data: { kind: 'doc', cover: hash }, visibility }
-        : { data: { kind: 'doc', cover: hash }, visibility, acting }, headers), CellCreateOutput).cell.id;
+        ? { kind: 'doc', data: { cover: hash }, visibility }
+        : { kind: 'doc', data: { cover: hash }, visibility, acting }, headers), CellCreateOutput).cell.id;
     const cell_fact_path = (cell_id, hash) => `/api/cells/${cell_id}/facts/${hash}`;
     describe('fact serving parity (cell-scoped per-reference reads)', () => {
         test_if(capabilities.fact_serving, 'cell-scoped admit: anon reads a fact through a public referencing cell', async () => {

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

@@ -1 +1 @@
-{"version":3,"file":"full_spine_mount.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/full_spine_mount.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,6BAA6B,CAAC;AAE3D,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,oBAAoB,CAAC;AAChD,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,4BAA4B,CAAC;AACjE,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,8CAA8C,CAAC;AAKrF,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,oCAAoC,CAAC;AAQzE,2FAA2F;AAC3F,MAAM,WAAW,qBAAqB;IACrC;;;;;;OAMG;IACH,QAAQ,CAAC,kBAAkB,EAAE,gBAAgB,CAAC;IAC9C;;;;OAIG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAC;CACzD;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,4BAA4B,GACxC,MAAM,OAAO,EACb,SAAS,qBAAqB,KAC5B,KAAK,CAAC,SAAS,CA0BjB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GACpC,KAAK,gBAAgB,EACrB,SAAS,qBAAqB,KAC5B,KAAK,CAAC,eAAe,CAEvB,CAAC"}
+{"version":3,"file":"full_spine_mount.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/full_spine_mount.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,6BAA6B,CAAC;AAE3D,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,oBAAoB,CAAC;AAChD,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,4BAA4B,CAAC;AACjE,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,8CAA8C,CAAC;AAKrF,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,oCAAoC,CAAC;AASzE,2FAA2F;AAC3F,MAAM,WAAW,qBAAqB;IACrC;;;;;;OAMG;IACH,QAAQ,CAAC,kBAAkB,EAAE,gBAAgB,CAAC;IAC9C;;;;OAIG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAC;CACzD;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,4BAA4B,GACxC,MAAM,OAAO,EACb,SAAS,qBAAqB,KAC5B,KAAK,CAAC,SAAS,CAoCjB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GACpC,KAAK,gBAAgB,EACrB,SAAS,qBAAqB,KAC5B,KAAK,CAAC,eAAe,CAEvB,CAAC"}

package/dist/testing/cross_backend/full_spine_mount.js

@@ -5,6 +5,7 @@ import { create_all_cell_actions } from '../../auth/all_cell_actions.js';
 import { create_actor_lookup_actions } from '../../auth/actor_lookup_actions.js';
 import { create_actor_search_actions } from '../../auth/actor_search_actions.js';
 import { create_testing_action_manifest_action, create_testing_actions, } from './testing_reset_actions.js';
+import { test_cell_gated_create_authorize } from './test_cell_gated_create_authorize.js';
 import { spine_roles, spine_session_options } from './default_spine_surface.js';
 import { SPINE_RPC_PATH } from './spine_surface_constants.js';
 /**
@@ -28,7 +29,14 @@ export const build_full_spine_rpc_actions = (deps, options) => {
             session_options: spine_session_options,
             daemon_token_state: options.daemon_token_state,
         }),
-        ...create_all_cell_actions(deps, { roles: spine_roles }),
+        // Mount the directory-model `cell_gated_create` test policy (twin of the
+        // Rust stub's `TestCellGatedCreateAuthorize`) so the cross-backend
+        // authorizer-parity suite has a known gate: `kind: 'space'` roots are
+        // admin-only, contributions are gated by the root's `data.policy`, and
+        // plain parentless creates stay open (the other cell suites are
+        // unaffected). The handler hands the governing root's `data` to the
+        // (pure) authorizer.
+        ...create_all_cell_actions({ ...deps, authorize_create: test_cell_gated_create_authorize }, { roles: spine_roles }),
         ...create_actor_lookup_actions(deps),
         ...create_actor_search_actions(deps),
         // `peer/ping` is mounted on the HTTP RPC endpoint too (not just WS) so an

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

@@ -1 +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;AASvD,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;IAC9B;;;;;;;OAOG;IACH,QAAQ,CAAC,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAC3C;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CAClC;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,8BAA8B,GAC1C,UAAS,6BAAkC,KACzC,aAiDF,CAAC"}
+{"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;AASvD,uGAAuG;AACvG,eAAO,MAAM,uBAAuB,oCAAoC,CAAC;AAEzE;;;;;GAKG;AACH,eAAO,MAAM,wCAAwC,6CAA6C,CAAC;AAkBnG,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;IAC9B;;;;;;;OAOG;IACH,QAAQ,CAAC,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAC3C;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CAClC;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,8BAA8B,GAC1C,UAAS,6BAAkC,KACzC,aAiDF,CAAC"}

package/dist/testing/cross_backend/rust_spine_stub_backend_config.js

@@ -49,14 +49,17 @@ export const RUST_SPINE_STUB_EXPECTED_SCHEMA_PATH_ENV = 'FUZ_RUST_SPINE_STUB_EXP
 /**
  * Capabilities for the Rust `testing_spine_stub` — `rust_default_capabilities`
  * plus `sse` (the stub serves `GET /api/admin/audit/stream` over the spine
- * `fuz_realtime::SseRegistry` + audit listener) and `ready` (it live-mounts
- * `/ready` over the env-supplied fixture path). Named (not inline) so every
- * spine preset is greppable, mirroring `ts_spine_capabilities`.
+ * `fuz_realtime::SseRegistry` + audit listener), `ready` (it live-mounts
+ * `/ready` over the env-supplied fixture path), and `cell_gated_create` (it
+ * mounts the `TestCellGatedCreateAuthorize` policy on its cell layer). Named
+ * (not inline) so every spine preset is greppable, mirroring
+ * `ts_spine_capabilities`.
  */
 const rust_spine_stub_capabilities = Object.freeze({
     ...rust_default_capabilities,
     sse: true,
     ready: true,
+    cell_gated_create: true,
 });
 /** Default listening port — slots beside zzz's 1175/1176; matches the binary's `DEFAULT_PORT`. */
 export const RUST_SPINE_STUB_DEFAULT_PORT = 1177;

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

@@ -0,0 +1,22 @@
+import '../assert_dev_env.js';
+import type { CellCreateAuthorize } from '../../auth/cell_actions.js';
+/** The admin-only root kind the test policy gates (talk's `space` analog). */
+export declare const SPACE_CELL_KIND = "space";
+/**
+ * The app-role a space policy references as `min_role` (besides admin) — the
+ * `participant` role both reference spines register. Mirrors the Rust policy's
+ * `"participant"` literal.
+ */
+export declare const PARTICIPATION_ROLE = "participant";
+/** A space's per-kind contribution rule (the shape stamped into `space.data.policy`). */
+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`.
+ */
+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

@@ -0,0 +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;AA+B9B,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,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,mBAoB9C,CAAC"}

package/dist/testing/cross_backend/test_cell_gated_create_authorize.js

@@ -0,0 +1,75 @@
+import '../assert_dev_env.js';
+/**
+ * Test `CellCreateAuthorize` policy mounted on **both** reference spines — the
+ * TS spine binary's full mount (`full_spine_mount.ts`) and the Rust
+ * `testing_spine_stub` — so the cross-backend `cell_gated_create` suite proves
+ * the parent-aware cell-creation authorizer agrees TS↔Rust. The twin of the
+ * Rust `TestCellGatedCreateAuthorize`, **directory model**.
+ *
+ * Admin bypasses everything (`{allow: true, moderation_required: false}`). For
+ * a non-admin:
+ *
+ * - **Root creation** (`root_id` null): `kind: 'space'` is admin-only (denied);
+ *   every other parentless kind stays open, so the plain-create `cell_crud` /
+ *   `cell_relations` suites are unaffected.
+ * - **Contribution** (`root_id` set): the governing root's
+ *   `data.policy[kind] = {min_role?, moderation_required?}` decides — a missing
+ *   entry denies, a present `min_role` the actor lacks denies, and otherwise it
+ *   admits with the entry's `moderation_required` folded into the verdict. The
+ *   root's `data` arrives in `input.root_data` (the handler read it in-tx), so
+ *   the predicate is **pure** — no DB read of its own (which also dodges the
+ *   single-connection PGlite deadlock a separate handle would hit).
+ *
+ * **`$lib`-free by contract** — reached by the spawned TS spine binary under
+ * Gro's loader (no `$lib` alias). Keep every import relative.
+ *
+ * @module
+ */
+import { has_role } from '../../auth/request_context.js';
+import { ROLE_ADMIN } from '../../auth/role_schema.js';
+import { SPINE_PARTICIPANT_ROLE } from './spine_surface_constants.js';
+/** The admin-only root kind the test policy gates (talk's `space` analog). */
+export const SPACE_CELL_KIND = 'space';
+/**
+ * The app-role a space policy references as `min_role` (besides admin) — the
+ * `participant` role both reference spines register. Mirrors the Rust policy's
+ * `"participant"` literal.
+ */
+export const PARTICIPATION_ROLE = SPINE_PARTICIPANT_ROLE;
+/** Pull the governing root's `data.policy[kind]` rule, defensively (loose `data`). */
+const get_contribution_rule = (data, kind) => {
+    if (data === null || typeof data !== 'object')
+        return undefined;
+    const policy = data.policy;
+    if (policy === null || typeof policy !== 'object')
+        return undefined;
+    const rule = policy[kind];
+    if (rule === null || typeof rule !== 'object')
+        return undefined;
+    return rule;
+};
+/**
+ * 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`.
+ */
+export const test_cell_gated_create_authorize = (auth, input) => {
+    // Admin bypass — admins create roots + any kind, live immediately.
+    if (has_role(auth, ROLE_ADMIN))
+        return { allow: true, moderation_required: false };
+    // Root creation (no governing root): `space` is admin-only; other parentless
+    // kinds stay open (the plain-create suites).
+    if (input.root_id === null) {
+        return input.kind === SPACE_CELL_KIND
+            ? { allow: false }
+            : { allow: true, moderation_required: false };
+    }
+    // Contribution: resolve the governing root's per-kind policy.
+    const rule = get_contribution_rule(input.root_data, input.kind ?? '');
+    if (!rule)
+        return { allow: false };
+    const admitted = rule.min_role === undefined || has_role(auth, rule.min_role);
+    return admitted
+        ? { allow: true, moderation_required: rule.moderation_required ?? false }
+        : { allow: false };
+};

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;AASvD,8GAA8G;AAC9G,eAAO,MAAM,gBAAgB,6BAA6B,CAAC;AA+B3D,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;IAC/B;;;;;;;;;OASG;IACH,QAAQ,CAAC,uBAAuB,CAAC,EAAE,OAAO,CAAC;CAC3C;AAWD;;;GAGG;AACH,eAAO,MAAM,4BAA4B,GACxC,UAAS,2BAAgC,KACvC,aAmBF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,GACvC,UAAS,2BAAgC,KACvC,aAmBF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B,GACxC,UAAS,2BAAgC,KACvC,aAgCF,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;AASvD,8GAA8G;AAC9G,eAAO,MAAM,gBAAgB,6BAA6B,CAAC;AAkC3D,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;IAC/B;;;;;;;;;OASG;IACH,QAAQ,CAAC,uBAAuB,CAAC,EAAE,OAAO,CAAC;CAC3C;AAWD;;;GAGG;AACH,eAAO,MAAM,4BAA4B,GACxC,UAAS,2BAAgC,KACvC,aAmBF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,GACvC,UAAS,2BAAgC,KACvC,aAmBF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B,GACxC,UAAS,2BAAgC,KACvC,aAgCF,CAAC"}

package/dist/testing/cross_backend/ts_spine_backend_config.js

@@ -7,14 +7,17 @@ export const TS_SPINE_DIR_ENV = 'FUZ_TESTING_TS_SPINE_DIR';
 /**
  * Capabilities for the TS spine binary — `ts_default_capabilities` plus `sse`
  * (the binary wires `audit_log_sse`), `ready` (the binary live-mounts the
- * `/ready` deploy gate in `build_spine_app`), and `peer_request` (the backend
- * WS transport's `request_connection` path drives server→client `peer/ping`).
+ * `/ready` deploy gate in `build_spine_app`), `peer_request` (the backend
+ * WS transport's `request_connection` path drives server→client `peer/ping`),
+ * and `cell_gated_create` (the binary's `full_spine_mount` mounts the
+ * `test_cell_gated_create_authorize` policy).
  */
 const ts_spine_capabilities = Object.freeze({
     ...ts_default_capabilities,
     sse: true,
     ready: true,
     peer_request: true,
+    cell_gated_create: true,
 });
 /**
  * Capabilities for the **Bun** spine binary — `ts_spine_capabilities` with

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzdev/fuz_app",
-  "version": "0.102.0",
+  "version": "0.104.0",
   "description": "fullstack app library",
   "glyph": "🗝",
   "logo": "logo.svg",