@xanots/sdk 0.0.10 → 0.0.12

package/CHANGELOG.md

@@ -11,6 +11,39 @@ listed here.
 
 ---
 
+## 0.0.11 — The silent-success pass
+
+_2026-08-31_ · [release notes](https://github.com/xanots/sdk/releases/tag/v0.0.11)
+
+This release adds one new entry point and closes a set of shapes that compiled clean and then went wrong at request time — a regex pair that answered `false` for every input, a read addressed by query string instead of by path, a column name the engine reserves, and a `0` id that fails a whole request. Most land as warnings, so an ordinary build is unaffected; `export --strict` promotes them, so a strict build that passed on 0.0.10 can newly fail. It also corrects one piece of published advice: a physical table name is not stable across deploys, and the old atomic-counter guidance said to hardcode it.
+
+- `@xanots/sdk/bundle` reads a compiled bundle without reimplementing the SDK
+- ⚠️ A reversed regex operand pair is refused instead of answering `false` forever
+- ⚠️ An addressing input missing from a query's path now warns
+- ⚠️ A reserved `run` column and a `get_by_id` id that can be `0` now warn
+- `obj()` accepts `c.obj` and `c.array` members
+- `./manifest.json` is exported from the package
+- Corrected: a physical table name is not stable across deploys
+
+---
+
+## 0.0.10 — The CLI surface pass
+
+_2026-08-31_ · [release notes](https://github.com/xanots/sdk/releases/tag/v0.0.10)
+
+This release is a CLI surface pass, and it is breaking throughout. Six ways to start a project collapse to `init` plus two flags, the sandbox environment is gone with every surface that named it, and a run of commands and flags were renamed to say what they actually do — including three that each carried two or three unrelated meanings. One command is new: `xanots status` answers where you stand in a single read.
+
+- ⚠️ Project creation is one command: `init`, with `--from` and `--web`
+- ⚠️ The sandbox environment is gone
+- ⚠️ `deploy` takes no environment flag
+- `xanots status` — who, where, and which environment
+- ⚠️ `validate` is now `preflight`, and `lock adopt` is now `lock import`
+- ⚠️ `--dest` is now `--env`, and names environments the way `--from` does
+- ⚠️ Flags that carried several meanings were split apart
+- `routes` and `whoami` are the canonical spellings
+
+---
+
 ## 0.0.9 — Eight reports from real use
 
 _2026-08-31_ · [release notes](https://github.com/xanots/sdk/releases/tag/v0.0.9)

package/README.md

@@ -173,8 +173,10 @@ const HOST = (typeof window !== "undefined" && window.XANO_HOST) || import.meta.
 
 **Prefer to wire it by hand?** Skip `init` — `npm install @xanots/sdk`, write your workspace
 in `xano/index.ts`, and steps 1 and 4 are unchanged. The entry must be an ES module (XanoTS
-defs are ESM-only); on Node ≥ 22.6 a `.ts` entry loads natively, and older Node wants
-[`tsx`](https://tsx.is).
+defs are ESM-only), and a TypeScript entry wants [`tsx`](https://tsx.is) installed
+(`npm i -D tsx`) — the CLI picks it up automatically. Node's own type stripping is not
+enough on its own: it loads a `.ts` file but does not remap the `./x.js` specifiers a
+workspace uses to import its own modules, so anything past a single file fails to resolve.
 
 ---
 
@@ -228,8 +230,9 @@ export default workspace("blog")
 Tab-complete `s.` to discover the entire statement catalog — `s.db.*`, `s.math.*`,
 `s.array.*`, `s.text.*`, `s.storage.*`, `s.api.*`, `s.cloud.*`, control flow, AI agent runs,
 and more. **All 214 engine statement surfaces are authorable** — every field name matches
-the Xano engine, and the output is proven byte-for-byte against the engine's own golden
-fixtures.
+the Xano engine, and the emitted shape is checked against bytes a real engine stored. Where
+a surface has no stored instance behind it yet, it is built from the engine's own schema;
+[Coverage](https://github.com/xanots/sdk/blob/main/guides/coverage.md) says which is which.
 
 Give a table a `seed` array and those rows ship into the database on deploy, so a fresh
 environment comes up with its lookup tables and fixtures already in place.
@@ -288,7 +291,7 @@ remember the environment's name; it is tracked with the project.
 
 Every flag, the `--prune` rules, the identity model, and headless CI runs are in
 [Signing in & deploying](https://github.com/xanots/sdk/blob/main/guides/deploying.md). Environment management is
-`xanots ephemeral <list|get|delete|export>`.
+`xanots ephemeral <list|get|delete|export|impersonate>`.
 
 ### Testing
 
@@ -414,6 +417,46 @@ reference, the guides carry the shape of a project and the behavior that will bi
 | [Pulling an existing workspace](https://github.com/xanots/sdk/blob/main/guides/codegen.md) | What `xanots init --from` writes, how faithful it is, and how to read its report |
 | [Coverage & agent grounding](https://github.com/xanots/sdk/blob/main/guides/coverage.md) | What is covered, what is out of scope, and the files agents read |
 
+### Reading a compiled bundle
+
+`@xanots/sdk` writes a bundle; `@xanots/sdk/bundle` reads one back. It is the surface for
+tools that take compiled JSON as input — a graph view, a diff, a linter, a docs generator —
+so none of them has to reverse-engineer the storage shape and then go quietly wrong when the
+engine grows a new one.
+
+```ts
+import { statementCatalog, walk } from "@xanots/sdk/bundle";
+
+const bundle = JSON.parse(await readFile("bundle.json", "utf8"));
+const catalog = statementCatalog();
+
+for (const { raw, path, depth } of walk(bundle.payload.query[0].run)) {
+  console.log(`${"  ".repeat(depth)}${path}  ${catalog.get(raw.name)?.sPath ?? raw.name}`);
+}
+// 0       db.query
+// 1       conditional
+// 1.if.0  db.add
+```
+
+- **`walk(run)`** → every statement in the tree, each with a `path` and a `depth`. The path
+  format (`2.if.0`) is the shared address: a lint finding, a review comment and a runtime
+  error written by three different tools all name the same node.
+- **`subStacks(raw)`** → the nested stacks a statement carries, keyed by where they are
+  stored and labelled by what they mean — a try/catch and a conditional share the same three
+  storage keys. Found by shape, so a nesting form added later is still walked.
+- **`statementCatalog()`** → the stored `mvp:*` name to its authoring path, minus the
+  namespace (`mvp:dbo_view` → `db.query`, the `sPath` you write after `s.`) — which is
+  the point: the stored name is often not the one you'd guess.
+- **`structuralHash(raw)`** → a diff key for a statement and everything under it, with
+  engine-filled operands excluded. Without that exclusion, adding one column to a table
+  reports every statement that writes it as changed.
+- **`tableRefOf(column)` / `linkedTableOf(column)`** → the table a column points at.
+- **`normalize(value)`** → the normalizer `xanots preflight` compares with, for diffing a
+  stored workspace against a compiled one.
+
+Everything on the entry is pure — no filesystem, no network, no Node built-ins — so it runs
+in a browser or a worker.
+
 The package also ships two machine-readable descriptions of the same surface, generated from
 the SDK's own sources so they cannot drift from it: `llms.txt` (the router — the mental model
 and the gotchas, plus a map of the `llms/*.md` topic files) and `manifest.json` (per-entry

package/dist/.build-fingerprint

@@ -1 +1 @@
-d72e74909376b02042f7e65298a7158f3c3646928e959af4a14a7409667d070d
+7189e90fd30c05ded87b682caf1b483465145a88a8373b654ad8f94fb6812b79

package/dist/{agent-file-refresh-QNKN5RYD.js → agent-file-refresh-GQWAAOBV.js}

@@ -3,10 +3,10 @@ import {
   codingAgentDetected,
   isCI,
   refreshAgentFiles
-} from "./chunk-JGCWTCA7.js";
-import "./chunk-KA6G2L7U.js";
+} from "./chunk-2VTJSI6X.js";
+import "./chunk-VK26K7AY.js";
 import "./chunk-ZSYZTGJH.js";
-import "./chunk-Q77KNEUL.js";
+import "./chunk-RQNMTDXD.js";
 import "./chunk-EZG76F7R.js";
 export {
   CI_ENV_VARS,
@@ -14,4 +14,4 @@ export {
   isCI,
   refreshAgentFiles
 };
-//# sourceMappingURL=agent-file-refresh-QNKN5RYD.js.map
+//# sourceMappingURL=agent-file-refresh-GQWAAOBV.js.map

package/dist/bin.js

@@ -1,28 +1,29 @@
 #!/usr/bin/env node
 import {
   maybeNotifyUpdate
-} from "./chunk-5YCQ2QHH.js";
+} from "./chunk-AG5GCZDD.js";
 import {
   readVersion,
   run
-} from "./chunk-ACCBOMCB.js";
-import "./chunk-CTD5ZCV6.js";
-import "./chunk-OYMR5AMJ.js";
+} from "./chunk-XT3XQ4PF.js";
+import "./chunk-7WRJPKGK.js";
+import "./chunk-3LQGF2WS.js";
 import {
   exitCodeOf,
   reportFailure
-} from "./chunk-F6CYJ7TN.js";
+} from "./chunk-Z2ZIE5CO.js";
 import "./chunk-GNPVYOPB.js";
 import {
   clearProgress,
   error
 } from "./chunk-EZG76F7R.js";
-import "./chunk-VKSOTZK3.js";
-import "./chunk-DIA7CT7J.js";
-import "./chunk-LBYWGMOA.js";
-import "./chunk-WHOJWOSV.js";
-import "./chunk-5XZ744TS.js";
-import "./chunk-7JDT4PBU.js";
+import "./chunk-QYSQ3UDO.js";
+import "./chunk-V5Y7D4LH.js";
+import "./chunk-N74KDCBD.js";
+import "./chunk-EETVJZAZ.js";
+import "./chunk-XWFRNJMQ.js";
+import "./chunk-2ZCUO2UG.js";
+import "./chunk-OHX6MIUZ.js";
 
 // src/emit/interrupt.ts
 var EXIT_SIGINT = 130;

package/dist/{branch-commands-2BLOC2GR.js → branch-commands-5KMPAAZV.js}

@@ -3,23 +3,23 @@ import {
   listBranches,
   requireBranch,
   setLiveBranch
-} from "./chunk-EQW3YT5U.js";
+} from "./chunk-P6PVBQL6.js";
 import {
   confirm
-} from "./chunk-AIZKXUNP.js";
+} from "./chunk-IMLYGQK6.js";
 import {
   isMachineOutput,
   writeJson
 } from "./chunk-NUQCEOKA.js";
 import {
   getAccessToken
-} from "./chunk-QKM4U5UK.js";
+} from "./chunk-TJS2AF5Y.js";
 import "./chunk-FE5I6S6N.js";
-import "./chunk-3IGNIP6R.js";
+import "./chunk-NDP7OUPS.js";
 import {
   UsageError,
   assertNoForce
-} from "./chunk-F6CYJ7TN.js";
+} from "./chunk-Z2ZIE5CO.js";
 import "./chunk-GNPVYOPB.js";
 import {
   blank,
@@ -29,7 +29,7 @@ import {
   success,
   warn
 } from "./chunk-EZG76F7R.js";
-import "./chunk-DIA7CT7J.js";
+import "./chunk-V5Y7D4LH.js";
 
 // src/emit/branch-commands.ts
 var VERBS = ["list", "set-live", "delete"];
@@ -133,4 +133,4 @@ Promote another branch first (\`xanots workspace branch set-live <other>\`), the
 export {
   runBranchCommand
 };
-//# sourceMappingURL=branch-commands-2BLOC2GR.js.map
+//# sourceMappingURL=branch-commands-5KMPAAZV.js.map

package/dist/bundle.d.ts

@@ -0,0 +1,218 @@
+import { S as StackItemXdo, g as FieldXdo } from './xdo-ODuJklk6.js';
+export { b as ConditionalContext, c as ConditionalElifContext, E as ExprGroup, d as ExprNode, e as ExprOperand, f as ExprStatement, h as FilterXdo, I as InputXdo, M as MethodXdo, k as ResultItemXdo, l as StatementInputXdo, o as TaggedValue } from './xdo-ODuJklk6.js';
+
+/**
+ * The statement catalog, keyed the way a bundle reader needs it.
+ *
+ * A compiled statement identifies itself by its STORED name (`mvp:dbo_view`);
+ * everything a person reads — a docs link, a lint message, a graph node label —
+ * wants the authoring path (`s.db.query`). The mapping is SDK metadata, so a
+ * third-party tool must not have to keep its own copy: a new statement kind
+ * would then need a release in every tool before it stopped rendering as an
+ * unknown node.
+ */
+/** One stored statement name and the authoring surface(s) that compile to it. */
+interface StatementCatalogEntry {
+    /** The stored `mvp:` name, as it appears on a compiled statement's `name`. */
+    readonly storedName: string;
+    /** The primary surface key — the engine's own schema name, e.g. `db.query`. */
+    readonly surface: string;
+    /** The dotted accessor under `s.`, e.g. `db.query` is reachable as `s.db.query`. */
+    readonly sPath: string;
+    /**
+     * Every surface key stored under this name, in catalog order. Almost always
+     * one; the mapping is NOT injective (`util.get_raw_input` and `util.get_input`
+     * both store `mvp:get_input`), so a reader that must not lose a surface reads
+     * this rather than {@link StatementCatalogEntry.surface}.
+     */
+    readonly surfaces: readonly string[];
+}
+/**
+ * Every stored statement name the SDK knows, mapped to its authoring surface.
+ *
+ * Built once and shared — the returned map is frozen in the sense that it is the
+ * same instance on every call, so a caller must not mutate it.
+ *
+ * `raw()` is deliberately absent: it is the passthrough for stored statements
+ * the catalog cannot model, so a `name` that misses here is exactly the set a
+ * tool should render as opaque.
+ */
+declare function statementCatalog(): ReadonlyMap<string, StatementCatalogEntry>;
+
+/**
+ * Statement-tree traversal for a compiled bundle.
+ *
+ * A stack is a `run[]` of {@link StackItemXdo} envelopes, and a statement that
+ * nests carries its children under `context` — never under a single key. A
+ * conditional stores `if.run` / `elif.run` / `else.run`, a try/catch reuses the
+ * same three keys for `try` / `catch` / `finally`, a switch stores its cases
+ * under `elif.run` and its default under `else.run`, and every loop, group and
+ * transaction stores a bare `context.run`.
+ *
+ * A tool that hardcodes that key set drops a subtree silently the day the engine
+ * adds a nesting shape, so {@link subStacks} does not hardcode it: it finds a
+ * sub-stack by SHAPE — any `context` member that is a `{run: [...]}` object,
+ * plus `context.run` itself. {@link SUB_STACK_KEYS} is exported as the set known
+ * today, and it fixes the ORDER discovery reports; a key outside it is still
+ * found, reported after the known ones, in `context` order.
+ */
+
+/**
+ * The `context` keys that hold a nested stack today, in the order
+ * {@link subStacks} reports them. The order is the authoring order for every
+ * statement that nests: `if` before `elif` before `else` for a conditional,
+ * try before catch before finally for a try/catch, cases before default for a
+ * switch.
+ *
+ * This is a reference set, not a filter — see the module note.
+ */
+declare const SUB_STACK_KEYS: readonly string[];
+/** One nested stack hanging off a statement's `context`. */
+interface SubStack {
+    /** The `context` key the stack is stored under (`if`, `elif`, `else`, `then`, `run`). */
+    readonly key: string;
+    /**
+     * What the branch means at the authoring surface — `try`/`catch`/`finally` for
+     * a try/catch, `cases`/`default` for a switch, `body` for a loop. Falls back
+     * to the key for a statement with no recorded mapping.
+     */
+    readonly label: string;
+    /** The nested statements, in run order. */
+    readonly run: readonly StackItemXdo[];
+}
+/** A statement reached by {@link walk}, with its address and nesting depth. */
+interface WalkedStatement {
+    /** The statement envelope, by reference — not a copy. */
+    readonly raw: StackItemXdo;
+    /**
+     * The statement's address within the stack it was walked from — see
+     * {@link statementPath}. `"2"` is the third top-level statement; `"2.if.0"` is
+     * the first statement of its `if` branch.
+     */
+    readonly path: string;
+    /** Nesting depth: `0` for a top-level statement, `1` inside one sub-stack, and so on. */
+    readonly depth: number;
+}
+/**
+ * Every nested stack a statement carries, in canonical order.
+ *
+ * Returns an empty array for a leaf statement. A sub-stack stored empty
+ * (`elif: {run: []}`, which the engine always persists on a conditional) is
+ * REPORTED with an empty `run` rather than skipped — the branch exists in the
+ * bytes, and a tool that renders branches wants to know the difference between
+ * "no elif" and "an elif that does nothing".
+ */
+declare function subStacks(raw: StackItemXdo): SubStack[];
+/**
+ * Join path segments into a statement path.
+ *
+ * The format is dot-separated, alternating an index with the `context` key that
+ * contains the next level: `2` is the third top-level statement, `2.if.0` is the
+ * first statement of its `if` branch, `2.elif.0.if.1` is the second statement of
+ * its first elif branch. The KEY is used, not the label, so the path addresses
+ * the stored bytes and stays stable if an authoring name changes.
+ *
+ * One shared address is the point: a lint finding, a review comment and a
+ * runtime error written by three different tools all name the same node.
+ */
+declare function statementPath(segments: readonly (string | number)[]): string;
+/**
+ * Walk a stack depth-first in pre-order — every statement, then its sub-stacks
+ * in {@link subStacks} order.
+ *
+ * A statement that is itself a branch carrier (`mvp:conditional_elif`,
+ * `mvp:switch_case`) is a stack item like any other, so it is VISITED and then
+ * descended into. A tool counting statements should filter those out; a tool
+ * addressing nodes wants them present.
+ *
+ * Iterative rather than recursive: a generated stack can nest deep enough to
+ * blow the call stack, and a bundle reader must not be the thing that crashes.
+ */
+declare function walk(run: readonly StackItemXdo[]): WalkedStatement[];
+
+/**
+ * A structural fingerprint for a compiled statement — the thing a diff, a cache
+ * key or a "did this change" check wants, and the thing a byte comparison is
+ * not.
+ *
+ * Two reductions run before the hash:
+ *
+ * 1. {@link normalize}, the same normalizer the SDK uses for fixture comparison
+ *    and for the `xanots preflight` round-trip diff. It strips server-assigned
+ *    identity (`_xsid`, `id`, timestamps, `market_item`) and canonicalizes the
+ *    spellings the engine persists two ways.
+ * 2. Engine-filled `input[]` slots — the entries carrying `ignore: true`.
+ *
+ * The second one is the whole reason this is not just `sha1(normalize(x))`. A
+ * "full" statement (`db.add`, `db.edit`, `api.request`) persists one `input[]`
+ * entry per column of the table it writes, and the ones the author did not set
+ * carry `ignore: true`. Add a column to a table and EVERY statement that writes
+ * it gains an entry — so an unfiltered diff reports that every one of them
+ * changed, when what changed was the table. Filtered, the same diff reports the
+ * one object that actually changed.
+ *
+ * The normalizer deliberately KEEPS `ignore: true` (it is meaningful bytes on a
+ * system column, and the normalizer's job is byte fidelity — it must not drop
+ * what it cannot prove inert). That is not a contradiction: byte fidelity and
+ * structural identity are different questions, so they get different reductions.
+ * If you need the byte-level answer, hash `normalize()` yourself.
+ */
+
+/**
+ * JSON with every object's keys sorted — so two statements that differ only in
+ * the order the engine happened to serialize their members hash the same.
+ */
+declare function canonicalJson(value: unknown): string;
+/**
+ * A stable hex fingerprint of a statement AND everything nested under it.
+ *
+ * Equal hashes mean the two statements do the same thing; different hashes mean
+ * something an author wrote differs. The value is stable across SDK versions
+ * only as far as the normalizer is — treat it as a comparison key computed in
+ * one pass over both sides, not as a value to persist and compare next year.
+ */
+declare function structuralHash(raw: StackItemXdo): string;
+
+/**
+ * Reading table relationships out of a stored column.
+ *
+ * Both are storage details a schema view needs and nothing else states, so they
+ * have been reverse-engineered once per tool up to now.
+ */
+
+/**
+ * The table a foreign-key column points at, as a guid — or `null` if the column
+ * is not a reference.
+ *
+ * A reference is an `int` or `uuid` column whose LAST method is `@` with a
+ * single `dbo=<guid>` argument. The position matters: `@` is an annotation the
+ * engine appends, and reading any `@` in the list would misread a column that
+ * carries one for another reason.
+ *
+ * A bare `dbo=` returns `null`. That is what the editor writes when a reference
+ * is CLEARED — an FK annotation pointing at nothing, which is not a reference.
+ */
+declare function tableRefOf(column: FieldXdo): string | null;
+/**
+ * The table a db-link column expands, as a guid — or `null` if the column is not
+ * one.
+ *
+ * The other table relationship, and a different shape entirely: the column's
+ * TYPE is the table's identity with `_mvpschema` appended, and the engine
+ * expands the link into one input per column of the named table. A schema view
+ * that only reads {@link tableRefOf} misses these edges.
+ */
+declare function linkedTableOf(column: FieldXdo): string | null;
+
+/**
+ * Structural deep-equal for comparing an engine-default subtree to a frozen
+ * default — and, exported, for comparing two normalized objects.
+ *
+ * Exported so a caller that has already normalized both sides does not carry its
+ * own copy of the same walk; a second implementation is a second set of rules
+ * about what "equal" means.
+ */
+declare function deepEqual(a: unknown, b: unknown): boolean;
+declare function normalize<T>(value: T): T;
+
+export { FieldXdo, SUB_STACK_KEYS, StackItemXdo, type StatementCatalogEntry, type SubStack, type WalkedStatement, canonicalJson, deepEqual, linkedTableOf, normalize, statementCatalog, statementPath, structuralHash, subStacks, tableRefOf, walk };

package/dist/bundle.js

@@ -0,0 +1,143 @@
+import {
+  linkedTableOf,
+  tableRefOf
+} from "./chunk-EHP3WPEG.js";
+import {
+  deepEqual,
+  normalize
+} from "./chunk-AE3PDSDS.js";
+import {
+  STATEMENT_SURFACES,
+  sPathOf
+} from "./chunk-DCMANKMX.js";
+import {
+  sha1Bytes
+} from "./chunk-OHX6MIUZ.js";
+
+// src/bundle/catalog.ts
+var cached;
+function statementCatalog() {
+  if (cached) return cached;
+  const map = /* @__PURE__ */ new Map();
+  for (const [surface, storedName] of STATEMENT_SURFACES) {
+    const existing = map.get(storedName);
+    if (existing) {
+      map.set(storedName, { ...existing, surfaces: [...existing.surfaces, surface] });
+      continue;
+    }
+    map.set(storedName, {
+      storedName,
+      surface,
+      sPath: sPathOf(surface),
+      surfaces: [surface]
+    });
+  }
+  cached = map;
+  return map;
+}
+
+// src/bundle/walk.ts
+var SUB_STACK_KEYS = ["if", "elif", "else", "then", "run"];
+var SUB_STACK_LABELS = {
+  "mvp:conditional": { if: "then", elif: "elif", else: "else" },
+  "mvp:conditional_elif": { if: "then" },
+  "mvp:switch": { elif: "cases", else: "default" },
+  "mvp:switch_case": { if: "body" },
+  "mvp:try_catch": { if: "try", else: "catch", then: "finally" }
+};
+var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+function runOf(value) {
+  if (!isRecord(value)) return null;
+  const run = value.run;
+  return Array.isArray(run) ? run : null;
+}
+function subStacks(raw) {
+  const context = raw?.context;
+  if (!isRecord(context)) return [];
+  const labels = SUB_STACK_LABELS[raw.name] ?? {};
+  const found = [];
+  const push = (key, value) => {
+    const run = key === "run" ? Array.isArray(value) ? value : null : runOf(value);
+    if (!run) return;
+    found.push({ key, label: labels[key] ?? (key === "run" ? "body" : key), run });
+  };
+  for (const key of SUB_STACK_KEYS) {
+    if (Object.hasOwn(context, key)) push(key, context[key]);
+  }
+  for (const key of Object.keys(context)) {
+    if (!SUB_STACK_KEYS.includes(key)) push(key, context[key]);
+  }
+  return found;
+}
+function statementPath(segments) {
+  return segments.join(".");
+}
+function walk(run) {
+  const out = [];
+  const pending = [];
+  for (let i = run.length - 1; i >= 0; i--) {
+    pending.push({ raw: run[i], path: statementPath([i]), depth: 0 });
+  }
+  while (pending.length > 0) {
+    const frame = pending.pop();
+    out.push(frame);
+    const children = [];
+    for (const sub of subStacks(frame.raw)) {
+      for (let i = 0; i < sub.run.length; i++) {
+        children.push({
+          raw: sub.run[i],
+          path: statementPath([frame.path, sub.key, i]),
+          depth: frame.depth + 1
+        });
+      }
+    }
+    for (let i = children.length - 1; i >= 0; i--) pending.push(children[i]);
+  }
+  return out;
+}
+
+// src/bundle/hash.ts
+var isRecord2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+function withoutIgnoredInputs(value) {
+  if (Array.isArray(value)) return value.map(withoutIgnoredInputs);
+  if (!isRecord2(value)) return value;
+  const out = {};
+  for (const [key, member] of Object.entries(value)) {
+    if (key === "input" && Array.isArray(member)) {
+      out[key] = member.filter((entry) => !(isRecord2(entry) && entry.ignore === true)).map(withoutIgnoredInputs);
+      continue;
+    }
+    out[key] = withoutIgnoredInputs(member);
+  }
+  return out;
+}
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (isRecord2(value)) {
+    const parts = Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`);
+    return `{${parts.join(",")}}`;
+  }
+  return value === void 0 ? "null" : JSON.stringify(value);
+}
+var HEX = "0123456789abcdef";
+function structuralHash(raw) {
+  const reduced = withoutIgnoredInputs(normalize(raw));
+  const bytes = sha1Bytes(canonicalJson(reduced));
+  let hex = "";
+  for (const byte of bytes) hex += HEX[byte >> 4] + HEX[byte & 15];
+  return hex;
+}
+export {
+  SUB_STACK_KEYS,
+  canonicalJson,
+  deepEqual,
+  linkedTableOf,
+  normalize,
+  statementCatalog,
+  statementPath,
+  structuralHash,
+  subStacks,
+  tableRefOf,
+  walk
+};
+//# sourceMappingURL=bundle.js.map

package/dist/{capture-4WVJY4DQ.js → capture-YLUVAITI.js}

@@ -1,6 +1,6 @@
 import {
   fixtureDirForKind
-} from "./chunk-TCFIPDB3.js";
+} from "./chunk-AVGDL6RB.js";
 
 // src/validate/capture.ts
 import { mkdirSync, writeFileSync } from "fs";
@@ -29,4 +29,4 @@ function safeName(name) {
 export {
   captureFixtures
 };
-//# sourceMappingURL=capture-4WVJY4DQ.js.map
+//# sourceMappingURL=capture-YLUVAITI.js.map