@fuzdev/fuz_app 0.104.0 → 0.106.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>');
@@ -371,7 +371,11 @@ const mint_account = async (handle, options) => {
     // Drain the body so the connection releases — Hono's login returns
     // `{ok: true}` and we already have the cookie via the jar.
     await login_response.arrayBuffer().catch(() => undefined);
-    const token_result = await rpc_via_transport(transport, handle.config.rpc_path, 'account_token_create', {}, handle.config.name);
+    // `scope` is required at mint — there is no absent state, which is the whole
+    // point of the default-deny design. A minted-account fixture stands in for an
+    // ordinary account credential, so it takes full account authority; the
+    // narrowed credential is the conformance table's `scoped_token` principal.
+    const token_result = await rpc_via_transport(transport, handle.config.rpc_path, 'account_token_create', { scope: { kind: 'full' } }, handle.config.name);
     const token_parsed = TokenCreateResponseShape.safeParse(token_result);
     if (!token_parsed.success) {
         throw new Error(`account_token_create(${handle.config.name}) returned unexpected result: ${JSON.stringify(token_result)}`);
@@ -381,7 +385,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 +422,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 +433,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 +464,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 +486,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 +518,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 +541,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 +568,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/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"}

package/dist/testing/cross_backend/testing_reset_actions.js

@@ -70,13 +70,14 @@ import '../assert_dev_env.js';
  */
 import { z } from 'zod';
 import { Uuid } from '@fuzdev/fuz_util/id.ts';
-import { fact_hash_bytes, FactHashSchema } from '@fuzdev/fuz_util/fact_hash.ts';
+import { fact_hash_bytes } from '@fuzdev/fuz_util/fact_hash.ts';
+import { FactHashSchema } from '@fuzdev/fuz_util/hash_schemas.ts';
 import { rpc_action } from '../../actions/action_rpc.js';
 import { protocol_action_specs } from '../../actions/protocol.js';
 import { query_put_fact } from '../../db/fact_queries.js';
 import { ROLE_ADMIN, ROLE_KEEPER } from '../../auth/role_schema.js';
 import { auth_integration_truncate_tables } from '../db.js';
-import { query_schema_snapshot, SchemaSnapshot, query_migration_tracker, MigrationTracker, } from '../schema_introspect.js';
+import { query_schema_snapshot, SchemaSnapshot, query_migration_tracker, MigrationTracker } from '../schema_introspect.js';
 import { ActionManifest, build_action_manifest } from './action_manifest.js';
 import { query_create_actor } from '../../auth/account_queries.js';
 import { create_test_account_with_credentials, mint_test_session } from '../app_server.js';
@@ -93,14 +94,14 @@ import { DEFAULT_TEST_PASSWORD } from '../test_credentials.js';
 const TESTING_ACTION_AUTH = {
     account: 'required',
     actor: 'none',
-    credential_types: ['daemon_token'],
+    credential_types: ['daemon_token']
 };
 /** Output shape for an individual seeded account (keeper or extra). */
 const SeededAccountShape = z.strictObject({
     account: z.strictObject({ id: Uuid, username: z.string() }),
     actor: z.strictObject({ id: Uuid }),
     api_token: z.string(),
-    session_cookie: z.string(),
+    session_cookie: z.string()
 });
 /**
  * The `_testing_reset` action spec.
@@ -139,7 +140,7 @@ export const testing_reset_action_spec = {
             .array(z.strictObject({
             username: z.string(),
             password_value: z.string().optional(),
-            roles: z.array(z.string()),
+            roles: z.array(z.string())
         }))
             .optional(),
         /**
@@ -151,15 +152,15 @@ export const testing_reset_action_spec = {
          * production wire path adds a second. Bootstrap-cradle seeding, same
          * rationale as `extra_accounts`.
          */
-        extra_actors: z.array(z.string()).optional(),
+        extra_actors: z.array(z.string()).optional()
     }),
     output: SeededAccountShape.extend({
         extra_accounts: z.array(SeededAccountShape),
         /** The keeper's additional actors (from input `extra_actors`), in order. */
-        extra_actors: z.array(z.strictObject({ id: Uuid, name: z.string() })),
+        extra_actors: z.array(z.strictObject({ id: Uuid, name: z.string() }))
     }),
     async: true,
-    description: 'Test-binary only — wipe auth tables, re-bootstrap a fresh keeper (+ optional extras), fire the domain-state reset.',
+    description: 'Test-binary only — wipe auth tables, re-bootstrap a fresh keeper (+ optional extras), fire the domain-state reset.'
 };
 /**
  * `_testing_drain_effects` — await in-flight fire-and-forget audit writes so
@@ -186,7 +187,7 @@ export const testing_drain_effects_action_spec = {
     input: z.void(),
     output: z.strictObject({ ok: z.boolean() }),
     async: true,
-    description: 'Test-binary only — await in-flight fire-and-forget audit writes so a following audit_log_list read is authoritative.',
+    description: 'Test-binary only — await in-flight fire-and-forget audit writes so a following audit_log_list read is authoritative.'
 };
 /**
  * `_testing_mint_session` — mint an expired-by-construction server-side
@@ -233,13 +234,13 @@ export const testing_mint_session_action_spec = {
             .meta({
             description: 'Seconds to offset the session row from NOW(). Constrained negative so this ' +
                 'backdoor can ONLY mint an already-expired (backdated) row — never a usable ' +
-                'session for an arbitrary account. Its sole use is the expired-session gate.',
-        }),
+                'session for an arbitrary account. Its sole use is the expired-session gate.'
+        })
     }),
     output: z.strictObject({ session_cookie: z.string() }),
     async: true,
     description: 'Test-binary only — mint a backdated-expiry auth_session row for an account and return its ' +
-        'signed cookie value (exercises the authoritative server-side DB-row expiry gate).',
+        'signed cookie value (exercises the authoritative server-side DB-row expiry gate).'
 };
 /**
  * Build the standalone `_testing_drain_effects` action. No deps — on TS the
@@ -271,12 +272,12 @@ export const testing_put_fact_action_spec = {
     side_effects: true,
     input: z.strictObject({
         content: z.string(),
-        content_type: z.string().optional(),
+        content_type: z.string().optional()
     }),
     output: z.strictObject({ hash: FactHashSchema }),
     async: true,
     description: 'Test-binary only — seed an embedded fact (blake3 of the UTF-8 content) and return its hash, ' +
-        'so the cross-process fact-serving suite can store bytes without a DB handle.',
+        'so the cross-process fact-serving suite can store bytes without a DB handle.'
 };
 /**
  * `_testing_schema_snapshot` — introspect the live database into a normalized
@@ -297,7 +298,7 @@ export const testing_schema_snapshot_action_spec = {
     input: z.strictObject({ exclude_tables: z.array(z.string()).optional() }),
     output: SchemaSnapshot,
     async: true,
-    description: 'Test-binary only — introspect the live schema into a normalized snapshot for cross-impl parity diffing.',
+    description: 'Test-binary only — introspect the live schema into a normalized snapshot for cross-impl parity diffing.'
 };
 /**
  * Build the standalone `_testing_schema_snapshot` action. No deps —
@@ -329,7 +330,7 @@ export const testing_migration_tracker_action_spec = {
     output: MigrationTracker,
     async: true,
     description: 'Test-binary only — dump the schema_version tracker rows as a normalized {namespace, name, ' +
-        'sequence} list for cross-impl migration-identity parity diffing.',
+        'sequence} list for cross-impl migration-identity parity diffing.'
 };
 /**
  * Build the standalone `_testing_migration_tracker` action. No deps — reads
@@ -368,7 +369,7 @@ export const testing_action_manifest_action_spec = {
     output: ActionManifest,
     async: true,
     description: 'Test-binary only — dump the live RPC registry as a normalized {method, auth, side_effects} ' +
-        'manifest for cross-impl method-set + auth-shape parity diffing.',
+        'manifest for cross-impl method-set + auth-shape parity diffing.'
 };
 /**
  * Build the `_testing_action_manifest` action over a backend's full live RPC
@@ -393,7 +394,7 @@ const PROTOCOL_METHODS = new Set(protocol_action_specs.map((spec) => spec.method
 export const create_testing_action_manifest_action = (mounted) => {
     const manifest = build_action_manifest([
         ...mounted.map((action) => action.spec).filter((spec) => !PROTOCOL_METHODS.has(spec.method)),
-        testing_action_manifest_action_spec,
+        testing_action_manifest_action_spec
     ]);
     return rpc_action(testing_action_manifest_action_spec, async () => manifest);
 };
@@ -463,7 +464,7 @@ export const create_testing_actions = (deps, options) => {
                 session_options,
                 password: deps.password,
                 password_value: DEFAULT_TEST_PASSWORD,
-                roles: [ROLE_KEEPER, ROLE_ADMIN, ...(input.extra_keeper_roles ?? [])],
+                roles: [ROLE_KEEPER, ROLE_ADMIN, ...(input.extra_keeper_roles ?? [])]
             });
             // 5. Seed any caller-requested extras. These are bootstrap-time
             //    secondaries — the bypass exists in the same cradle the
@@ -477,7 +478,7 @@ export const create_testing_actions = (deps, options) => {
                     password: deps.password,
                     username: spec.username,
                     password_value: spec.password_value ?? DEFAULT_TEST_PASSWORD,
-                    roles: spec.roles,
+                    roles: spec.roles
                 });
                 extras.push(seeded);
             }
@@ -512,7 +513,7 @@ export const create_testing_actions = (deps, options) => {
                 keyring: deps.keyring,
                 session_options,
                 account_id: input.account_id,
-                expires_in_seconds: input.expires_in_seconds,
+                expires_in_seconds: input.expires_in_seconds
             });
             return { session_cookie };
         }),
@@ -524,13 +525,13 @@ export const create_testing_actions = (deps, options) => {
                 bytes,
                 external_url: null,
                 content_type: input.content_type ?? null,
-                size: bytes.length,
+                size: bytes.length
             });
             return { hash };
         }),
         create_testing_drain_effects_action(),
         create_testing_schema_snapshot_action(),
-        create_testing_migration_tracker_action(),
+        create_testing_migration_tracker_action()
     ];
 };
 /** Set of auth-namespace tables `_testing_reset` wipes. Mirrored by the coverage test. */

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

@@ -1 +1 @@
-{"version":3,"file":"testing_server_bun.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_server_bun.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA6B9B,OAAO,KAAK,EAAc,oBAAoB,EAAC,MAAM,0BAA0B,CAAC;AAehF,kDAAkD;AAClD,eAAO,MAAM,0BAA0B,QAAO,oBA0D5C,CAAC"}
+{"version":3,"file":"testing_server_bun.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_server_bun.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA6B9B,OAAO,KAAK,EAAe,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAelF,kDAAkD;AAClD,eAAO,MAAM,0BAA0B,QAAO,oBA0D5C,CAAC"}