@xano/sdk 1.0.0

package/dist/backend-dir-2U53CIAL.js

@@ -0,0 +1,39 @@
+import {
+  backendDirFor,
+  backendDirIn,
+  resolveBackendDir
+} from "./chunk-5A2PLKZB.js";
+import "./chunk-AHJWCYQO.js";
+import "./chunk-DX4QR4B2.js";
+import "./chunk-6QXLMMT3.js";
+import "./chunk-ZFDZKNGG.js";
+import "./chunk-FWD7AL6N.js";
+import "./chunk-2GNFDZA2.js";
+import "./chunk-JTUKLCXS.js";
+import "./chunk-4KHEMC32.js";
+import {
+  projectRootFrom
+} from "./chunk-ROY4YAEQ.js";
+import "./chunk-WRBKLYSJ.js";
+import "./chunk-3LDULPRE.js";
+import "./chunk-YLDALTWZ.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-UCQ2VUTG.js";
+import "./chunk-DGWHAVRG.js";
+import "./chunk-PTHVMXZI.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-OHX6MIUZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  backendDirFor,
+  backendDirIn,
+  projectRootFrom,
+  resolveBackendDir
+};
+//# sourceMappingURL=backend-dir-2U53CIAL.js.map

package/dist/backend-slot-7QXW2QYC.js

@@ -0,0 +1,28 @@
+import {
+  allBackendSlots,
+  backendSlot,
+  backendSlotForFlag,
+  commandPath,
+  parseSlot,
+  refusedKind,
+  requireBackendSlot,
+  slotValueMissing
+} from "./chunk-STSFNCY4.js";
+import "./chunk-PTHVMXZI.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  allBackendSlots,
+  backendSlot,
+  backendSlotForFlag,
+  commandPath,
+  parseSlot,
+  refusedKind,
+  requireBackendSlot,
+  slotValueMissing
+};
+//# sourceMappingURL=backend-slot-7QXW2QYC.js.map

package/dist/bin.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+import {
+  maybeNotifyUpdate
+} from "./chunk-LIEOKXKD.js";
+import "./chunk-D7VGG3WS.js";
+import "./chunk-2TFRR6JV.js";
+import {
+  readVersion,
+  run
+} from "./chunk-ETO6LGLD.js";
+import "./chunk-ZIY7RNUT.js";
+import "./chunk-DAD3ONIS.js";
+import "./chunk-HHN734BU.js";
+import "./chunk-LPECSJ2J.js";
+import "./chunk-6NNTNXN7.js";
+import "./chunk-QCNYHBL7.js";
+import "./chunk-2ZUEE4EK.js";
+import "./chunk-AN6BL47T.js";
+import "./chunk-ET4Y4XCB.js";
+import "./chunk-SWBF2LTK.js";
+import "./chunk-UZ6QQWJT.js";
+import "./chunk-A3UDOZB6.js";
+import "./chunk-2MNLRIOX.js";
+import "./chunk-3M4LFYNQ.js";
+import "./chunk-AM4FKL4J.js";
+import "./chunk-Q325JKYB.js";
+import "./chunk-STSFNCY4.js";
+import "./chunk-I4F5TCJH.js";
+import "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import "./chunk-7G3CTU7I.js";
+import "./chunk-6PBR37LN.js";
+import "./chunk-T5KELPAR.js";
+import "./chunk-622HUCZT.js";
+import "./chunk-NAQDMEHV.js";
+import "./chunk-5A2PLKZB.js";
+import "./chunk-AHJWCYQO.js";
+import "./chunk-DX4QR4B2.js";
+import "./chunk-6QXLMMT3.js";
+import "./chunk-ZFDZKNGG.js";
+import "./chunk-FWD7AL6N.js";
+import "./chunk-2GNFDZA2.js";
+import "./chunk-JTUKLCXS.js";
+import {
+  installSentWriteTracking,
+  landedStep,
+  pendingWrite
+} from "./chunk-4KHEMC32.js";
+import "./chunk-U64O2MXY.js";
+import "./chunk-ROY4YAEQ.js";
+import "./chunk-P2HAGF6H.js";
+import "./chunk-TLQE7ZN3.js";
+import "./chunk-WRBKLYSJ.js";
+import "./chunk-3LDULPRE.js";
+import "./chunk-XW6KISBB.js";
+import {
+  installSecretRedaction,
+  redactSecrets
+} from "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-OPHB5ORL.js";
+import "./chunk-UCQ2VUTG.js";
+import "./chunk-DGWHAVRG.js";
+import "./chunk-JGE7CAWB.js";
+import {
+  EXIT_OUTCOME_UNKNOWN,
+  activeOperation,
+  clearProgress,
+  detail,
+  error,
+  failureWritesDocument,
+  installCliDiagnosticSink,
+  installCliPrefix,
+  installStdoutPipeGuard,
+  interruptDocumentText,
+  interruptedRunDocumentExitCode,
+  interruptedRunFinished,
+  interruptedRunWroteDocument,
+  processExitCode,
+  reportFailure,
+  success
+} from "./chunk-PTHVMXZI.js";
+import "./chunk-MXHSQOC4.js";
+import "./chunk-6IUMKYWI.js";
+import "./chunk-2CMJZDCL.js";
+import "./chunk-CTMO46PK.js";
+import "./chunk-ZDPP6RKB.js";
+import "./chunk-K5BBGTYZ.js";
+import "./chunk-LQCMKAJ7.js";
+import "./chunk-YGZHHAAB.js";
+import "./chunk-XVBGLISP.js";
+import "./chunk-6HO3NCSJ.js";
+import "./chunk-5V5XU32D.js";
+import "./chunk-GSGDWJB5.js";
+import "./chunk-HVRUQXGD.js";
+import "./chunk-ERVIASGL.js";
+import "./chunk-4POWHT2K.js";
+import "./chunk-H2V3N23D.js";
+import "./chunk-3JDU4VRL.js";
+import "./chunk-WTPZRR4I.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-6MR5TI5V.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-XNCP4KYO.js";
+import "./chunk-AKNCFVKZ.js";
+import "./chunk-YU4HSQW7.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-G554NZNI.js";
+import "./chunk-N5GKCWE5.js";
+import "./chunk-OXA6PSZT.js";
+import "./chunk-VAX3UZOY.js";
+import "./chunk-NZOWWHU5.js";
+import "./chunk-4BW2SG2N.js";
+import "./chunk-TTEIYD5P.js";
+import "./chunk-CIMQZRRE.js";
+import "./chunk-OHX6MIUZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/emit/interrupt.ts
+import { writeSync } from "fs";
+var EXIT_SIGINT = 130;
+var SIGNAL_EXIT = { SIGINT: EXIT_SIGINT, SIGTERM: 143, SIGHUP: 129 };
+function writeStdoutSync(text) {
+  try {
+    writeSync(1, text);
+  } catch {
+    process.stdout.write(text);
+  }
+}
+function handleInterrupt(exit = process.exit, writeStdout = writeStdoutSync, signal = "SIGINT", argv2 = process.argv.slice(2)) {
+  let code = SIGNAL_EXIT[signal];
+  try {
+    clearProgress();
+    const write = (doc) => writeStdout(redactSecrets(interruptDocumentText(doc)));
+    const landed = landedStep();
+    const op = activeOperation();
+    if (op === void 0 || !op.writeSent) {
+      const sent = pendingWrite();
+      if (sent === void 0 && op === void 0 && interruptedRunFinished()) {
+        code = runExitCode();
+        return;
+      }
+      const reported = interruptedRunDocumentExitCode();
+      if (sent === void 0 && landed === void 0 && reported !== void 0) {
+        code = reported;
+        return;
+      }
+      if (sent === void 0) {
+        reportCancelled(signal, code, landed, argv2, write);
+        return;
+      }
+      code = EXIT_OUTCOME_UNKNOWN;
+      reportSentWrite(sent, landed, argv2, write);
+      return;
+    }
+    code = EXIT_OUTCOME_UNKNOWN;
+    if (op.machine) {
+      let doc;
+      try {
+        doc = withLanded(op.snapshot({ interrupted: true }), landed);
+      } catch {
+        doc = void 0;
+      }
+      if (doc !== void 0) write(doc);
+    }
+    if (landed !== void 0) success(landed.said);
+    error(`Interrupted: ${op.what ?? "the write"} was already sent and may have completed.`);
+    detail(`Check with \`${op.resolveWith}\` before retrying.`);
+  } catch {
+  } finally {
+    exit(code);
+  }
+}
+function runExitCode() {
+  const set = process.exitCode;
+  const n = typeof set === "number" ? set : typeof set === "string" ? Number(set) : 0;
+  return Number.isInteger(n) ? n : 0;
+}
+function withLanded(doc, landed) {
+  if (landed === void 0 || typeof doc !== "object" || doc === null || Array.isArray(doc)) return doc;
+  return { ...landed.fields, ...doc, landed: landed.said };
+}
+function reportCancelled(signal, code, landed, argv2, write) {
+  const head = signal === "SIGINT" ? "Cancelled." : `Stopped by ${signal}.`;
+  const after = landed === void 0 ? void 0 : landed.ifCancelled ?? landed.said;
+  const wantsDocument = landed === void 0 ? argv2.includes("--json") : failureWritesDocument(argv2);
+  if (wantsDocument && !interruptedRunWroteDocument()) {
+    write({
+      ...landed?.fields,
+      ok: false,
+      outcome: "cancelled",
+      interrupted: true,
+      ...landed === void 0 ? {} : { landed: landed.said },
+      error: { code: "SDK_ERROR", message: after === void 0 ? head : `${head}
+${after}`, exitCode: code }
+    });
+  }
+  error(head);
+  if (after !== void 0) detail(after);
+}
+function reportSentWrite(sent, landed, argv2, write) {
+  const what = sent.what ?? `a write to ${sent.host}`;
+  const head = `Interrupted: ${what} was already ${sent.local === true ? "running" : "sent"} and may have completed.`;
+  const check = sent.check ?? (sent.resolveWith !== void 0 ? `Check with \`${sent.resolveWith}\` before retrying.` : `Check what ${sent.host} now holds before retrying.`);
+  if (failureWritesDocument(argv2) && !interruptedRunWroteDocument()) {
+    write({
+      ...landed?.fields,
+      ok: false,
+      outcome: "unknown",
+      interrupted: true,
+      ...landed === void 0 ? {} : { landed: landed.said },
+      ...sent.resolveWith === void 0 ? {} : { resolveWith: sent.resolveWith },
+      error: {
+        code: "SDK_ERROR",
+        message: [...landed === void 0 ? [] : [landed.said], head, check].join("\n"),
+        exitCode: EXIT_OUTCOME_UNKNOWN
+      }
+    });
+  }
+  if (landed !== void 0) success(landed.said);
+  error(head);
+  detail(check);
+}
+function installInterruptHandler() {
+  for (const signal of Object.keys(SIGNAL_EXIT)) {
+    process.on(signal, () => handleInterrupt(process.exit, writeStdoutSync, signal));
+  }
+}
+
+// src/emit/bin.ts
+import { fileURLToPath } from "url";
+installSecretRedaction(process.stdout);
+installSecretRedaction(process.stderr);
+installInterruptHandler();
+installSentWriteTracking();
+installCliDiagnosticSink();
+installStdoutPipeGuard();
+installCliPrefix(fileURLToPath(import.meta.url));
+var argv = process.argv.slice(2);
+run(argv).then(() => maybeNotifyUpdate()).catch((err) => {
+  reportFailure(err, readVersion(), argv);
+  const code = processExitCode(err);
+  process.exitCode = code;
+  process.stdout.write("", () => process.exit(code));
+});
+//# sourceMappingURL=bin.js.map

package/dist/branch-NCRNWQBQ.js

@@ -0,0 +1,61 @@
+import {
+  BRANCH_LABEL_PATTERN,
+  BranchHttpError,
+  BranchLabelError,
+  BranchNotFoundError,
+  BranchTakenError,
+  DEFAULT_BRANCH_LABEL,
+  assertBranchAbsent,
+  assertUsableBranchLabel,
+  createBranch,
+  deleteBranch,
+  derivedLabelTail,
+  findBranch,
+  freeBranchLabel,
+  listBranchListing,
+  listBranches,
+  liveBranchLabel,
+  requireBranch,
+  setLiveBranch
+} from "./chunk-TRJCALW3.js";
+import "./chunk-2MNLRIOX.js";
+import "./chunk-T5KELPAR.js";
+import "./chunk-622HUCZT.js";
+import "./chunk-NAQDMEHV.js";
+import "./chunk-FWD7AL6N.js";
+import "./chunk-XW6KISBB.js";
+import "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-PTHVMXZI.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  BRANCH_LABEL_PATTERN,
+  BranchHttpError,
+  BranchLabelError,
+  BranchNotFoundError,
+  BranchTakenError,
+  DEFAULT_BRANCH_LABEL,
+  assertBranchAbsent,
+  assertUsableBranchLabel,
+  createBranch,
+  deleteBranch,
+  derivedLabelTail,
+  findBranch,
+  freeBranchLabel,
+  listBranchListing,
+  listBranches,
+  liveBranchLabel,
+  requireBranch,
+  setLiveBranch
+};
+//# sourceMappingURL=branch-NCRNWQBQ.js.map

package/dist/branch-commands-ACIRCEQJ.js

@@ -0,0 +1,79 @@
+import {
+  liveBranchMismatch,
+  liveMismatch,
+  runBranchCommand,
+  shownLabel,
+  staleSchemaRefs
+} from "./chunk-K6RXBGUB.js";
+import "./chunk-65HWOMGV.js";
+import "./chunk-BWPNT55T.js";
+import "./chunk-TPHWJ7UG.js";
+import "./chunk-CJHQKJU4.js";
+import "./chunk-3DRXWLJ5.js";
+import "./chunk-X4DVXBFY.js";
+import "./chunk-TRJCALW3.js";
+import "./chunk-45UIT5T2.js";
+import "./chunk-HRVBLCVJ.js";
+import "./chunk-ZIY7RNUT.js";
+import "./chunk-2ZUEE4EK.js";
+import "./chunk-ET4Y4XCB.js";
+import "./chunk-A3UDOZB6.js";
+import "./chunk-2MNLRIOX.js";
+import "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import "./chunk-7G3CTU7I.js";
+import "./chunk-6PBR37LN.js";
+import "./chunk-T5KELPAR.js";
+import "./chunk-622HUCZT.js";
+import "./chunk-NAQDMEHV.js";
+import "./chunk-FWD7AL6N.js";
+import "./chunk-4KHEMC32.js";
+import "./chunk-TLQE7ZN3.js";
+import "./chunk-XW6KISBB.js";
+import "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-3YW23UFH.js";
+import "./chunk-PTHVMXZI.js";
+import "./chunk-2CMJZDCL.js";
+import "./chunk-K5BBGTYZ.js";
+import "./chunk-6HO3NCSJ.js";
+import "./chunk-5V5XU32D.js";
+import "./chunk-ERVIASGL.js";
+import "./chunk-4POWHT2K.js";
+import "./chunk-H2V3N23D.js";
+import "./chunk-3JDU4VRL.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-6MR5TI5V.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-XNCP4KYO.js";
+import "./chunk-YU4HSQW7.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-EHP3WPEG.js";
+import "./chunk-L5JYN3NM.js";
+import "./chunk-G554NZNI.js";
+import "./chunk-N5GKCWE5.js";
+import "./chunk-OXA6PSZT.js";
+import "./chunk-VAX3UZOY.js";
+import "./chunk-NZOWWHU5.js";
+import "./chunk-4BW2SG2N.js";
+import "./chunk-TTEIYD5P.js";
+import "./chunk-CIMQZRRE.js";
+import "./chunk-OHX6MIUZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  liveBranchMismatch,
+  liveMismatch,
+  runBranchCommand,
+  shownLabel,
+  staleSchemaRefs
+};
+//# sourceMappingURL=branch-commands-ACIRCEQJ.js.map

package/dist/bundle.d.ts

@@ -0,0 +1,223 @@
+import { S as StackItemXdo, F as FieldXdo } from './xdo-CxDr2Q1C.js';
+export { c as ConditionalContext, d as ConditionalElifContext, E as ExprGroup, f as ExprNode, g as ExprOperand, h as ExprStatement, i as FilterXdo, l as InputXdo, M as MethodXdo, r as ResultItemXdo, s as StatementInputXdo, v as TaggedValue } from './xdo-CxDr2Q1C.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 `xanosdk 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))`. An
+ * edit (`db.edit`, `db.add_or_edit`) 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 such statement 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.
+ *
+ * A `db.add` is different, and its hash DOES change: an insert writes every
+ * column, so the slot for a column the author did not set carries
+ * `ignore: false` with the value the row gets (`null`, or the column's default).
+ * That slot is a real write, not engine noise.
+ *
+ * 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 };