@fuzdev/fuz_app 0.103.0 → 0.105.0

package/dist/testing/cross_backend/setup.js

@@ -47,12 +47,12 @@ export const build_extra_account_fixture = (seeded, cookie_name) => ({
     session_cookie: seeded.session_cookie,
     create_session_headers: (extra) => ({
         cookie: `${cookie_name}=${seeded.session_cookie}`,
-        ...extra,
+        ...extra
     }),
     create_bearer_headers: (extra) => ({
         authorization: `Bearer ${seeded.api_token}`,
-        ...extra,
-    }),
+        ...extra
+    })
 });
 /**
  * Strip the non-serializable members so the result can be passed to
@@ -63,7 +63,7 @@ export const serialize_bootstrapped_handle = (handle) => ({
     daemon_token: handle.daemon_token,
     keeper_account: handle.keeper_account,
     keeper_actor: handle.keeper_actor,
-    keeper_cookies: [...handle.keeper_cookies],
+    keeper_cookies: [...handle.keeper_cookies]
 });
 /**
  * Rebuild a usable handle from the serialized subset. Synthesizes a
@@ -81,7 +81,7 @@ export const reconstruct_bootstrapped_handle = (serialized) => ({
     keeper_cookies: serialized.keeper_cookies,
     keeper_transport: create_fetch_transport({
         base_url: serialized.config.base_url,
-        initial_cookies: serialized.keeper_cookies,
+        initial_cookies: serialized.keeper_cookies
     }),
     // Same cookie jar but Origin-free so the daemon-token middleware doesn't
     // discard the credential as browser-context — used by the `_testing_*`
@@ -90,8 +90,8 @@ export const reconstruct_bootstrapped_handle = (serialized) => ({
     keeper_daemon_transport: create_fetch_transport({
         base_url: serialized.config.base_url,
         initial_cookies: serialized.keeper_cookies,
-        origin: null,
-    }),
+        origin: null
+    })
 });
 /**
  * Structural subset of `SignupOutput` the runner cares about. Looser
@@ -101,12 +101,12 @@ export const reconstruct_bootstrapped_handle = (serialized) => ({
 const SignupResponseShape = z.object({
     ok: z.literal(true),
     account: z.object({ id: Uuid, username: z.string() }),
-    actor: z.object({ id: Uuid }),
+    actor: z.object({ id: Uuid })
 });
 /** Structural subset of `account_token_create`'s output. */
 const TokenCreateResponseShape = z.object({
     token: z.string(),
-    id: z.string(),
+    id: z.string()
 });
 /**
  * Per-test username generator for the *default* `fixture.create_account()`
@@ -148,7 +148,7 @@ const rpc_via_transport = async (transport, rpc_path, method, params, backend_na
     const response = await transport(rpc_path, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json', ...extra_headers },
-        body: JSON.stringify({ jsonrpc: '2.0', method, params, id: method }),
+        body: JSON.stringify({ jsonrpc: '2.0', method, params, id: method })
     });
     if (!response.ok) {
         const body = await response.text().catch(() => '<unreadable>');
@@ -238,9 +238,9 @@ const TestingResetResponseShape = z.object({
         account: z.object({ id: Uuid, username: z.string() }),
         actor: z.object({ id: Uuid }),
         api_token: z.string(),
-        session_cookie: z.string(),
+        session_cookie: z.string()
     })),
-    extra_actors: z.array(z.object({ id: Uuid, name: z.string() })),
+    extra_actors: z.array(z.object({ id: Uuid, name: z.string() }))
 });
 /**
  * Fire the `_testing_reset` RPC action over the keeper's daemon-token
@@ -255,9 +255,9 @@ const fire_testing_reset = async (handle, options) => {
         extra_accounts: (options.extra_accounts ?? []).map((spec) => ({
             username: spec.username,
             ...(spec.password_value !== undefined && { password_value: spec.password_value }),
-            roles: [...spec.roles],
+            roles: [...spec.roles]
         })),
-        extra_actors: [...(options.extra_actors ?? [])],
+        extra_actors: [...(options.extra_actors ?? [])]
     }, handle.config.name, { [DAEMON_TOKEN_HEADER]: handle.daemon_token });
     const parsed = TestingResetResponseShape.safeParse(raw);
     if (!parsed.success) {
@@ -268,10 +268,10 @@ const fire_testing_reset = async (handle, options) => {
             account: parsed.data.account,
             actor: parsed.data.actor,
             api_token: parsed.data.api_token,
-            session_cookie: parsed.data.session_cookie,
+            session_cookie: parsed.data.session_cookie
         },
         extra_accounts: parsed.data.extra_accounts,
-        extra_actors: parsed.data.extra_actors,
+        extra_actors: parsed.data.extra_actors
     };
 };
 /**
@@ -347,8 +347,8 @@ const mint_account = async (handle, options) => {
         body: JSON.stringify({
             username,
             password,
-            ...(options.email !== undefined && { email: options.email }),
-        }),
+            ...(options.email !== undefined && { email: options.email })
+        })
     });
     if (!signup_response.ok) {
         const body = await signup_response.text().catch(() => '<unreadable>');
@@ -362,7 +362,7 @@ const mint_account = async (handle, options) => {
     const login_response = await transport('/api/account/login', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ username, password }),
+        body: JSON.stringify({ username, password })
     });
     if (!login_response.ok) {
         const body = await login_response.text().catch(() => '<unreadable>');
@@ -381,7 +381,7 @@ const mint_account = async (handle, options) => {
         account: parsed.data.account,
         actor: parsed.data.actor,
         session_cookie: extract_cookie_value(transport, handle.config.cookie_name, handle.config.name),
-        api_token: token_parsed.data.token,
+        api_token: token_parsed.data.token
     };
 };
 /**
@@ -418,7 +418,7 @@ const grant_roles_via_offer_accept = async (handle, minted, roles) => {
  */
 const create_keeper_transport = (handle, cookie_name, session_cookie) => create_fetch_transport({
     base_url: handle.config.base_url,
-    initial_cookies: [`${cookie_name}=${session_cookie}`],
+    initial_cookies: [`${cookie_name}=${session_cookie}`]
 });
 /**
  * Origin-free twin of `create_keeper_transport` — same fresh keeper cookie
@@ -429,7 +429,7 @@ const create_keeper_transport = (handle, cookie_name, session_cookie) => create_
 const create_keeper_daemon_transport = (handle, cookie_name, session_cookie) => create_fetch_transport({
     base_url: handle.config.base_url,
     initial_cookies: [`${cookie_name}=${session_cookie}`],
-    origin: null,
+    origin: null
 });
 /**
  * Build a `SetupTest` against a spawned + bootstrapped backend.
@@ -460,10 +460,10 @@ export const default_cross_process_setup = (handle, options) => {
     const extra_actor_names = options?.extra_actors ?? [];
     const { cookie_name } = handle.config;
     return async () => {
-        const { keeper, extra_accounts: seeded_extras, extra_actors, } = await fire_testing_reset(handle, {
+        const { keeper, extra_accounts: seeded_extras, extra_actors } = await fire_testing_reset(handle, {
             extra_keeper_roles,
             extra_accounts: extra_account_specs,
-            extra_actors: extra_actor_names,
+            extra_actors: extra_actor_names
         });
         // Rebuild the keeper transport with the new session cookie — the
         // reset action wiped the `globalSetup` keeper's auth_session row,
@@ -482,27 +482,27 @@ export const default_cross_process_setup = (handle, options) => {
             keeper_daemon_transport,
             keeper_account: keeper.account,
             keeper_actor: keeper.actor,
-            keeper_cookies: [`${cookie_name}=${keeper.session_cookie}`],
+            keeper_cookies: [`${cookie_name}=${keeper.session_cookie}`]
         };
         const create_session_headers = (extra) => ({
             cookie: `${cookie_name}=${keeper.session_cookie}`,
-            ...extra,
+            ...extra
         });
         const create_bearer_headers = (extra) => ({
             authorization: `Bearer ${keeper.api_token}`,
-            ...extra,
+            ...extra
         });
         const create_daemon_token_headers = (extra) => ({
             [DAEMON_TOKEN_HEADER]: handle.daemon_token,
-            ...extra,
+            ...extra
         });
         const create_account = async (account_options) => {
             const other = await mint_account(refreshed_handle, {
                 ...(account_options?.username !== undefined && { username: account_options.username }),
                 ...(account_options?.password_value !== undefined && {
-                    password_value: account_options.password_value,
+                    password_value: account_options.password_value
                 }),
-                ...(account_options?.email !== undefined && { email: account_options.email }),
+                ...(account_options?.email !== undefined && { email: account_options.email })
             });
             if (account_options?.roles && account_options.roles.length > 0) {
                 await grant_roles_via_offer_accept(refreshed_handle, other, account_options.roles);
@@ -514,12 +514,12 @@ export const default_cross_process_setup = (handle, options) => {
                 api_token: other.api_token,
                 create_session_headers: (extra) => ({
                     cookie: `${cookie_name}=${other.session_cookie}`,
-                    ...extra,
+                    ...extra
                 }),
                 create_bearer_headers: (extra) => ({
                     authorization: `Bearer ${other.api_token}`,
-                    ...extra,
-                }),
+                    ...extra
+                })
             };
         };
         const extra_accounts = {};
@@ -537,13 +537,13 @@ export const default_cross_process_setup = (handle, options) => {
         // secondary's transport via `fixture.create_account()`.
         const transport = create_fetch_transport({
             base_url: handle.config.base_url,
-            initial_cookies: [`${cookie_name}=${keeper.session_cookie}`],
+            initial_cookies: [`${cookie_name}=${keeper.session_cookie}`]
         });
         return {
             transport,
             fresh_transport: (fresh_options) => create_fetch_transport({
                 base_url: handle.config.base_url,
-                ...(fresh_options?.origin !== undefined && { origin: fresh_options.origin }),
+                ...(fresh_options?.origin !== undefined && { origin: fresh_options.origin })
             }),
             account: keeper.account,
             actor: keeper.actor,
@@ -564,7 +564,7 @@ export const default_cross_process_setup = (handle, options) => {
                         `${JSON.stringify(raw)} (${parsed.error.message})`);
                 }
                 return `${cookie_name}=${parsed.data.session_cookie}`;
-            },
+            }
         };
     };
 };

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

@@ -1 +1 @@
-{"version":3,"file":"spawn_backend.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/spawn_backend.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAQ,KAAK,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAI5D,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAIvD,6EAA6E;AAC7E,MAAM,WAAW,aAAa;IAC7B,yFAAyF;IACzF,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AA4ID;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GAAU,QAAQ,aAAa,KAAG,OAAO,CAAC,aAAa,CAiHhF,CAAC"}
+{"version":3,"file":"spawn_backend.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/spawn_backend.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAS,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAI9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD,6EAA6E;AAC7E,MAAM,WAAW,aAAa;IAC7B,yFAAyF;IACzF,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AA4ID;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GAAU,QAAQ,aAAa,KAAG,OAAO,CAAC,aAAa,CAiHhF,CAAC"}

package/dist/testing/cross_backend/spawn_backend.js

@@ -168,7 +168,7 @@ export const spawn_backend = async (config) => {
         // Own process group so SIGTERM to the negative PID tears down the
         // binary's descendants too — Hono workers, PTY children, etc.
         detached: true,
-        stdio: ['ignore', 'pipe', 'pipe'],
+        stdio: ['ignore', 'pipe', 'pipe']
     });
     // Buffer stderr so a startup-time crash surfaces with context.
     const stderr_chunks = [];

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

@@ -1 +1 @@
-{"version":3,"file":"sse_round_trip.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/sse_round_trip.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA+D9B,OAAO,EAAC,KAAK,mBAAmB,EAAU,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,YAAY,CAAC;AAK1C,kEAAkE;AAClE,MAAM,WAAW,0BAA0B;IAC1C;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,wEAAwE;IACxE,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,6DAA6D;IAC7D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CACzB;AA0BD;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,GAAI,SAAS,0BAA0B,KAAG,IAqKtF,CAAC"}
+{"version":3,"file":"sse_round_trip.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/sse_round_trip.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA+D9B,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAK5C,kEAAkE;AAClE,MAAM,WAAW,0BAA0B;IAC1C;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,wEAAwE;IACxE,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,6DAA6D;IAC7D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CACzB;AA0BD;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,GAAI,SAAS,0BAA0B,KAAG,IAwKtF,CAAC"}

package/dist/testing/cross_backend/sse_round_trip.js

@@ -48,7 +48,7 @@ import '../assert_dev_env.js';
  * @module
  */
 import { assert, describe } from 'vitest';
-import { account_session_list_action_spec, account_session_revoke_action_spec, account_session_revoke_all_action_spec, } from '../../auth/account_action_specs.js';
+import { account_session_list_action_spec, account_session_revoke_action_spec, account_session_revoke_all_action_spec } from '../../auth/account_action_specs.js';
 import { admin_session_revoke_all_action_spec } from '../../auth/admin_action_specs.js';
 import { audit_log_event_specs } from '../../realtime/sse_auth_guard.js';
 import { SSE_CONNECTED_COMMENT } from '../../realtime/sse_constants.js';
@@ -87,7 +87,7 @@ export const describe_cross_process_sse_tests = (options) => {
                 base_url,
                 sse_path,
                 cookies: fixture.transport.cookies(),
-                origin,
+                origin
             });
             try {
                 const first = await sse.read_frame();
@@ -103,18 +103,21 @@ export const describe_cross_process_sse_tests = (options) => {
         // keeper (target ≠ subscriber, so the stream stays open).
         test_if(capabilities.sse && rpc_path !== undefined, 'broadcasts an audit event as a data frame', async () => {
             const fixture = await setup_test();
-            const secondary = await fixture.create_account({ username: 'sse_revoke_target', roles: [] });
+            const secondary = await fixture.create_account({
+                username: 'sse_revoke_target',
+                roles: []
+            });
             const sse = await create_sse_transport({
                 base_url,
                 sse_path,
                 cookies: fixture.transport.cookies(),
-                origin,
+                origin
             });
             try {
                 const first = await sse.read_frame();
                 assert.strictEqual(first + '\n\n', SSE_CONNECTED_COMMENT, 'first frame must be the connected comment');
                 const res = await fixture.transport(rpc_path, create_rpc_post_init(admin_session_revoke_all_action_spec.method, {
-                    account_id: secondary.account.id,
+                    account_id: secondary.account.id
                 }));
                 assert.strictEqual(res.status, 200, `admin_session_revoke_all RPC failed (status=${res.status})`);
                 const data_frame = await sse.read_frame();
@@ -132,7 +135,7 @@ export const describe_cross_process_sse_tests = (options) => {
                 base_url,
                 sse_path,
                 cookies: fixture.transport.cookies(),
-                origin,
+                origin
             });
             try {
                 const first = await sse.read_frame();
@@ -161,7 +164,7 @@ export const describe_cross_process_sse_tests = (options) => {
                 base_url,
                 sse_path,
                 cookies: fixture.transport.cookies(),
-                origin,
+                origin
             });
             try {
                 const first = await sse.read_frame();

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

@@ -1 +1 @@
-{"version":3,"file":"standard.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/standard.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAM1D,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,mBAAmB,CAAC;AAC3D,OAAO,KAAK,EAAC,SAAS,EAAE,WAAW,EAAC,MAAM,YAAY,CAAC;AAEvD;;;;;;GAMG;AACH,MAAM,WAAW,+BAA+B;IAC/C,2CAA2C;IAC3C,UAAU,EAAE,SAAS,CAAC;IACtB;;;OAGG;IACH,cAAc,EAAE,cAAc,CAAC;IAC/B,uCAAuC;IACvC,YAAY,EAAE,mBAAmB,CAAC;IAClC,uFAAuF;IACvF,eAAe,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IACxC;;;;;OAKG;IACH,aAAa,EAAE,uBAAuB,CAAC;IACvC;;;OAGG;IACH,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;;OAMG;IACH,sBAAsB,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACvC;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAC/F;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,GAAG,CAC1B,MAAM,EACN,CAAC,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAC,CAAC,CACjF,CAAC;CACF;AAED;;;;GAIG;AACH,eAAO,MAAM,qCAAqC,GACjD,SAAS,+BAA+B,KACtC,IAwCF,CAAC"}
+{"version":3,"file":"standard.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/standard.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAM5D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzD;;;;;;GAMG;AACH,MAAM,WAAW,+BAA+B;IAC/C,2CAA2C;IAC3C,UAAU,EAAE,SAAS,CAAC;IACtB;;;OAGG;IACH,cAAc,EAAE,cAAc,CAAC;IAC/B,uCAAuC;IACvC,YAAY,EAAE,mBAAmB,CAAC;IAClC,uFAAuF;IACvF,eAAe,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IACxC;;;;;OAKG;IACH,aAAa,EAAE,uBAAuB,CAAC;IACvC;;;OAGG;IACH,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;;OAMG;IACH,sBAAsB,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACvC;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAC/F;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,GAAG,CAC1B,MAAM,EACN,CAAC,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CACnF,CAAC;CACF;AAED;;;;GAIG;AACH,eAAO,MAAM,qCAAqC,GACjD,SAAS,+BAA+B,KACtC,IAwCF,CAAC"}

package/dist/testing/cross_backend/standard.js

@@ -16,14 +16,14 @@ export const describe_standard_cross_process_tests = (options) => {
         capabilities: options.capabilities,
         session_options: options.session_options,
         rpc_endpoints: options.rpc_endpoints,
-        error_coverage_min: options.error_coverage_min,
+        error_coverage_min: options.error_coverage_min
     });
     describe_round_trip_validation({
         setup_test: options.setup_test,
         surface_source: options.surface_source,
         capabilities: options.capabilities,
         skip_routes: options.round_trip_skip_routes,
-        success_fixtures: options.rest_success_fixtures,
+        success_fixtures: options.rest_success_fixtures
     });
     describe_rpc_round_trip_tests({
         setup_test: options.setup_test,
@@ -31,12 +31,12 @@ export const describe_standard_cross_process_tests = (options) => {
         capabilities: options.capabilities,
         session_options: options.session_options,
         rpc_endpoints: options.rpc_endpoints,
-        success_fixtures: options.rpc_success_fixtures,
+        success_fixtures: options.rpc_success_fixtures
     });
     describe_data_exposure_tests({
         setup_test: options.setup_test,
         surface_source: options.surface_source,
-        capabilities: options.capabilities,
+        capabilities: options.capabilities
     });
     if (options.roles) {
         describe_standard_admin_integration_tests({
@@ -46,7 +46,7 @@ export const describe_standard_cross_process_tests = (options) => {
             session_options: options.session_options,
             roles: options.roles,
             rpc_endpoints: options.rpc_endpoints,
-            admin_prefix: options.admin_prefix,
+            admin_prefix: options.admin_prefix
         });
     }
 };

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

@@ -1,17 +1,22 @@
 import '../assert_dev_env.js';
 import type { CellCreateAuthorize } from '../../auth/cell_actions.js';
-/** The single kind the test policy gates (shared with the driving suite). */
-export declare const GATED_CELL_KIND = "gated";
+/** The admin-only root kind the test policy gates (talk's `space` analog). */
+export declare const SPACE_CELL_KIND = "space";
 /**
- * The app-role that unlocks creating the gated kind (besides admin) — the
+ * 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 GATED_CELL_ROLE = "participant";
+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;
+}
 /**
- * Allow unless the cell's `kind` is `'gated'`, in which case the actor must
- * hold the `participant` role or be a (scope-agnostic) admin. Mirrors the Rust
- * `TestCellGatedCreateAuthorize` exactly.
+ * 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

@@ -1 +1 @@
-{"version":3,"file":"test_cell_gated_create_authorize.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/test_cell_gated_create_authorize.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAuB9B,OAAO,KAAK,EAAC,mBAAmB,EAA2B,MAAM,4BAA4B,CAAC;AAG9F,6EAA6E;AAC7E,eAAO,MAAM,eAAe,UAAU,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,eAAe,gBAAyB,CAAC;AAEtD;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,EAAE,mBAIiD,CAAC"}
+{"version":3,"file":"test_cell_gated_create_authorize.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/test_cell_gated_create_authorize.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;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

@@ -3,14 +3,22 @@ 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 cell-creation authorizer agrees TS↔Rust. The twin of the Rust
- * `TestCellGatedCreateAuthorize`.
+ * the parent-aware cell-creation authorizer agrees TS↔Rust. The twin of the
+ * Rust `TestCellGatedCreateAuthorize`, **directory model**.
  *
- * The policy gates exactly one kind: creating a `kind: 'gated'` cell requires
- * the `participant` app-role (registered on both spines, `grant_paths:
- * ['admin']`) or admin. Every other kind — and a typeless cell — is open, so
- * the existing cell suites (which use `note` / `collection` kinds) are
- * unaffected, exactly as on the Rust stub.
+ * 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.
@@ -20,17 +28,48 @@ import '../assert_dev_env.js';
 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 single kind the test policy gates (shared with the driving suite). */
-export const GATED_CELL_KIND = 'gated';
+/** The admin-only root kind the test policy gates (talk's `space` analog). */
+export const SPACE_CELL_KIND = 'space';
 /**
- * The app-role that unlocks creating the gated kind (besides admin) — the
+ * 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 GATED_CELL_ROLE = SPINE_PARTICIPANT_ROLE;
+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;
+};
 /**
- * Allow unless the cell's `kind` is `'gated'`, in which case the actor must
- * hold the `participant` role or be a (scope-agnostic) admin. Mirrors the Rust
- * `TestCellGatedCreateAuthorize` exactly.
+ * 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) => input.kind !== GATED_CELL_KIND || has_role(auth, GATED_CELL_ROLE) || has_role(auth, ROLE_ADMIN);
+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/testing_backdoor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing_backdoor.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_backdoor.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA2D9B,OAAO,KAAK,EAAC,wBAAwB,EAAc,MAAM,YAAY,CAAC;AAqEtE,kEAAkE;AAClE,MAAM,MAAM,+BAA+B,GAAG,wBAAwB,CAAC;AAEvE,eAAO,MAAM,qCAAqC,GACjD,SAAS,+BAA+B,KACtC,IAiCF,CAAC"}
+{"version":3,"file":"testing_backdoor.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_backdoor.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA2D9B,OAAO,KAAK,EAAE,wBAAwB,EAAe,MAAM,YAAY,CAAC;AAqExE,kEAAkE;AAClE,MAAM,MAAM,+BAA+B,GAAG,wBAAwB,CAAC;AAEvE,eAAO,MAAM,qCAAqC,GACjD,SAAS,+BAA+B,KACtC,IAiCF,CAAC"}

package/dist/testing/cross_backend/testing_backdoor.js

@@ -73,20 +73,20 @@ const backdoor_methods = [
     { method: '_testing_migration_tracker', params: {} },
     // The RPC-registry-dump read — input is an empty strict object, so `{}` is
     // valid and clears the 400 phase, reaching the credential gate like the rest.
-    { method: '_testing_action_manifest', params: {} },
+    { method: '_testing_action_manifest', params: {} }
 ];
 const principals = [
     {
         name: 'anonymous',
         status: 401,
         // Fresh jar so the keeper cookie (cross-process) can't leak in.
-        resolve: (f) => ({ transport: f.fresh_transport(), headers: {} }),
+        resolve: (f) => ({ transport: f.fresh_transport(), headers: {} })
     },
     {
         name: 'session',
         status: 403,
         reason: ERROR_CREDENTIAL_TYPE_REQUIRED,
-        resolve: (f) => ({ transport: f.transport, headers: f.create_session_headers() }),
+        resolve: (f) => ({ transport: f.transport, headers: f.create_session_headers() })
     },
     {
         name: 'bearer',
@@ -98,9 +98,9 @@ const principals = [
         resolve: (f) => ({
             transport: f.fresh_transport({ origin: null }),
             headers: f.create_bearer_headers(),
-            suppress_default_origin: true,
-        }),
-    },
+            suppress_default_origin: true
+        })
+    }
 ];
 export const describe_testing_backdoor_cross_tests = (options) => {
     const { setup_test } = options;
@@ -117,7 +117,7 @@ export const describe_testing_backdoor_cross_tests = (options) => {
                         method,
                         params,
                         headers,
-                        ...(suppress_default_origin && { suppress_default_origin: true }),
+                        ...(suppress_default_origin && { suppress_default_origin: true })
                     });
                     const label = `${method} ${principal.name}`;
                     assert.ok(!res.ok, `${label}: expected denial (${principal.status}) but the call succeeded`);

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

@@ -1 +1 @@
-{"version":3,"file":"testing_reset_actions.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_reset_actions.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AAEH,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAItB,OAAO,EAAa,KAAK,SAAS,EAAC,MAAM,6BAA6B,CAAC;AAKvE,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,oBAAoB,CAAC;AAChD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,4BAA4B,CAAC;AACjE,OAAO,KAAK,EAAC,EAAE,EAAC,MAAM,gBAAgB,CAAC;AAqCvC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;QAiBpC;;;;;;;;WAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWyC,CAAC;AAE/C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;CAWA,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;CAwBC,CAAC;AAE/C;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC,QAAO,SACiB,CAAC;AAEzE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;CAeK,CAAC;AAE/C;;;;;;;;;GASG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWF,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,qCAAqC,QAAO,SAGvD,CAAC;AAEH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;CAYJ,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,uCAAuC,QAAO,SAGzD,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYF,CAAC;AAyB/C,eAAO,MAAM,qCAAqC,GACjD,SAAS,aAAa,CAAC,SAAS,CAAC,KAC/B,SAMF,CAAC;AAEF,4CAA4C;AAC5C,MAAM,WAAW,2BAA2B;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IACjD;;;;;OAKG;IACH,QAAQ,CAAC,kBAAkB,EAAE,gBAAgB,CAAC;IAC9C;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACxD;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB,GAClC,MAAM,OAAO,EACb,SAAS,2BAA2B,KAClC,KAAK,CAAC,SAAS,CAsIjB,CAAC;AAEF,0FAA0F;AAC1F,eAAO,MAAM,0BAA0B,UAAmC,CAAC"}
+{"version":3,"file":"testing_reset_actions.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_reset_actions.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,EAAc,KAAK,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAKzE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AAqCzC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;QAiBpC;;;;;;;;WAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWyC,CAAC;AAE/C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;CAWA,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;CAwBC,CAAC;AAE/C;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC,QAAO,SACmB,CAAC;AAE3E;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;CAeK,CAAC;AAE/C;;;;;;;;;GASG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWF,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,qCAAqC,QAAO,SAGvD,CAAC;AAEH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;CAYJ,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,uCAAuC,QAAO,SAGzD,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYF,CAAC;AAyB/C,eAAO,MAAM,qCAAqC,GACjD,SAAS,aAAa,CAAC,SAAS,CAAC,KAC/B,SAMF,CAAC;AAEF,4CAA4C;AAC5C,MAAM,WAAW,2BAA2B;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IACjD;;;;;OAKG;IACH,QAAQ,CAAC,kBAAkB,EAAE,gBAAgB,CAAC;IAC9C;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACxD;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB,GAClC,MAAM,OAAO,EACb,SAAS,2BAA2B,KAClC,KAAK,CAAC,SAAS,CAsIjB,CAAC;AAEF,0FAA0F;AAC1F,eAAO,MAAM,0BAA0B,UAAmC,CAAC"}