@fuzdev/fuz_app 0.147.0 → 0.149.0

package/dist/testing/cross_backend/cargo_binary.js

@@ -0,0 +1,148 @@
+import '../assert_dev_env.js';
+/**
+ * Cargo-built test binaries for cross-backend projects — build before the
+ * spawn, then spawn the binary itself.
+ *
+ * A config that spawns `cargo run` builds inside `spawn_backend`'s health
+ * window, so a cold build can outlast the startup timeout, and the build's
+ * output is held in the spawn's stderr tail rather than shown.
+ * `prepare_cargo_binary` runs the build first, with its output inherited, as a
+ * pre-spawn hook (`create_cross_backend_global_setup`'s `before_spawn`), and
+ * the config's `start_command` names the built binary
+ * (`resolve_cargo_binary_path`), so the spawn starts at once.
+ *
+ * The binary's path comes from `cargo metadata`: under the workspace's
+ * resolved `target_directory`, so `CARGO_TARGET_DIR` and `build.target-dir`
+ * are honoured, in the profile's output directory.
+ *
+ * @module
+ */
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Env var skipping the build, for iteration on a known-current binary: `1` or
+ * `true` skips it, any other value (`0`, `false`, empty) builds.
+ */
+export const NO_REBUILD_ENV = 'FUZ_TESTING_NO_REBUILD';
+/**
+ * Whether an `NO_REBUILD_ENV` value asks to skip the build — only an explicit
+ * `1` / `true`, so `FUZ_TESTING_NO_REBUILD=0` still builds.
+ *
+ * @param value - the variable's value, `undefined` when unset
+ */
+export const is_no_rebuild_requested = (value) => value === '1' || value?.toLowerCase() === 'true';
+/**
+ * The directory under the target directory a profile's output lands in —
+ * `debug` for `dev`, the profile's own name otherwise (`release`, a custom
+ * `cross-test`).
+ *
+ * @param profile - the Cargo profile
+ */
+export const to_cargo_profile_dir = (profile) => profile === 'dev' ? 'debug' : profile;
+/**
+ * The binary path `cargo build --profile <profile> --bin <bin>` writes, from
+ * `cargo metadata --no-deps --format-version 1` output.
+ *
+ * @param metadata_json - the `cargo metadata` output
+ * @param bin - the binary's name
+ * @param profile - the Cargo profile
+ * @returns the binary's absolute path
+ * @throws Error when the output carries no `target_directory`
+ */
+export const to_cargo_binary_path = (metadata_json, bin, profile) => {
+    const metadata = JSON.parse(metadata_json);
+    if (typeof metadata.target_directory !== 'string' || !metadata.target_directory) {
+        throw new Error('`cargo metadata` output has no `target_directory`');
+    }
+    return join(metadata.target_directory, to_cargo_profile_dir(profile), bin);
+};
+/**
+ * Per-process memo of each workspace's target directory metadata. On
+ * `globalThis` rather than in module scope, so every project's `globalSetup` in
+ * one vitest process shares it whether or not they share this module's
+ * instance.
+ */
+const CARGO_METADATA_MEMO_KEY = '__fuz_app_cargo_metadata_memo';
+const get_metadata_memo = () => {
+    const holder = globalThis;
+    return (holder[CARGO_METADATA_MEMO_KEY] ??= new Map());
+};
+/**
+ * How long `cargo metadata` may take (ms). Usually well under a second, but
+ * the first run in a checkout can have rustup install the pinned toolchain.
+ */
+const CARGO_METADATA_TIMEOUT_MS = 120_000;
+/**
+ * Throw naming the workspace when its directory is missing — a spawn with a
+ * missing `cwd` otherwise fails as `spawnSync cargo ENOENT`, which reads as
+ * cargo not being installed.
+ */
+const assert_workspace_dir = (workspace_dir) => {
+    if (!existsSync(workspace_dir)) {
+        throw new Error(`the Cargo workspace ${workspace_dir} does not exist`);
+    }
+};
+const read_cargo_metadata = (workspace_dir) => {
+    const memo = get_metadata_memo();
+    let metadata_json = memo.get(workspace_dir);
+    if (metadata_json === undefined) {
+        assert_workspace_dir(workspace_dir);
+        try {
+            metadata_json = execFileSync('cargo', ['metadata', '--no-deps', '--format-version', '1'], {
+                cwd: workspace_dir,
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'inherit'],
+                maxBuffer: 64 * 1024 * 1024,
+                timeout: CARGO_METADATA_TIMEOUT_MS
+            });
+        }
+        catch (error) {
+            const code = error.code;
+            throw new Error(code === 'ETIMEDOUT'
+                ? `\`cargo metadata\` in ${workspace_dir} took over ${CARGO_METADATA_TIMEOUT_MS}ms`
+                : `\`cargo metadata\` in ${workspace_dir} failed: ${error.message}`, { cause: error });
+        }
+        memo.set(workspace_dir, metadata_json);
+    }
+    return metadata_json;
+};
+/**
+ * The path of a Cargo-built binary, without building it — what a config's
+ * `start_command` names. Runs `cargo metadata` once per process per workspace,
+ * so it needs cargo on PATH.
+ *
+ * @param options - the workspace, package, binary and profile
+ * @returns the binary's absolute path
+ * @throws Error when the workspace is missing or `cargo metadata` fails
+ */
+export const resolve_cargo_binary_path = (options) => {
+    const { workspace_dir, package: pkg, bin = pkg, profile = 'dev' } = options;
+    return to_cargo_binary_path(read_cargo_metadata(workspace_dir), bin, profile);
+};
+/**
+ * Build a Cargo binary before its backend spawns, unless `NO_REBUILD_ENV`
+ * asks to skip it, and return its path. The build's output is inherited, so a
+ * cold build shows its progress, and a failed build throws — the project fails
+ * loudly rather than spawning a stale binary. `cargo build` is incremental, so
+ * a build with nothing changed is quick.
+ *
+ * Synchronous: vitest awaits each project's `globalSetup` in turn, so one
+ * invocation selecting several projects builds once, then finds the build
+ * current.
+ *
+ * @param options - the workspace, package, binary and profile
+ * @returns the binary's absolute path (`resolve_cargo_binary_path`)
+ * @throws Error when the workspace is missing, the build fails, or `cargo metadata` fails
+ */
+export const prepare_cargo_binary = (options) => {
+    const { workspace_dir, package: pkg, bin = pkg, profile = 'dev' } = options;
+    if (!is_no_rebuild_requested(process.env[NO_REBUILD_ENV])) {
+        assert_workspace_dir(workspace_dir);
+        execFileSync('cargo', ['build', '-p', pkg, '--bin', bin, '--profile', profile], {
+            cwd: workspace_dir,
+            stdio: 'inherit'
+        });
+    }
+    return resolve_cargo_binary_path(options);
+};

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;AA6D9B,OAAO,KAAK,EAAE,uCAAuC,EAAE,MAAM,YAAY,CAAC;AAG1E,eAAO,MAAM,8BAA8B,GAC1C,SAAS,uCAAuC,KAC9C,IAggBF,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;AA0E9B,OAAO,KAAK,EAAE,uCAAuC,EAAE,MAAM,YAAY,CAAC;AAgE1E,eAAO,MAAM,8BAA8B,GAC1C,SAAS,uCAAuC,KAC9C,IA4uBF,CAAC"}

package/dist/testing/cross_backend/cell_crud.js

@@ -23,6 +23,9 @@ import '../assert_dev_env.js';
  * - a non-owner non-admin editing / reading / deleting another's private cell
  *   gets 404 (IDOR mask), never 403;
  * - admin reaches any cell;
+ * - `cell_list` pages honor `limit` + `offset`, and a page is visible rows:
+ *   a newer run of cells the caller can't see never crowds the visible ones
+ *   out, for a non-owner and for anon, and an admin's pages tile every row;
  * - duplicate active `path` → 409 (`cell_path_taken`);
  * - `path` write by a non-admin → 403 (`cell_path_admin_only`), on both create
  *   and update (even by the owner);
@@ -35,7 +38,13 @@ import '../assert_dev_env.js';
  *   accepted as a list filter that matches nothing;
  * - a `kind` of exactly `CELL_KIND_LENGTH_MAX` UTF-16 code units is stored
  *   whole, and one unit past it is `invalid_params` on create and as a list
- *   filter.
+ *   filter;
+ * - a `data` that is no `CellData` — not an object, or a `label` / `summary`
+ *   that is no string — is 400 `invalid_params` with the generic message and
+ *   no reason on `cell_create`, `cell_update` and (with
+ *   `capabilities.cell_relations`) `cell_clone`'s `with_data_patch`, ahead of
+ *   every cell check (a missing or hidden cell refuses it the same way, never
+ *   with the 404 mask), and writes no cell.
  *
  * The visibility-manage-tier 403 (`cell_visibility_manage_only`) needs a
  * non-owner editor, which only a `cell_grant` can produce, so it lives in
@@ -45,11 +54,64 @@ import '../assert_dev_env.js';
  * @module
  */
 import { describe, assert } from 'vitest';
-import { CELL_KIND_LENGTH_MAX, CellCreateOutput, CellDeleteOutput, CellGetOutput, CellListOutput, CellUpdateOutput } from '../../auth/cell_action_specs.js';
+import { jsonrpc_error_messages } from '../../http/jsonrpc_errors.js';
+import { CELL_KIND_LENGTH_MAX, CELL_LIST_LIMIT_MAX, 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 { cross_rpc_call, error_reason, expect_output } from './cross_rpc.js';
 import { assert_iso8601_seconds, assert_iso8601_seconds_nullable } from './wire_shapes.js';
 import { SPINE_RPC_PATH } from './spine_surface_constants.js';
+/**
+ * `data` values that are no `CellData` — not an object, or an object whose
+ * `label` / `summary` is no string. Twin of the Rust spine's mistyped-data
+ * table in its cell authz tests.
+ */
+const MISTYPED_CELL_DATA = [
+    'not_an_object',
+    42,
+    true,
+    [1],
+    { label: 123 },
+    { label: null },
+    { summary: {} },
+    { summary: false }
+];
+/** The message every schema refusal answers, naming no field. */
+const INVALID_PARAMS_MESSAGE = jsonrpc_error_messages.invalid_params().message;
+/**
+ * Assert `r` is a schema refusal: 400 `invalid_params` with the generic
+ * message and no `data`, save the Zod `issues` a TS spine adds under DEV
+ * alone — an array of issue objects, each with a string `code` and
+ * `message`, and never a `reason`.
+ */
+const assert_schema_refusal = (r, label) => {
+    const detail = `${label}: got ${r.status} ${JSON.stringify(r.error ?? r.result)}`;
+    assert.strictEqual(r.status, 400, detail);
+    const { error } = r;
+    assert.ok(error, detail);
+    assert.strictEqual(error.code, -32602, detail);
+    assert.strictEqual(error.message, INVALID_PARAMS_MESSAGE, detail);
+    const { data } = error;
+    if (data === undefined)
+        return;
+    assert.ok(typeof data === 'object' && data !== null && Object.keys(data).join() === 'issues', `${detail} — data beyond the DEV-only issues`);
+    const { issues } = data;
+    assert.ok(Array.isArray(issues), `${detail} — DEV-only issues that are no array`);
+    for (const issue of issues) {
+        assert.ok(typeof issue === 'object' &&
+            issue !== null &&
+            typeof issue.code === 'string' &&
+            typeof issue.message === 'string', `${detail} — a DEV-only issue that is no Zod issue`);
+    }
+};
+/**
+ * Assert `r` is the IDOR mask: 404 with reason `cell_not_found` — the
+ * well-typed control beside a schema refusal of the same call.
+ */
+const assert_cell_not_found = (r, label) => {
+    const detail = `${label}: got ${r.status} ${JSON.stringify(r.error ?? r.result)}`;
+    assert.strictEqual(r.status, 404, detail);
+    assert.strictEqual(error_reason(r), 'cell_not_found', detail);
+};
 export const describe_cell_crud_cross_tests = (options) => {
     const { setup_test, capabilities } = options;
     const rpc_path = options.rpc_path ?? SPINE_RPC_PATH;
@@ -194,6 +256,59 @@ export const describe_cell_crud_cross_tests = (options) => {
             assert.ok(!update_path.ok, 'non-admin set a path on update');
             assert.strictEqual(error_reason(update_path), 'cell_path_admin_only');
         });
+        test_if(capabilities.cell_crud, 'cell_list pages: limit + offset honored; hidden rows never crowd visible ones out of a page', async () => {
+            const fixture = await setup_test();
+            const owner = await fixture.create_account({ username: 'cell_page_owner' });
+            const other = await fixture.create_account({ username: 'cell_page_other' });
+            const viewer = await fixture.create_account({ username: 'cell_page_viewer' });
+            const t = fixture.fresh_transport();
+            const kind = 'page_probe';
+            const create = async (headers, visibility) => expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { kind, data: {}, visibility }, headers), CellCreateOutput).cell.id;
+            const owner_h = owner.create_session_headers();
+            const other_h = other.create_session_headers();
+            // oldest first: the visible rows, then a newer run of hidden ones —
+            // two owners' private cells — longer than a page, so the newest
+            // `limit` rows are all hidden from the viewer
+            const visible = [];
+            for (let i = 0; i < 5; i++) {
+                visible.push(await create(i % 2 === 0 ? owner_h : other_h, 'public'));
+            }
+            const hidden = [];
+            for (let i = 0; i < 6; i++) {
+                hidden.push(await create(i % 2 === 0 ? owner_h : other_h, 'private'));
+            }
+            const limit = 3;
+            const page = async (transport, headers, params) => expect_output(await cross_rpc_call(transport, rpc_path, 'cell_list', { kind, ...params }, headers), CellListOutput).cells.map((c) => c.id);
+            // newest first (the default order), so the visible rows, newest first
+            const visible_desc = [...visible].reverse();
+            for (const [label, transport, headers] of [
+                ['a non-owner viewer', t, viewer.create_session_headers()],
+                ['anon', fixture.fresh_transport({ origin: null }), {}]
+            ]) {
+                const first = await page(transport, headers, { limit });
+                assert.deepStrictEqual(first, visible_desc.slice(0, limit), `${label}: the first page is the newest visible rows, full to limit`);
+                const second = await page(transport, headers, { limit, offset: limit });
+                assert.deepStrictEqual(second, visible_desc.slice(limit), `${label}: the next page is the rest of the visible rows`);
+                const past = await page(transport, headers, { limit, offset: visible.length });
+                assert.deepStrictEqual(past, [], `${label}: a page past the visible rows is empty`);
+                for (const id of [...first, ...second]) {
+                    assert.ok(!hidden.includes(id), `${label}: a page leaked a hidden row`);
+                }
+            }
+            // an admin sees every row, paged the same way
+            const admin_h = fixture.create_session_headers();
+            const all_desc = [...visible, ...hidden].reverse();
+            const admin_pages = [];
+            for (let offset = 0; offset < all_desc.length; offset += 4) {
+                const rows = await page(t, admin_h, { limit: 4, offset });
+                assert.ok(rows.length <= 4, `admin page at offset ${offset} exceeds limit`);
+                admin_pages.push(...rows);
+            }
+            assert.deepStrictEqual(admin_pages, all_desc, 'admin pages tile the whole list in order');
+            // the owner sees its own private rows beside every public one
+            const owner_rows = await page(t, owner_h, { limit: 50 });
+            assert.deepStrictEqual(owner_rows, all_desc.filter((id) => visible.includes(id) || hidden.indexOf(id) % 2 === 0), 'the owner reads public rows plus its own private ones');
+        });
         test_if(capabilities.cell_crud, 'cell_get without id or path → invalid_params', async () => {
             const fixture = await setup_test();
             const bad = await cross_rpc_call(fixture.fresh_transport(), rpc_path, 'cell_get', {}, fixture.create_session_headers());
@@ -271,5 +386,61 @@ export const describe_cell_crud_cross_tests = (options) => {
                 }
             }
         });
+        describe('mistyped data', () => {
+            /** Count every cell, read as the keeper (an admin sees every row). */
+            const count_cells = async (t, keeper_headers) => {
+                const { cells } = expect_output(await cross_rpc_call(t, rpc_path, 'cell_list', { limit: CELL_LIST_LIMIT_MAX }, keeper_headers), CellListOutput);
+                assert.ok(cells.length < CELL_LIST_LIMIT_MAX, 'the count needs a page that holds every cell');
+                return cells.length;
+            };
+            test_if(capabilities.cell_crud, 'cell_create and cell_update refuse it as invalid_params before any cell check', async () => {
+                const fixture = await setup_test();
+                const writer = await fixture.create_account({ username: 'cell_data_writer' });
+                const stranger = await fixture.create_account({ username: 'cell_data_stranger' });
+                const t = fixture.fresh_transport();
+                const keeper_headers = fixture.create_session_headers();
+                const writer_headers = writer.create_session_headers();
+                // the keeper's private cell, hidden from the stranger; the keeper
+                // creates it so a backend that refuses a non-admin root runs the case
+                const hidden = expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { kind: 'note', data: {} }, keeper_headers), CellCreateOutput).cell.id;
+                const missing = crypto.randomUUID();
+                const before = await count_cells(t, keeper_headers);
+                for (const data of MISTYPED_CELL_DATA) {
+                    const shown = JSON.stringify(data);
+                    assert_schema_refusal(await cross_rpc_call(t, rpc_path, 'cell_create', { data }, writer_headers), `cell_create data ${shown}`);
+                    for (const [cell_id, headers, who] of [
+                        [missing, writer_headers, 'a missing cell'],
+                        [hidden, stranger.create_session_headers(), 'a hidden cell']
+                    ]) {
+                        assert_schema_refusal(await cross_rpc_call(t, rpc_path, 'cell_update', { cell_id, data }, headers), `cell_update of ${who} data ${shown}`);
+                    }
+                }
+                // the control: well-typed, the same call meets the 404 mask, so the
+                // 400s above came before the cell check
+                assert_cell_not_found(await cross_rpc_call(t, rpc_path, 'cell_update', { cell_id: hidden, data: {} }, stranger.create_session_headers()), 'cell_update of a hidden cell data {}');
+                assert.strictEqual(await count_cells(t, keeper_headers), before, 'a refused write wrote a cell');
+            });
+            test_if(capabilities.cell_crud && capabilities.cell_relations, 'cell_clone refuses it in with_data_patch as invalid_params before any cell check', async () => {
+                const fixture = await setup_test();
+                const writer = await fixture.create_account({ username: 'cell_patch_writer' });
+                const stranger = await fixture.create_account({ username: 'cell_patch_stranger' });
+                const t = fixture.fresh_transport();
+                const keeper_headers = fixture.create_session_headers();
+                const hidden = expect_output(await cross_rpc_call(t, rpc_path, 'cell_create', { kind: 'note', data: {} }, keeper_headers), CellCreateOutput).cell.id;
+                const missing = crypto.randomUUID();
+                const before = await count_cells(t, keeper_headers);
+                for (const with_data_patch of MISTYPED_CELL_DATA) {
+                    for (const [source_id, headers, who] of [
+                        [missing, writer.create_session_headers(), 'a missing cell'],
+                        [hidden, stranger.create_session_headers(), 'a hidden cell']
+                    ]) {
+                        assert_schema_refusal(await cross_rpc_call(t, rpc_path, 'cell_clone', { source_id, with_data_patch }, headers), `cell_clone of ${who} with_data_patch ${JSON.stringify(with_data_patch)}`);
+                    }
+                }
+                // the control: well-typed, the same clone meets the 404 mask
+                assert_cell_not_found(await cross_rpc_call(t, rpc_path, 'cell_clone', { source_id: hidden, with_data_patch: { label: 'patched' } }, stranger.create_session_headers()), 'cell_clone of a hidden cell with_data_patch {label}');
+                assert.strictEqual(await count_cells(t, keeper_headers), before, 'a refused clone wrote a cell');
+            });
+        });
     });
 };

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

@@ -1,64 +1,4 @@
 import '../assert_dev_env.js';
 import type { RpcPathCapabilityGatedCrossSuiteOptions } from './setup.js';
 export declare const describe_cell_gated_create_cross_tests: (options: RpcPathCapabilityGatedCrossSuiteOptions) => 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.
- *
- * And that moderation gates reads — a cell's effective audience is its
- * visibility or grants **and** its moderation admission (unmoderated or
- * `approved`), so a pending or rejected contribution reaches no one past its
- * author and admins:
- *
- * - **an author's self-flip to public admits nobody** — a pending post its
- *   author makes public stays 404 to anon and a fresh non-admin on `cell_get`,
- *   and out of their `cell_list`; the author and admin still read it.
- * - **rejection holds a public post back** — pending → rejected → public, and
- *   approved → rejected (approval made it public, rejection leaves visibility
- *   alone), both 404 past the author; a grant made while the post was approved
- *   stops admitting once it is rejected, on `cell_get` and `shared_with: 'me'`.
- * - **an approved post is live** — the control.
- * - **relation reads follow** — a pending post in a public collection is
- *   omitted from anon `cell_item_list`, beside a live sibling that isn't; at
- *   the far end of all four relation lists, a pending post is hidden from
- *   anon even flipped public, and a rejected one from its grant holder.
- * - **fact serving follows** — a pending post's fact is 404 to anon, even
- *   with the post flipped public (also gated on `capabilities.fact_serving`).
- *
- * And the steward arm — the owner of a **non-admin** root (a parentless
- * non-`space` kind carrying the same policy, which the test authorizer leaves
- * open) reads the pending posts under it and moderates them:
- *
- * - **the queue** — `cell_list({root_id, moderation: 'pending'})` and
- *   `cell_get` (with `can_edit` / `can_grant` false) → 200; a stranger 404s.
- * - **moderation** — the root owner approves → 200; the author 403, a
- *   stranger 404.
- * - **the arm stops there** — the root owner's `cell_clone` of the pending
- *   post and a contribution under it are both 404.
- * - **fact serving** — the root owner fetches a pending post's fact → 200,
- *   anon 404 (also gated on `capabilities.fact_serving`).
- *
- * And that `cell_grant_create` refuses a pending contribution — **403**
- * `cell_grant_unapproved` for its author and an admin, actor- and role-shaped,
- * while a non-manager keeps the **404** mask; the same grant lands once the
- * post is approved.
- *
- * Gated on `capabilities.cell_gated_create` — a `pending` contribution only
- * exists when the directory authorizer is mounted (reference spine binaries).
- */
-export declare const describe_cell_moderate_cross_tests: (options: RpcPathCapabilityGatedCrossSuiteOptions) => 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;AAoE9B,OAAO,KAAK,EAAE,uCAAuC,EAAE,MAAM,YAAY,CAAC;AAqB1E,eAAO,MAAM,sCAAsC,GAClD,SAAS,uCAAuC,KAC9C,IAuTF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,eAAO,MAAM,kCAAkC,GAC9C,SAAS,uCAAuC,KAC9C,IAs6BF,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;AAsD9B,OAAO,KAAK,EAAE,uCAAuC,EAAE,MAAM,YAAY,CAAC;AAQ1E,eAAO,MAAM,sCAAsC,GAClD,SAAS,uCAAuC,KAC9C,IAuTF,CAAC"}