@xanots/sdk 0.0.9 → 0.0.11

package/CHANGELOG.md

@@ -11,6 +11,40 @@ listed here.
 
 ---
 
+## 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)
+
+Eight reports, all from one round of real-world use, and every one of them a case that type-checks, exports under `--strict` and deploys clean before going wrong. The headline is a deploy that could not succeed at all: any seeded number below `1e-4` failed the import with a signature error that named nothing. The rest correct places where the docs described behavior the engine does not have — a search operator that silently matches nothing, a by-id read that rejects the sentinel the field docs prescribe, and a seeding question whose two possible answers demanded opposite designs.
+
+- Seed data holding a number below `1e-4` no longer fails the deploy
+- ⚠️ Every test JSON document puts its per-test array under `tests`
+- `like` and `ilike` match nothing for a bare term — reach for `includes`
+- `db.get_by_id` rejects the `0` optional-FK sentinel, and takes the whole request with it
+- A seeded `f.password()` column IS hashed, so demo credentials work as fixtures
+- Native email is discoverable, and the built-in provider needs no configuration
+- A relative entry path names the directory it resolved against
+- Three fields the docs called plain values take tagged ones
+
+---
+
 ## 0.0.8 — The auth() lookalike
 
 _2026-08-30_ · [release notes](https://github.com/xanots/sdk/releases/tag/v0.0.8)

package/README.md

@@ -119,17 +119,17 @@ The starter backend is empty but already compiles and deploys — grow it from t
 in `xano/EXAMPLE.md`. For the flags, the two presets, theming, and add-ons, see
 [The scaffolded project](https://github.com/xanots/sdk/blob/main/guides/scaffold.md).
 
-Prefer to see the theme before you commit to it? `xanots onboard` picks the framework, the
-palette, the typefaces and the add-ons in a browser, against a live preview, and hands the
-result back to `init` here in your terminal.
+Prefer to see the theme before you commit to it? `--web` picks the framework, the palette,
+the typefaces and the add-ons in a browser, against a live preview, and hands the result
+back to `init` here in your terminal.
 
 ```bash
-npx @xanots/sdk onboard my-app
+npx @xanots/sdk init my-app --web
 ```
 
 It is a nicer way to arrive at the flags above, not a second scaffolder — it prints the
 equivalent `init` command when it is done, so the project stays reproducible from a script.
-The configurator is downloaded on demand, so `onboard` needs the registry before it can
+The configurator is downloaded on demand, so `--web` needs the registry before it can
 start; `init` reaches out only to install the new project's dependencies, which
 `--no-install` skips.
 
@@ -263,7 +263,7 @@ statements, values, inputs, and middleware are all in the
 
 | Command | Where it goes |
 |---|---|
-| `xanots deploy` | A disposable **ephemeral** environment (default) — create-or-refreshed each run, auto-expiring, with its own URL. `--dest sandbox` targets your throwaway singleton instead. |
+| `xanots deploy` | A disposable **ephemeral** environment — create-or-refreshed each run, auto-expiring, with its own URL. There is no other destination and no flag to choose one. |
 | `xanots release` | Your **main Xano instance** workspace — the production target. **Merges** by default: objects are updated in place or added, and your table data is never touched unless you ask. |
 
 Every `deploy` is a **full replace** of the disposable environment — always fresh, no merge
@@ -277,10 +277,15 @@ change, and asks. `--yes` skips the prompt for CI but never skips the preview. S
 `xanots release ./xano/index.ts --dry-run` to see the plan without committing to it.
 
 > ⚠️ A deploy is a full replace of the target environment, **including its table records**,
-> before importing. The blast radius is your own disposable ephemeral or sandbox — but
+> before importing. The blast radius is your own disposable ephemeral — but
 > anything you only ever created by hand in it is gone. That is exactly why production has a
 > separate `release` path.
 
+`xanots status` answers where you stand in one read — who you are signed in as, which
+instance and workspace your credential is bound to, and the environment this project last
+deployed to, including whether it is still alive and when it expires. You never have to
+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>`.
@@ -291,8 +296,9 @@ The tests you author — a `tests` entry on a query, function, or middleware, or
 `workflowTest()` — run against a deployed environment:
 
 ```bash
-npx xanots test run-all                    # the ephemeral you last deployed to
-npx xanots test run-all --dest workspace   # or your real workspace (this only reads)
+npx xanots test run-all                       # the ephemeral you last deployed to
+npx xanots test run-all --env ephemeral:pr-3  # or a named one
+npx xanots test run-all --env workspace       # or your real workspace (this only reads)
 ```
 
 `xanots test list` shows what is there without running it, and `xanots test run "<name>"`
@@ -344,7 +350,7 @@ Importing a def carries the SDK runtime with it. When that matters, emit a route
 instead — plain data plus one interpolator, importing nothing:
 
 ```bash
-xanots paths ./xano/index.ts --emit xano/routes.gen.ts
+xanots routes ./xano/index.ts --emit xano/routes.gen.ts
 ```
 
 Route names and their `{param}` keys are still checked at compile time, so a backend rename
@@ -356,21 +362,22 @@ rules, endpoint-name constraints, and the realtime helpers are in
 
 ## Already have a Xano workspace?
 
-`codegen` runs the loop the other way: it reads a workspace and writes it back out as
+`--from` runs the loop the other way: it reads a workspace and writes it back out as
 readable XanoTS source — real `s.db.query(...)`, `f.email()`, typed defs — not a JSON dump.
-And not a loose pile of files either: you get the same runnable project `xanots init`
-scaffolds, with the pulled workspace filling `xano/`. So a pull deploys:
+And not a loose pile of files either: it is the same runnable project `xanots init`
+scaffolds, with the pulled workspace filling `xano/` instead of the starter. So a pull
+deploys:
 
 ```bash
-xanots workspace codegen my-app   # your real workspace (the one your login is scoped to)
+xanots init my-app --from workspace   # your real workspace (the one your login is scoped to)
 cd my-app
 npm run build
-npm run xano:deploy               # → a live ephemeral URL
+npm run xano:deploy                   # → a live ephemeral URL
 ```
 
-The other three sources are the same command with a different origin — `xanots sandbox
-codegen`, `xanots ephemeral codegen`, and `xanots codegen ws.json` for a bundle already on
-disk (offline, no login).
+The other two sources are the same flag with a different value — `--from ephemeral:<name>`,
+and `--from ./ws.json` for a bundle already on disk (offline, no login). Everything else about the project is unchanged, so `--theme`, `--ai` and `--web`
+compose with a pull exactly as they do with a starter.
 
 Object identities are preserved, so cross-references stay intact, and a statement this SDK
 does not model yet round-trips verbatim rather than breaking the pull. Then it checks its own
@@ -379,7 +386,7 @@ from, so "it compiled" and "it means the same thing" are separate claims and you
 
 > ⚠️ **`xano/` is a scratch surface.** Regenerating rewrites it, it carries schema only — no
 > table rows — and deploying it is a *full replace* of the target. Pull from your real
-> workspace, edit, and `deploy` to a disposable ephemeral or sandbox. Workspace env var
+> workspace, edit, and `deploy` to a disposable ephemeral. Workspace env var
 > **values** ride inline in `xano/workspace.ts`, so treat a pulled tree as secret-bearing
 > before you commit it.
 
@@ -401,12 +408,50 @@ reference, the guides carry the shape of a project and the behavior that will bi
 | [Object kinds](https://github.com/xanots/sdk/blob/main/guides/object-kinds.md) | Every authorable kind, and splitting a workspace across microservices |
 | [Authoring reference](https://github.com/xanots/sdk/blob/main/guides/authoring.md) | Tables and fields, statements, values, inputs, middleware, seed data |
 | [CLI](https://github.com/xanots/sdk/blob/main/guides/cli.md) | Every command, shell completion, and what failures look like |
-| [Signing in & deploying](https://github.com/xanots/sdk/blob/main/guides/deploying.md) | Auth, ephemerals, `--static`, releasing to production, `xanots validate` |
+| [Signing in & deploying](https://github.com/xanots/sdk/blob/main/guides/deploying.md) | Auth, ephemerals, `--static`, releasing to production, `xanots preflight` |
 | [Environment & identity](https://github.com/xanots/sdk/blob/main/guides/environment.md) | Every environment variable, and how `xano.lock` pins identity |
 | [The typed frontend surface](https://github.com/xanots/sdk/blob/main/guides/typed-frontend.md) | Path resolution, input/response inference, bundle cost, the route manifest |
-| [Pulling an existing workspace](https://github.com/xanots/sdk/blob/main/guides/codegen.md) | What `xanots codegen` writes, how faithful it is, and how to read its report |
+| [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 (`s.db.query`).
+- **`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 @@
-6be27443d5fbd10d871e0401f52565ed89d47edcc49810206bbf1efb9497f539
+6e6a4444f6fc73ee75afa9e72fb57b1ac2592d33d6b9a99205023fcbaccf8ed8

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

@@ -3,8 +3,8 @@ import {
   codingAgentDetected,
   isCI,
   refreshAgentFiles
-} from "./chunk-QIWBCS7N.js";
-import "./chunk-4PE4ZAB7.js";
+} from "./chunk-JGCWTCA7.js";
+import "./chunk-KA6G2L7U.js";
 import "./chunk-ZSYZTGJH.js";
 import "./chunk-Q77KNEUL.js";
 import "./chunk-EZG76F7R.js";
@@ -14,4 +14,4 @@ export {
   isCI,
   refreshAgentFiles
 };
-//# sourceMappingURL=agent-file-refresh-4W37DGXS.js.map
+//# sourceMappingURL=agent-file-refresh-QNKN5RYD.js.map

package/dist/bin.js

@@ -1,27 +1,29 @@
 #!/usr/bin/env node
 import {
   maybeNotifyUpdate
-} from "./chunk-OW2QZEWL.js";
+} from "./chunk-22TKBSDV.js";
 import {
   readVersion,
   run
-} from "./chunk-K3YSQDXJ.js";
+} from "./chunk-RCT7UX7B.js";
+import "./chunk-CTD5ZCV6.js";
+import "./chunk-XEOX6AM7.js";
 import {
   exitCodeOf,
   reportFailure
-} from "./chunk-JQLR64UC.js";
-import "./chunk-OYMR5AMJ.js";
+} from "./chunk-F6CYJ7TN.js";
 import "./chunk-GNPVYOPB.js";
 import {
   clearProgress,
   error
 } from "./chunk-EZG76F7R.js";
-import "./chunk-UDL46O35.js";
-import "./chunk-OKNSR7MT.js";
-import "./chunk-QONOJO45.js";
+import "./chunk-OWGCOGKK.js";
+import "./chunk-DIA7CT7J.js";
+import "./chunk-QK7ZQJLP.js";
 import "./chunk-WHOJWOSV.js";
+import "./chunk-VAF6A3YD.js";
 import "./chunk-5XZ744TS.js";
-import "./chunk-7JDT4PBU.js";
+import "./chunk-OHX6MIUZ.js";
 
 // src/emit/interrupt.ts
 var EXIT_SIGINT = 130;

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

@@ -6,19 +6,20 @@ import {
 } from "./chunk-EQW3YT5U.js";
 import {
   confirm
-} from "./chunk-4PTSTDIG.js";
-import {
-  getAccessToken
-} from "./chunk-3QW5NFZJ.js";
-import "./chunk-BKDJN76G.js";
+} from "./chunk-AIZKXUNP.js";
 import {
   isMachineOutput,
   writeJson
 } from "./chunk-NUQCEOKA.js";
+import {
+  getAccessToken
+} from "./chunk-QKM4U5UK.js";
+import "./chunk-FE5I6S6N.js";
 import "./chunk-3IGNIP6R.js";
 import {
-  UsageError
-} from "./chunk-JQLR64UC.js";
+  UsageError,
+  assertNoForce
+} from "./chunk-F6CYJ7TN.js";
 import "./chunk-GNPVYOPB.js";
 import {
   blank,
@@ -28,7 +29,7 @@ import {
   success,
   warn
 } from "./chunk-EZG76F7R.js";
-import "./chunk-OKNSR7MT.js";
+import "./chunk-DIA7CT7J.js";
 
 // src/emit/branch-commands.ts
 var VERBS = ["list", "set-live", "delete"];
@@ -60,6 +61,7 @@ function renderList(branches, workspaceId) {
   detail("Branches scope logic. Tables and microservices are shared by every branch.");
 }
 async function runBranchCommand(args) {
+  assertNoForce(args.force, "workspace", "branch");
   const verb = assertVerb(args.positionals[0]);
   const auth = await getAccessToken(args);
   const workspaceId = auth.workspaceId;
@@ -87,7 +89,7 @@ async function runBranchCommand(args) {
     if (outgoing !== void 0) detail(`The runtime stops serving "${outgoing}" and starts serving "${label}".`);
     detail("Table data is unaffected \u2014 it is shared by every branch either way.");
     blank();
-    if (!args.yes && !args.force) {
+    if (!args.yes) {
       const ok = await confirm(`Make "${label}" the live branch?`, {
         flag: "--yes",
         helpFor: { command: "workspace", subcommand: "branch" }
@@ -114,7 +116,7 @@ Promote another branch first (\`xanots workspace branch set-live <other>\`), the
       { helpFor: { command: "workspace", subcommand: "branch" } }
     );
   }
-  if (!args.yes && !args.force) {
+  if (!args.yes) {
     const ok = await confirm(`Delete branch "${label}" from workspace #${workspaceId}?`, {
       flag: "--yes",
       helpFor: { command: "workspace", subcommand: "branch" }
@@ -131,4 +133,4 @@ Promote another branch first (\`xanots workspace branch set-live <other>\`), the
 export {
   runBranchCommand
 };
-//# sourceMappingURL=branch-commands-PBQ36L4A.js.map
+//# sourceMappingURL=branch-commands-2BLOC2GR.js.map

package/dist/bundle.d.ts

@@ -0,0 +1,218 @@
+import { S as StackItemXdo, g as FieldXdo } from './xdo-BjJj5W_E.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-BjJj5W_E.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 };