@fuzdev/fuz_app 0.103.0 → 0.105.0

package/dist/testing/cross_backend/actor_search.js

@@ -34,7 +34,7 @@ import '../assert_dev_env.js';
  * @module
  */
 import { describe, test, assert } from 'vitest';
-import { actor_search_action_spec, ERROR_ACTOR_SEARCH_SCOPE_REQUIRED, } from '../../auth/actor_search_action_specs.js';
+import { actor_search_action_spec, ERROR_ACTOR_SEARCH_SCOPE_REQUIRED } from '../../auth/actor_search_action_specs.js';
 import { SPINE_RPC_PATH } from './spine_surface_constants.js';
 /** Nil UUID — an unheld scope id (no actor holds a role_grant on it). */
 const NIL_UUID = '00000000-0000-0000-0000-000000000000';
@@ -49,7 +49,7 @@ export const describe_actor_search_cross_tests = (options) => {
             const res = await fixture.fresh_transport()(rpc_path, {
                 method: 'POST',
                 headers: { 'content-type': 'application/json' },
-                body: search_envelope({ query: 'a' }, 'anon-search'),
+                body: search_envelope({ query: 'a' }, 'anon-search')
             });
             assert.strictEqual(res.status, 401, 'unauthenticated actor_search must be refused');
         });
@@ -59,7 +59,7 @@ export const describe_actor_search_cross_tests = (options) => {
             const res = await fixture.fresh_transport()(rpc_path, {
                 method: 'POST',
                 headers: { ...account.create_session_headers(), 'content-type': 'application/json' },
-                body: search_envelope({ query: 'a' }, 'nonadmin-noscope'),
+                body: search_envelope({ query: 'a' }, 'nonadmin-noscope')
             });
             assert.strictEqual(res.status, 400, 'non-admin unbounded search must be rejected');
             const body = (await res.json());
@@ -71,7 +71,7 @@ export const describe_actor_search_cross_tests = (options) => {
             const res = await fixture.fresh_transport()(rpc_path, {
                 method: 'POST',
                 headers: { ...account.create_session_headers(), 'content-type': 'application/json' },
-                body: search_envelope({ query: 'a', scope_ids: [NIL_UUID] }, 'nonadmin-scope'),
+                body: search_envelope({ query: 'a', scope_ids: [NIL_UUID] }, 'nonadmin-scope')
             });
             assert.strictEqual(res.status, 200, 'non-admin with a scope filter is allowed');
             const body = (await res.json());
@@ -82,7 +82,7 @@ export const describe_actor_search_cross_tests = (options) => {
             const res = await fixture.transport(rpc_path, {
                 method: 'POST',
                 headers: { ...fixture.create_session_headers(), 'content-type': 'application/json' },
-                body: search_envelope({ query: 'a' }, 'admin-noscope'),
+                body: search_envelope({ query: 'a' }, 'admin-noscope')
             });
             assert.strictEqual(res.status, 200, 'admin unbounded search is allowed');
             const body = (await res.json());

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

@@ -1 +1 @@
-{"version":3,"file":"app_settings.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/app_settings.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAsC9B,OAAO,KAAK,EAAC,wBAAwB,EAAC,MAAM,YAAY,CAAC;AAGzD,qFAAqF;AACrF,MAAM,MAAM,2BAA2B,GAAG,wBAAwB,CAAC;AAiBnE,eAAO,MAAM,iCAAiC,GAAI,SAAS,2BAA2B,KAAG,IA8DxF,CAAC"}
+{"version":3,"file":"app_settings.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/app_settings.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAsC9B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAG3D,qFAAqF;AACrF,MAAM,MAAM,2BAA2B,GAAG,wBAAwB,CAAC;AAiBnE,eAAO,MAAM,iCAAiC,GAAI,SAAS,2BAA2B,KAAG,IA8DxF,CAAC"}

package/dist/testing/cross_backend/app_settings.js

@@ -43,7 +43,7 @@ const update_envelope = (open_signup, id) => JSON.stringify({
     jsonrpc: '2.0',
     method: app_settings_update_action_spec.method,
     params: { open_signup },
-    id,
+    id
 });
 export const describe_app_settings_cross_tests = (options) => {
     const { setup_test } = options;
@@ -54,13 +54,13 @@ export const describe_app_settings_cross_tests = (options) => {
             const enable = await fixture.transport(rpc_path, {
                 method: 'POST',
                 headers: { ...fixture.create_session_headers(), 'content-type': 'application/json' },
-                body: update_envelope(true, 'enable-open-signup'),
+                body: update_envelope(true, 'enable-open-signup')
             });
             assert.strictEqual(enable.status, 200, 'admin app_settings_update must succeed');
             const res = await fixture.fresh_transport()(SIGNUP_PATH, {
                 method: 'POST',
                 headers: { 'content-type': 'application/json' },
-                body: JSON.stringify({ username: 'open_signup_user', password: SIGNUP_PASSWORD }),
+                body: JSON.stringify({ username: 'open_signup_user', password: SIGNUP_PASSWORD })
             });
             assert.strictEqual(res.status, 200, 'open signup must admit an anonymous account');
             const body = (await res.json());
@@ -73,19 +73,19 @@ export const describe_app_settings_cross_tests = (options) => {
             const enable = await fixture.transport(rpc_path, {
                 method: 'POST',
                 headers: { ...fixture.create_session_headers(), 'content-type': 'application/json' },
-                body: update_envelope(true, 'enable-before-disable'),
+                body: update_envelope(true, 'enable-before-disable')
             });
             assert.strictEqual(enable.status, 200, 'admin app_settings_update (enable) must succeed');
             const disable = await fixture.transport(rpc_path, {
                 method: 'POST',
                 headers: { ...fixture.create_session_headers(), 'content-type': 'application/json' },
-                body: update_envelope(false, 'disable-open-signup'),
+                body: update_envelope(false, 'disable-open-signup')
             });
             assert.strictEqual(disable.status, 200, 'admin app_settings_update (disable) must succeed');
             const res = await fixture.fresh_transport()(SIGNUP_PATH, {
                 method: 'POST',
                 headers: { 'content-type': 'application/json' },
-                body: JSON.stringify({ username: 'closed_signup_user', password: SIGNUP_PASSWORD }),
+                body: JSON.stringify({ username: 'closed_signup_user', password: SIGNUP_PASSWORD })
             });
             assert.strictEqual(res.status, 403, 'closed signup must refuse a no-invite anonymous account');
             const body = (await res.json());

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

@@ -1 +1 @@
-{"version":3,"file":"backend_config.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/backend_config.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,mBAAmB,CAAC;AAE3D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,sBAAsB;IACtC,qFAAqF;IACrF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,4CAA4C;IAC5C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,4CAA4C;IAC5C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACnC;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,aAAa;IAC7B,sFAAsF;IACtF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oEAAoE;IACpE,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9C,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,yDAAyD;IACzD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,yDAAyD;IACzD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,+CAA+C;IAC/C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,6DAA6D;IAC7D,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC;;;;;;OAMG;IACH,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC/C,6DAA6D;IAC7D,QAAQ,CAAC,SAAS,EAAE,sBAAsB,CAAC;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;CAC3C"}
+{"version":3,"file":"backend_config.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/backend_config.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,sBAAsB;IACtC,qFAAqF;IACrF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,4CAA4C;IAC5C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,4CAA4C;IAC5C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACnC;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,aAAa;IAC7B,sFAAsF;IACtF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oEAAoE;IACpE,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9C,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,yDAAyD;IACzD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,yDAAyD;IACzD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,+CAA+C;IAC/C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,6DAA6D;IAC7D,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC;;;;;;OAMG;IACH,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC/C,6DAA6D;IAC7D,QAAQ,CAAC,SAAS,EAAE,sBAAsB,CAAC;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;CAC3C"}

package/dist/testing/cross_backend/bench/bench_report.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bench_report.d.ts","sourceRoot":"../src/lib/","sources":["../../../../src/lib/testing/cross_backend/bench/bench_report.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAC;AAGjC,OAAO,EAEN,KAAK,mBAAmB,EACxB,MAAM,qCAAqC,CAAC;AAE7C,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,2BAA2B,CAAC;AAEpE;;;;;;GAMG;AAEH,sFAAsF;AACtF,eAAO,MAAM,0BAA0B,GAAI,QAAQ,oBAAoB,KAAG,MAM3D,CAAC;AAEhB,iFAAiF;AACjF,MAAM,WAAW,wBAAwB;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,0DAA0D;IAC1D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,uCAAuC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;CACzC;AAED,MAAM,WAAW,uBAAuB;IACvC,wFAAwF;IACxF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAC9B,QAAQ,oBAAoB,EAC5B,UAAU,uBAAuB,KAC/B,KAAK,CAAC,wBAAwB,CAoBhC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,GACxC,SAAS,aAAa,CAAC,wBAAwB,CAAC,KAC9C,MAGU,CAAC;AAEd;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GAAI,QAAQ,oBAAoB,KAAG,MA4BpE,CAAC"}
+{"version":3,"file":"bench_report.d.ts","sourceRoot":"../src/lib/","sources":["../../../../src/lib/testing/cross_backend/bench/bench_report.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAC;AAGjC,OAAO,EAEN,KAAK,mBAAmB,EACxB,MAAM,qCAAqC,CAAC;AAE7C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEtE;;;;;;GAMG;AAEH,sFAAsF;AACtF,eAAO,MAAM,0BAA0B,GAAI,QAAQ,oBAAoB,KAAG,MAM3D,CAAC;AAEhB,iFAAiF;AACjF,MAAM,WAAW,wBAAwB;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,0DAA0D;IAC1D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,uCAAuC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;CACzC;AAED,MAAM,WAAW,uBAAuB;IACvC,wFAAwF;IACxF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAC9B,QAAQ,oBAAoB,EAC5B,UAAU,uBAAuB,KAC/B,KAAK,CAAC,wBAAwB,CAoBhC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,GACxC,SAAS,aAAa,CAAC,wBAAwB,CAAC,KAC9C,MAGU,CAAC;AAEd;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GAAI,QAAQ,oBAAoB,KAAG,MA4BpE,CAAC"}

package/dist/testing/cross_backend/bench/bench_report.js

@@ -1,6 +1,6 @@
 import '../../assert_dev_env.js';
 import { benchmark_format_markdown } from '@fuzdev/fuz_util/benchmark_format.ts';
-import { benchmark_stats_compare, } from '@fuzdev/fuz_util/benchmark_stats.ts';
+import { benchmark_stats_compare } from '@fuzdev/fuz_util/benchmark_stats.ts';
 /**
  * Reporting adapters over a `CrossImplBenchResult` — all built on fuz_util's
  * formatters + Welch comparison. Markdown for human eyeballs, a per-scenario
@@ -36,7 +36,7 @@ export const compare_cross_impl = (result, options) => {
                 scenario,
                 reference,
                 backend: e.backend,
-                comparison: benchmark_stats_compare(ref_entry.result.stats, e.result.stats),
+                comparison: benchmark_stats_compare(ref_entry.result.stats, e.result.stats)
             });
         }
     }
@@ -77,7 +77,7 @@ export const format_cross_impl_json = (result) => JSON.stringify({
             std_dev_ns: e.result.stats.std_dev_ns,
             ops_per_second: e.result.stats.ops_per_second,
             outlier_ratio: e.result.stats.outlier_ratio,
-            sample_size: e.result.stats.sample_size,
-        },
-    })),
+            sample_size: e.result.stats.sample_size
+        }
+    }))
 }, null, 2);

package/dist/testing/cross_backend/bench/run_cross_impl_bench.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run_cross_impl_bench.d.ts","sourceRoot":"../src/lib/","sources":["../../../../src/lib/testing/cross_backend/bench/run_cross_impl_bench.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAC;AAGjC,OAAO,KAAK,EAAC,eAAe,EAAE,eAAe,EAAC,MAAM,qCAAqC,CAAC;AAE1F,OAAO,KAAK,EAAC,yBAAyB,EAAC,MAAM,aAAa,CAAC;AAC3D,OAAO,KAAK,EAAC,aAAa,EAAuB,MAAM,eAAe,CAAC;AAEvE;;;;;;;;;;;;GAYG;AAEH,0DAA0D;AAC1D,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;CACjC;AAED,6DAA6D;AAC7D,MAAM,WAAW,oBAAoB;IACpC,iDAAiD;IACjD,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACzC,uDAAuD;IACvD,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,mBAAmB,CAAC,CAAC;CACrD;AAED,MAAM,WAAW,wBAAwB;IACxC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,yBAAyB,CAAC,CAAC;IAC3D,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,aAAa,CAAC,CAAC;IACjD,8DAA8D;IAC9D,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;CAC3C;AAeD,eAAO,MAAM,oBAAoB,GAChC,SAAS,wBAAwB,KAC/B,OAAO,CAAC,oBAAoB,CAwB9B,CAAC"}
+{"version":3,"file":"run_cross_impl_bench.d.ts","sourceRoot":"../src/lib/","sources":["../../../../src/lib/testing/cross_backend/bench/run_cross_impl_bench.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAC;AAGjC,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAE5F,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,eAAe,CAAC;AAEzE;;;;;;;;;;;;GAYG;AAEH,0DAA0D;AAC1D,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;CACjC;AAED,6DAA6D;AAC7D,MAAM,WAAW,oBAAoB;IACpC,iDAAiD;IACjD,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACzC,uDAAuD;IACvD,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,mBAAmB,CAAC,CAAC;CACrD;AAED,MAAM,WAAW,wBAAwB;IACxC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,yBAAyB,CAAC,CAAC;IAC3D,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,aAAa,CAAC,CAAC;IACjD,8DAA8D;IAC9D,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;CAC3C;AAeD,eAAO,MAAM,oBAAoB,GAChC,SAAS,wBAAwB,KAC/B,OAAO,CAAC,oBAAoB,CAwB9B,CAAC"}

package/dist/testing/cross_backend/bench/run_cross_impl_bench.js

@@ -10,7 +10,7 @@ const DEFAULT_BENCH_CONFIG = {
     warmup_iterations: 20,
     min_iterations: 100,
     duration_ms: 3000,
-    cooldown_ms: 100,
+    cooldown_ms: 100
 };
 export const run_cross_impl_bench = async (options) => {
     const config = { ...DEFAULT_BENCH_CONFIG, ...options.config };
@@ -19,7 +19,7 @@ export const run_cross_impl_bench = async (options) => {
         const ctx = {
             transport: handle.keeper_transport,
             rpc_path: handle.config.rpc_path,
-            capabilities: handle.config.capabilities,
+            capabilities: handle.config.capabilities
         };
         for (const scenario of options.scenarios) {
             if (scenario.requires && !scenario.requires(handle.config.capabilities))

package/dist/testing/cross_backend/bench/scenario.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scenario.d.ts","sourceRoot":"../src/lib/","sources":["../../../../src/lib/testing/cross_backend/bench/scenario.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAC;AAGjC,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,qCAAqC,CAAC;AACxE,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,oBAAoB,CAAC;AAE5D;;;;;;;;;GASG;AACH,MAAM,WAAW,oBAAoB;IACpC,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IACnC,4CAA4C;IAC5C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,iEAAiE;IACjE,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;CAC3C;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,YAAY,EAAE,mBAAmB,KAAK,OAAO,CAAC;IACnE,wDAAwD;IACxD,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3D;AAcD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB,EAAE,aAAa,CAAC,aAAa,CAIhE,CAAC"}
+{"version":3,"file":"scenario.d.ts","sourceRoot":"../src/lib/","sources":["../../../../src/lib/testing/cross_backend/bench/scenario.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAC;AAGjC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D;;;;;;;;;GASG;AACH,MAAM,WAAW,oBAAoB;IACpC,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IACnC,4CAA4C;IAC5C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,iEAAiE;IACjE,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;CAC3C;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,YAAY,EAAE,mBAAmB,KAAK,OAAO,CAAC;IACnE,wDAAwD;IACxD,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3D;AAcD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB,EAAE,aAAa,CAAC,aAAa,CAIhE,CAAC"}

package/dist/testing/cross_backend/bench/scenario.js

@@ -24,5 +24,5 @@ const rpc_scenario = (method, params) => async (ctx) => {
 export const default_bench_scenarios = [
     { name: 'account_verify', run: rpc_scenario('account_verify') },
     { name: 'account_session_list', run: rpc_scenario('account_session_list') },
-    { name: 'audit_log_list', run: rpc_scenario('audit_log_list', { limit: 20 }) },
+    { name: 'audit_log_list', run: rpc_scenario('audit_log_list', { limit: 20 }) }
 ];

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

@@ -1 +1 @@
-{"version":3,"file":"body_size.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/body_size.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA6D9B,OAAO,KAAK,EAAC,wBAAwB,EAAC,MAAM,YAAY,CAAC;AAGzD;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,GAAG,wBAAwB,CAAC;AAmDhE,eAAO,MAAM,8BAA8B,GAAI,SAAS,wBAAwB,KAAG,IA0ClF,CAAC"}
+{"version":3,"file":"body_size.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/body_size.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA6D9B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAG3D;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,GAAG,wBAAwB,CAAC;AAmDhE,eAAO,MAAM,8BAA8B,GAAI,SAAS,wBAAwB,KAAG,IA0ClF,CAAC"}

package/dist/testing/cross_backend/body_size.js

@@ -104,7 +104,7 @@ export const describe_body_size_cross_tests = (options) => {
     const post = (fixture, body) => fetch_retrying_once(fixture.transport, rpc_path, {
         method: 'POST',
         headers: { ...fixture.create_session_headers(), 'content-type': 'application/json' },
-        body,
+        body
     });
     describe('body-size limit parity', () => {
         test('over-limit POST (cap + 1) → 413 payload_too_large (refused before dispatch)', async () => {

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

@@ -1 +1 @@
-{"version":3,"file":"bootstrap_backend.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/bootstrap_backend.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAIvD,OAAO,KAAK,EAAC,yBAAyB,EAAC,MAAM,YAAY,CAAC;AAE1D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,GAC7B,QAAQ,aAAa,KACnB,OAAO,CAAC,yBAAyB,CAwBnC,CAAC"}
+{"version":3,"file":"bootstrap_backend.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/bootstrap_backend.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAE5D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,GAC7B,QAAQ,aAAa,KACnB,OAAO,CAAC,yBAAyB,CAwBnC,CAAC"}

package/dist/testing/cross_backend/bootstrap_backend.js

@@ -28,11 +28,11 @@ export const bootstrap_backend = async (config) => {
             keeper_daemon_transport: create_fetch_transport({
                 base_url: config.base_url,
                 initial_cookies: keeper.cookies,
-                origin: null,
+                origin: null
             }),
             keeper_account: keeper.account,
             keeper_actor: keeper.actor,
-            keeper_cookies: keeper.cookies,
+            keeper_cookies: keeper.cookies
         };
     }
     catch (err) {

package/dist/testing/cross_backend/build_test_backend_paths.js

@@ -28,6 +28,6 @@ export const build_test_backend_paths = (prefix) => {
         bootstrap_token_path: join(root, 'bootstrap_token'),
         // `init_daemon_token` (Rust) and the TS server's daemon-token
         // writer both land the token at `{root}/run/daemon_token`.
-        daemon_token_path: join(root, 'run', 'daemon_token'),
+        daemon_token_path: join(root, 'run', 'daemon_token')
     };
 };

package/dist/testing/cross_backend/capabilities.js

@@ -58,7 +58,7 @@ export const in_process_capabilities = Object.freeze({
     peer_request: false,
     // Cross-process-only: the test `CellCreateAuthorize` policy is mounted on the
     // spine binaries' full mount + the Rust stub, not the in-process default app.
-    cell_gated_create: false,
+    cell_gated_create: false
 });
 /**
  * Shape notes for the in-process Hono transport — every wiring fact present
@@ -68,7 +68,7 @@ export const in_process_capabilities = Object.freeze({
 export const in_process_shape_notes = Object.freeze({
     bearer_auth: true,
     trusted_proxy: true,
-    login_rate_limit: true,
+    login_rate_limit: true
 });
 /**
  * Conditional `test()` wrapper — registers a vitest case only when

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

@@ -1 +1 @@
-{"version":3,"file":"cell_cross_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/cell_cross_helpers.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAmB9B,OAAO,KAAK,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAG3B,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,kCAAkC,CAAC;AAErE,qEAAqE;AACrE,MAAM,WAAW,SAAS;IACzB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAC,CAAC;CAC5F;AAED;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAC1B,WAAW,cAAc,EACzB,MAAM,MAAM,EACZ,QAAQ,MAAM,EACd,QAAQ,OAAO,EACf,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAC7B,OAAO,CAAC,SAAS,CAMnB,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,YAAY,GAAI,GAAG,SAAS,KAAG,OAG/B,CAAC;AAEd;;;GAGG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,GAAG,SAAS,EAAE,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAG,CAUrE,CAAC"}
+{"version":3,"file":"cell_cross_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/cell_cross_helpers.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAmB9B,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAG7B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAEvE,qEAAqE;AACrE,MAAM,WAAW,SAAS;IACzB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CAC9F;AAED;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAC1B,WAAW,cAAc,EACzB,MAAM,MAAM,EACZ,QAAQ,MAAM,EACd,QAAQ,OAAO,EACf,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAC7B,OAAO,CAAC,SAAS,CAMnB,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,YAAY,GAAI,GAAG,SAAS,KAAG,OAG/B,CAAC;AAEd;;;GAGG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,GAAG,SAAS,EAAE,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAG,CAUrE,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"cell_crud.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/cell_crud.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA2D9B,OAAO,KAAK,EAAC,wBAAwB,EAAC,MAAM,YAAY,CAAC;AAGzD,eAAO,MAAM,8BAA8B,GAAI,SAAS,wBAAwB,KAAG,IAublF,CAAC"}
+{"version":3,"file":"cell_crud.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/cell_crud.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA2D9B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAG3D,eAAO,MAAM,8BAA8B,GAAI,SAAS,wBAAwB,KAAG,IAsclF,CAAC"}

package/dist/testing/cross_backend/cell_crud.js

@@ -45,7 +45,7 @@ import '../assert_dev_env.js';
  * @module
  */
 import { describe, assert } from 'vitest';
-import { CellCreateOutput, CellDeleteOutput, CellGetOutput, CellListOutput, CellUpdateOutput, } from '../../auth/cell_action_specs.js';
+import { CellCreateOutput, CellDeleteOutput, CellGetOutput, CellListOutput, CellUpdateOutput } from '../../auth/cell_action_specs.js';
 import { test_if } from './capabilities.js';
 import { cross_rpc_call, error_reason, expect_output } from './cell_cross_helpers.js';
 import { SPINE_RPC_PATH } from './spine_surface_constants.js';
@@ -102,7 +102,10 @@ export const describe_cell_crud_cross_tests = (options) => {
             const ref_b = `blake3:${'b'.repeat(64)}`;
             const ref_c = `blake3:${'c'.repeat(64)}`;
             const sorted = [ref_a, ref_b, ref_c];
-            const created = expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { kind: 'note', data: { cover: ref_c, nested: { attachments: [ref_b, ref_a, ref_b] } } }, owner_headers), CellCreateOutput);
+            const created = expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', {
+                kind: 'note',
+                data: { cover: ref_c, nested: { attachments: [ref_b, ref_a, ref_b] } }
+            }, owner_headers), CellCreateOutput);
             assert.deepStrictEqual(created.cell.refs, sorted, 'create did not return sorted refs');
             // Read it back — the stored column round-trips sorted too.
             const got = expect_output(await cross_rpc_call(t, rpc_path, 'cell_get', { id: created.cell.id }, owner_headers), CellGetOutput);

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

@@ -1,4 +1,28 @@
 import '../assert_dev_env.js';
 import type { RpcPathCrossSuiteOptions } from './setup.js';
 export declare const describe_cell_gated_create_cross_tests: (options: RpcPathCrossSuiteOptions) => void;
+/**
+ * Cross-backend parity for the **`cell_moderate` verb** (the `pending →
+ * approved | rejected` transition) — root-authority-gated.
+ *
+ * Builds a moderated public space (admin) + a `participant`'s `post` (born
+ * `pending` + private under the `moderation_required: true` policy), then
+ * proves both spines agree:
+ *
+ * - **a root manager (admin) approves** → `moderation: 'approved'` +
+ *   `visibility: 'public'` (the contribution goes live).
+ * - **the author cannot self-approve** → `403 cell_moderate_forbidden` (the
+ *   author can *view* their own pending cell, so they reach the gate, and are
+ *   denied — moderation authority is over the governing root, not the
+ *   contribution).
+ * - **a non-viewer is 404-masked** → a stranger who can't see the pending
+ *   contribution gets `cell_not_found`, never learns it exists.
+ * - **reject** → `moderation: 'rejected'`, visibility stays private.
+ *
+ * Gated on `capabilities.cell_gated_create` — a `pending` contribution only
+ * exists when the directory authorizer is mounted (reference spine binaries).
+ *
+ * `$lib`-free by contract (relative specifiers only).
+ */
+export declare const describe_cell_moderate_cross_tests: (options: RpcPathCrossSuiteOptions) => void;
 //# sourceMappingURL=cell_gated_create.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cell_gated_create.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/cell_gated_create.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAuC9B,OAAO,KAAK,EAAC,wBAAwB,EAAC,MAAM,YAAY,CAAC;AAIzD,eAAO,MAAM,sCAAsC,GAAI,SAAS,wBAAwB,KAAG,IAqF1F,CAAC"}
+{"version":3,"file":"cell_gated_create.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/cell_gated_create.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAiD9B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAkB3D,eAAO,MAAM,sCAAsC,GAAI,SAAS,wBAAwB,KAAG,IAwP1F,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,kCAAkC,GAAI,SAAS,wBAAwB,KAAG,IAwHtF,CAAC"}

package/dist/testing/cross_backend/cell_gated_create.js

@@ -1,25 +1,35 @@
 import '../assert_dev_env.js';
 /**
- * Cross-backend parity suite for the **cell-creation authorizer**
- * (`CellCreateAuthorize`).
+ * Cross-backend parity suite for the **parent-aware cell-creation authorizer**
+ * (`CellCreateAuthorize`) — the directory model.
  *
  * The authorizer adds no method, column, or wire shape, so the schema-snapshot
  * and action-manifest parity gates are **blind** to a TS↔Rust authorizer
- * divergence (the authorizer in the wrong phase, a different deny shape,
- * create-vs-update). This behavioral cross case is the only gate that catches
- * one — proven *here in fuz_app*, against both reference spines.
+ * divergence (the authorizer in the wrong phase, a different deny shape, the
+ * 404/403 split, the moderation outcome). This behavioral cross case is the
+ * only gate that catches one — proven *here in fuz_app*, against both reference
+ * spines.
  *
- * Both spines mount the same `test_cell_gated_create_authorize` policy (the
- * TS spine binary via `full_spine_mount`, the Rust `testing_spine_stub` via
- * `TestCellGatedCreateAuthorize`): creating a `kind: 'gated'` cell requires the
- * `participant` app-role or admin; every other kind (and a typeless cell) is
- * open. The suite asserts all three spines agree:
+ * Both spines mount the same directory-model policy (the TS spine binary via
+ * `create_test_cell_gated_create_authorize`, the Rust `testing_spine_stub` via
+ * `TestCellGatedCreateAuthorize`): admin bypasses; a non-admin creating a
+ * `kind: 'space'` **root** is denied (admin-only); a **contribution** under a
+ * space is gated by the space's `data.policy[kind] = {min_role, moderation_required}`,
+ * with the moderation outcome folded into the verdict; plain parentless creates
+ * stay open. The suite asserts all spines agree on:
  *
- * - **non-participant → gated kind is denied** with the `cell_not_found` 404
- *   IDOR mask (a gated kind is wire-indistinguishable from a missing resource).
- * - **non-participant → ungated kind succeeds** (the policy gates only `gated`).
- * - **participant → gated kind succeeds** (the role unlocks it).
- * - **admin → gated kind succeeds** (the admin bypass).
+ * - **root-create admin-only** — a non-admin `space` root → **403**
+ *   `cell_create_forbidden`; admin → succeeds.
+ * - **contribution gated by the root's policy** — under a public space, an
+ *   unauthorized stranger → **403**; a `participant` → succeeds.
+ * - **moderation per `moderation_required`** — a `participant`'s `post`
+ *   (`moderation_required: true`) is born `moderation: 'pending'` + private; a
+ *   `react` (`moderation_required: false`) is born `moderation: 'approved'` at
+ *   the author's visibility.
+ * - **404 on a hidden parent vs 403 on a visible one** — a contribution under a
+ *   **private** space the caller can't view → **404** `cell_not_found` (the
+ *   parent is masked); under a **public** space → **403** (you see it, you
+ *   can't contribute).
  *
  * Gated on `capabilities.cell_gated_create` — `true` only on the reference
  * spine binaries that mount the policy, so it skips for generic consumers and
@@ -31,41 +41,174 @@ import '../assert_dev_env.js';
  * @module
  */
 import { describe, assert } from 'vitest';
-import { CellCreateOutput } from '../../auth/cell_action_specs.js';
+import { CellCreateOutput, CellModerateOutput } from '../../auth/cell_action_specs.js';
 import { test_if } from './capabilities.js';
 import { cross_rpc_call, error_reason, expect_output } from './cell_cross_helpers.js';
 import { SPINE_RPC_PATH } from './spine_surface_constants.js';
-import { GATED_CELL_KIND, GATED_CELL_ROLE } from './test_cell_gated_create_authorize.js';
+import { SPACE_CELL_KIND, PARTICIPATION_ROLE } from './test_cell_gated_create_authorize.js';
+/**
+ * A space `data.policy` mirroring the test ladder: gated `post` (moderated) +
+ * `react` (live) + `comment` (live). `comment` exists so the deep-case test can
+ * create a comment under a post (`root_id !== parent_id`) and prove the policy
+ * resolves from the governing root (the space), not the immediate parent.
+ */
+const SPACE_POLICY = {
+    policy: {
+        post: { min_role: PARTICIPATION_ROLE, moderation_required: true },
+        react: { min_role: PARTICIPATION_ROLE, moderation_required: false },
+        comment: { min_role: PARTICIPATION_ROLE, moderation_required: false }
+    }
+};
 export const describe_cell_gated_create_cross_tests = (options) => {
     const { setup_test, capabilities } = options;
     const rpc_path = options.rpc_path ?? SPINE_RPC_PATH;
-    describe('cell_gated_create authorizer parity', () => {
-        test_if(capabilities.cell_gated_create, 'a non-participant is denied the gated kind (cell_not_found 404 IDOR mask)', async () => {
+    describe('cell_gated_create authorizer parity (directory model)', () => {
+        test_if(capabilities.cell_gated_create, 'a non-admin is denied a `space` root (admin-only), admin succeeds', async () => {
             const fixture = await setup_test();
-            const stranger = await fixture.create_account({ username: 'gated_stranger' });
-            const denied = await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: GATED_CELL_KIND, data: {} }, stranger.create_session_headers());
-            assert.ok(!denied.ok, 'a non-participant must not create the gated kind');
-            assert.strictEqual(error_reason(denied), 'cell_not_found');
+            const stranger = await fixture.create_account({ username: 'space_stranger' });
+            const denied = await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: SPACE_CELL_KIND, data: {} }, stranger.create_session_headers());
+            assert.ok(!denied.ok, 'a non-admin must not create a space root');
+            assert.strictEqual(error_reason(denied), 'cell_create_forbidden');
+            const space = expect_output(await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: SPACE_CELL_KIND, data: SPACE_POLICY, visibility: 'public' }, fixture.create_session_headers()), CellCreateOutput);
+            assert.strictEqual(space.cell.kind, SPACE_CELL_KIND, 'admin creates the space root');
+            assert.strictEqual(space.cell.parent_id, null, 'a root is parentless');
+            assert.strictEqual(space.cell.root_id, null, 'a root has no governing root');
+            assert.strictEqual(space.cell.moderation, null, 'a root carries no moderation marker even under a mounted authorizer (moderation is a contribution concept)');
         });
-        test_if(capabilities.cell_gated_create, 'a non-participant may create an ungated kind (the policy gates only `gated`)', async () => {
+        test_if(capabilities.cell_gated_create, 'a contribution under a public space: unauthorized → 403, participant → allowed', async () => {
             const fixture = await setup_test();
-            const stranger = await fixture.create_account({ username: 'ungated_stranger' });
-            const created = expect_output(await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: 'note', data: {} }, stranger.create_session_headers()), CellCreateOutput);
-            assert.strictEqual(created.cell.kind, 'note', 'the ungated cell keeps its kind');
+            const space = expect_output(await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: SPACE_CELL_KIND, data: SPACE_POLICY, visibility: 'public' }, fixture.create_session_headers()), CellCreateOutput);
+            // A non-participant sees the public space but can't contribute → 403.
+            const stranger = await fixture.create_account({ username: 'post_stranger' });
+            const forbidden = await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: 'post', data: {}, parent_id: space.cell.id }, stranger.create_session_headers());
+            assert.ok(!forbidden.ok, 'a non-participant must not post in the space');
+            assert.strictEqual(error_reason(forbidden), 'cell_create_forbidden');
+            // A participant may post; the contribution carries the directory edges.
+            const participant = await fixture.create_account({
+                username: 'post_participant',
+                roles: [PARTICIPATION_ROLE]
+            });
+            const post = expect_output(await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: 'post', data: {}, parent_id: space.cell.id }, participant.create_session_headers()), CellCreateOutput);
+            assert.strictEqual(post.cell.parent_id, space.cell.id, 'parent edge set');
+            assert.strictEqual(post.cell.root_id, space.cell.id, 'root resolved to the space');
         });
-        test_if(capabilities.cell_gated_create, 'a participant may create the gated kind', async () => {
+        test_if(capabilities.cell_gated_create, 'moderation is set per `moderation_required` (post → pending+private, react → approved)', async () => {
             const fixture = await setup_test();
+            const space = expect_output(await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: SPACE_CELL_KIND, data: SPACE_POLICY, visibility: 'public' }, fixture.create_session_headers()), CellCreateOutput);
             const participant = await fixture.create_account({
-                username: 'gated_participant',
-                roles: [GATED_CELL_ROLE],
+                username: 'mod_participant',
+                roles: [PARTICIPATION_ROLE]
             });
-            const created = expect_output(await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: GATED_CELL_KIND, data: {} }, participant.create_session_headers()), CellCreateOutput);
-            assert.strictEqual(created.cell.kind, GATED_CELL_KIND, 'the participant created the gated kind');
+            // `post` requires moderation → born pending + forced private.
+            const post = expect_output(await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: 'post', data: {}, parent_id: space.cell.id, visibility: 'public' }, participant.create_session_headers()), CellCreateOutput);
+            assert.strictEqual(post.cell.moderation, 'pending', 'gated post is born pending');
+            assert.strictEqual(post.cell.visibility, 'private', 'a pending contribution is forced private until approved');
+            // `react` does not require moderation → born approved at the author's visibility.
+            const react = expect_output(await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: 'react', data: {}, parent_id: space.cell.id, visibility: 'public' }, participant.create_session_headers()), CellCreateOutput);
+            assert.strictEqual(react.cell.moderation, 'approved', 'unmoderated kind is born approved');
+            assert.strictEqual(react.cell.visibility, 'public', "the author's visibility is honored");
+        });
+        test_if(capabilities.cell_gated_create, 'a contribution under a hidden (private) space is 404-masked (not 403)', async () => {
+            const fixture = await setup_test();
+            // A private space — only admin/owner can view it.
+            const space = expect_output(await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: SPACE_CELL_KIND, data: SPACE_POLICY, visibility: 'private' }, fixture.create_session_headers()), CellCreateOutput);
+            const stranger = await fixture.create_account({ username: 'hidden_stranger' });
+            const masked = await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: 'post', data: {}, parent_id: space.cell.id }, stranger.create_session_headers());
+            assert.ok(!masked.ok, 'a stranger must not contribute under a hidden space');
+            assert.strictEqual(error_reason(masked), 'cell_not_found', 'a hidden parent 404-masks the attempt (never reveals it exists)');
         });
-        test_if(capabilities.cell_gated_create, 'an admin (keeper) may create the gated kind (admin bypass)', async () => {
+        test_if(capabilities.cell_gated_create, 'a deep contribution (comment under a post) resolves policy from the governing root, not the parent', async () => {
             const fixture = await setup_test();
-            const created = expect_output(await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: GATED_CELL_KIND, data: {} }, fixture.create_session_headers()), CellCreateOutput);
-            assert.strictEqual(created.cell.kind, GATED_CELL_KIND, 'admin bypasses the gate');
+            const space = expect_output(await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: SPACE_CELL_KIND, data: SPACE_POLICY, visibility: 'public' }, fixture.create_session_headers()), CellCreateOutput);
+            const participant = await fixture.create_account({
+                username: 'deep_participant',
+                roles: [PARTICIPATION_ROLE]
+            });
+            // A post lives directly under the space — the shallow case
+            // (`root_id === parent_id`), so the handler reuses the parent row as
+            // `root_data`. The post is gated `moderation_required: true`, so it's
+            // born pending + private; the author can still view their own pending
+            // cell, so it's a valid parent for the comment below.
+            const post = expect_output(await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: 'post', data: {}, parent_id: space.cell.id }, participant.create_session_headers()), CellCreateOutput);
+            assert.strictEqual(post.cell.root_id, space.cell.id, 'a post roots at the space');
+            // A comment lives under the post — the DEEP case. Here
+            // `root_id !== parent_id`, so the handler must read the governing
+            // root (the space) *through* the post (the separate in-tx root read),
+            // and the authorizer must resolve `policy.comment` from the SPACE's
+            // data, not the post's. This is the only case that exercises the
+            // deep-read branch on both spines.
+            const comment = expect_output(await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: 'comment', data: {}, parent_id: post.cell.id }, participant.create_session_headers()), CellCreateOutput);
+            assert.strictEqual(comment.cell.parent_id, post.cell.id, 'the immediate parent is the post');
+            assert.strictEqual(comment.cell.root_id, space.cell.id, 'the governing root resolves to the space (deep read through the post), not the post');
+            assert.strictEqual(comment.cell.moderation, 'approved', 'the comment policy (moderation_required: false) resolved from the space, not the post');
+        });
+    });
+};
+/**
+ * Cross-backend parity for the **`cell_moderate` verb** (the `pending →
+ * approved | rejected` transition) — root-authority-gated.
+ *
+ * Builds a moderated public space (admin) + a `participant`'s `post` (born
+ * `pending` + private under the `moderation_required: true` policy), then
+ * proves both spines agree:
+ *
+ * - **a root manager (admin) approves** → `moderation: 'approved'` +
+ *   `visibility: 'public'` (the contribution goes live).
+ * - **the author cannot self-approve** → `403 cell_moderate_forbidden` (the
+ *   author can *view* their own pending cell, so they reach the gate, and are
+ *   denied — moderation authority is over the governing root, not the
+ *   contribution).
+ * - **a non-viewer is 404-masked** → a stranger who can't see the pending
+ *   contribution gets `cell_not_found`, never learns it exists.
+ * - **reject** → `moderation: 'rejected'`, visibility stays private.
+ *
+ * Gated on `capabilities.cell_gated_create` — a `pending` contribution only
+ * exists when the directory authorizer is mounted (reference spine binaries).
+ *
+ * `$lib`-free by contract (relative specifiers only).
+ */
+export const describe_cell_moderate_cross_tests = (options) => {
+    const { setup_test, capabilities } = options;
+    const rpc_path = options.rpc_path ?? SPINE_RPC_PATH;
+    // Build an admin-owned public space (moderated `post` policy) + a
+    // participant's pending post under it.
+    const setup_pending_post = async () => {
+        const fixture = await setup_test();
+        const space = expect_output(await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: SPACE_CELL_KIND, data: SPACE_POLICY, visibility: 'public' }, fixture.create_session_headers()), CellCreateOutput);
+        const author = await fixture.create_account({
+            username: 'moderate_author',
+            roles: [PARTICIPATION_ROLE]
+        });
+        const post = expect_output(await cross_rpc_call(fixture.transport, rpc_path, 'cell_create', { kind: 'post', data: {}, parent_id: space.cell.id }, author.create_session_headers()), CellCreateOutput);
+        return { fixture, author, post };
+    };
+    describe('cell_moderate verb parity (root-authority-gated)', () => {
+        test_if(capabilities.cell_gated_create, 'a root manager (admin) approves a pending post → approved + public', async () => {
+            const { fixture, post } = await setup_pending_post();
+            assert.strictEqual(post.cell.moderation, 'pending', 'the post is born pending');
+            const moderated = expect_output(await cross_rpc_call(fixture.transport, rpc_path, 'cell_moderate', { cell_id: post.cell.id, moderation: 'approved' }, fixture.create_session_headers() // keeper = admin = root manager
+            ), CellModerateOutput);
+            assert.strictEqual(moderated.cell.moderation, 'approved', 'approval sets the marker');
+            assert.strictEqual(moderated.cell.visibility, 'public', 'approval publishes the post');
+        });
+        test_if(capabilities.cell_gated_create, 'the author (non-manager) cannot moderate their own pending post → 403', async () => {
+            const { fixture, author, post } = await setup_pending_post();
+            const denied = await cross_rpc_call(fixture.transport, rpc_path, 'cell_moderate', { cell_id: post.cell.id, moderation: 'approved' }, author.create_session_headers());
+            assert.ok(!denied.ok, 'the author must not self-approve');
+            assert.strictEqual(error_reason(denied), 'cell_moderate_forbidden');
+        });
+        test_if(capabilities.cell_gated_create, 'a non-viewer is 404-masked from moderating a pending post', async () => {
+            const { fixture, post } = await setup_pending_post();
+            const stranger = await fixture.create_account({ username: 'moderate_stranger' });
+            const masked = await cross_rpc_call(fixture.transport, rpc_path, 'cell_moderate', { cell_id: post.cell.id, moderation: 'approved' }, stranger.create_session_headers());
+            assert.ok(!masked.ok, 'a non-viewer must not moderate');
+            assert.strictEqual(error_reason(masked), 'cell_not_found', 'a non-viewer never learns the pending post exists');
+        });
+        test_if(capabilities.cell_gated_create, 'a root manager rejects a pending post → rejected, stays private', async () => {
+            const { fixture, post } = await setup_pending_post();
+            const moderated = expect_output(await cross_rpc_call(fixture.transport, rpc_path, 'cell_moderate', { cell_id: post.cell.id, moderation: 'rejected' }, fixture.create_session_headers()), CellModerateOutput);
+            assert.strictEqual(moderated.cell.moderation, 'rejected', 'rejection sets the marker');
+            assert.strictEqual(moderated.cell.visibility, 'private', 'rejection leaves the post private');
         });
     });
 };

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

@@ -1 +1 @@
-{"version":3,"file":"cell_grant_role.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/cell_grant_role.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA8C9B,OAAO,KAAK,EAAC,wBAAwB,EAAC,MAAM,YAAY,CAAC;AAGzD,+EAA+E;AAC/E,eAAO,MAAM,gBAAgB,gBAAyB,CAAC;AAEvD,oFAAoF;AACpF,eAAO,MAAM,yBAAyB,qBAAqB,CAAC;AAK5D,eAAO,MAAM,oCAAoC,GAAI,SAAS,wBAAwB,KAAG,IAuIxF,CAAC"}
+{"version":3,"file":"cell_grant_role.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/cell_grant_role.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA8C9B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAG3D,+EAA+E;AAC/E,eAAO,MAAM,gBAAgB,gBAAyB,CAAC;AAEvD,oFAAoF;AACpF,eAAO,MAAM,yBAAyB,qBAAqB,CAAC;AAK5D,eAAO,MAAM,oCAAoC,GAAI,SAAS,wBAAwB,KAAG,IAuIxF,CAAC"}

package/dist/testing/cross_backend/cell_grant_role.js

@@ -35,7 +35,7 @@ import '../assert_dev_env.js';
  */
 import { describe, assert } from 'vitest';
 import { CellCreateOutput, CellGetOutput, CellUpdateOutput } from '../../auth/cell_action_specs.js';
-import { CellGrantCreateOutput, ERROR_CELL_GRANT_UNKNOWN_ROLE, } from '../../auth/cell_grant_action_specs.js';
+import { CellGrantCreateOutput, ERROR_CELL_GRANT_UNKNOWN_ROLE } from '../../auth/cell_grant_action_specs.js';
 import { test_if } from './capabilities.js';
 import { cross_rpc_call, error_reason, expect_output } from './cell_cross_helpers.js';
 import { SPINE_CELL_EDITOR_ROLE, SPINE_RPC_PATH } from './spine_surface_constants.js';
@@ -80,7 +80,7 @@ export const describe_cell_grant_role_cross_tests = (options) => {
             const denied = await cross_rpc_call(t, rpc_path, 'cell_grant_create', {
                 cell_id: created.cell.id,
                 level: 'viewer',
-                principal: { kind: 'role', role: UNREGISTERED_ROLE },
+                principal: { kind: 'role', role: UNREGISTERED_ROLE }
             }, owner_h);
             assert.ok(!denied.ok, 'granting an unregistered role must fail');
             assert.strictEqual(error_reason(denied), ERROR_CELL_GRANT_UNKNOWN_ROLE);