@xanots/sdk 0.0.10 → 0.0.11

package/CHANGELOG.md

@@ -11,6 +11,23 @@ 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)

package/README.md

@@ -414,6 +414,44 @@ 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 (`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 @@
-d72e74909376b02042f7e65298a7158f3c3646928e959af4a14a7409667d070d
+6e6a4444f6fc73ee75afa9e72fb57b1ac2592d33d6b9a99205023fcbaccf8ed8

package/dist/bin.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   maybeNotifyUpdate
-} from "./chunk-5YCQ2QHH.js";
+} from "./chunk-22TKBSDV.js";
 import {
   readVersion,
   run
-} from "./chunk-ACCBOMCB.js";
+} from "./chunk-RCT7UX7B.js";
 import "./chunk-CTD5ZCV6.js";
-import "./chunk-OYMR5AMJ.js";
+import "./chunk-XEOX6AM7.js";
 import {
   exitCodeOf,
   reportFailure
@@ -17,12 +17,13 @@ import {
   clearProgress,
   error
 } from "./chunk-EZG76F7R.js";
-import "./chunk-VKSOTZK3.js";
+import "./chunk-OWGCOGKK.js";
 import "./chunk-DIA7CT7J.js";
-import "./chunk-LBYWGMOA.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/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 };

package/dist/bundle.js

@@ -0,0 +1,143 @@
+import {
+  linkedTableOf,
+  tableRefOf
+} from "./chunk-EHP3WPEG.js";
+import {
+  deepEqual,
+  normalize
+} from "./chunk-3INK4Y4E.js";
+import {
+  STATEMENT_SURFACES,
+  sPathOf
+} from "./chunk-BC2C5GVI.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/{chunk-5YCQ2QHH.js → chunk-22TKBSDV.js}

@@ -1,6 +1,6 @@
 import {
   readVersion
-} from "./chunk-ACCBOMCB.js";
+} from "./chunk-RCT7UX7B.js";
 import {
   atomicWrite
 } from "./chunk-GNPVYOPB.js";
@@ -170,4 +170,4 @@ export {
   upgradeCommand,
   maybeNotifyUpdate
 };
-//# sourceMappingURL=chunk-5YCQ2QHH.js.map
+//# sourceMappingURL=chunk-22TKBSDV.js.map

package/dist/{chunk-YYFXVYPX.js → chunk-4IF54NU5.js}

@@ -41,7 +41,7 @@ import {
 } from "./chunk-Q77KNEUL.js";
 import {
   readVersion
-} from "./chunk-ACCBOMCB.js";
+} from "./chunk-RCT7UX7B.js";
 import {
   ENV_SPELLINGS,
   parseEnvSelector
@@ -420,7 +420,7 @@ function rejectPullOnlyFlags(args) {
 async function runInitCommand(args) {
   if (args.from !== void 0) {
     const source = resolveFromSource(args.from);
-    const { runInitFromCommand } = await import("./codegen-command-GB3H2KQ7.js");
+    const { runInitFromCommand } = await import("./codegen-command-FUT2KJB6.js");
     return runInitFromCommand(args, source);
   }
   rejectPullOnlyFlags(args);
@@ -501,4 +501,4 @@ export {
   resolveFromSource,
   runInitCommand
 };
-//# sourceMappingURL=chunk-YYFXVYPX.js.map
+//# sourceMappingURL=chunk-4IF54NU5.js.map

package/dist/{chunk-W24FJHPD.js → chunk-4Q7ZOHH7.js}

@@ -1,6 +1,6 @@
 import {
   compileBundle
-} from "./chunk-ACCBOMCB.js";
+} from "./chunk-RCT7UX7B.js";
 import {
   missingArgument
 } from "./chunk-F6CYJ7TN.js";
@@ -34,4 +34,4 @@ export {
   assertBundleInput,
   loadBundleText
 };
-//# sourceMappingURL=chunk-W24FJHPD.js.map
+//# sourceMappingURL=chunk-4Q7ZOHH7.js.map

package/dist/{chunk-4BXJGVZ3.js → chunk-BC2C5GVI.js}

@@ -1,49 +1,3 @@
-// src/fields/generated/field-methods.generated.ts
-var FIELD_METHODS = {
-  "decimal": {
-    "max": "int",
-    "min": "int"
-  },
-  "email": {
-    "lower": "bool",
-    "trim": "bool"
-  },
-  "int": {
-    "max": "int",
-    "min": "int"
-  },
-  "password": {
-    "max": "int",
-    "min": "int",
-    "minAlpha": "int",
-    "minDigit": "int",
-    "minLowerAlpha": "int",
-    "minSymbol": "int",
-    "minUpperAlpha": "int",
-    "salt": "text"
-  },
-  "tableRef": {
-    "max": "int",
-    "min": "int"
-  },
-  "text": {
-    "alphaOk": "bool",
-    "digitOk": "bool",
-    "lower": "bool",
-    "max": "int",
-    "min": "int",
-    "ok": "text",
-    "pattern": "text",
-    "startsWith": "text",
-    "trim": "bool",
-    "upper": "bool"
-  },
-  "vector": {
-    "max": "int",
-    "min": "int"
-  }
-};
-
 // src/statements/surfaces.ts
 var STATEMENT_SURFACES = [
   ["action.call", "mvp:action"],
@@ -288,31 +242,10 @@ function sPathOf(surfaceKey) {
   return SPATH_OVERRIDES[surfaceKey] ?? surfaceKey.replace(/^stack\|/, "");
 }
 
-// src/statements/superseded.ts
-var SUPERSEDED_STATEMENTS = /* @__PURE__ */ new Map([
-  // Four crypto families, each phased forward with breaking changes between
-  // versions. The engine still registers a class for every one of them.
-  ["mvp:crypto_jwe_decode", "mvp:crypto_jwe_decode2"],
-  ["mvp:crypto_jwe_encode", "mvp:crypto_jwe_encode3"],
-  ["mvp:crypto_jwe_encode2", "mvp:crypto_jwe_encode3"],
-  ["mvp:crypto_jws_decode", "mvp:crypto_jws_decode2"],
-  ["mvp:crypto_jws_encode", "mvp:crypto_jws_encode2"],
-  // Retired outright — an old third-party log connector with no successor.
-  ["mvp:connect_ncscale_send_log", ""]
-]);
-function supersededBy(storedName, surfaceOf) {
-  const successor = SUPERSEDED_STATEMENTS.get(storedName);
-  if (successor === void 0 || successor === "") return null;
-  return surfaceOf(successor) ?? successor;
-}
-
 export {
-  FIELD_METHODS,
   STATEMENT_SURFACES,
   TOTAL_STATEMENTS,
   IMPLEMENTED_STATEMENTS,
-  sPathOf,
-  SUPERSEDED_STATEMENTS,
-  supersededBy
+  sPathOf
 };
-//# sourceMappingURL=chunk-4BXJGVZ3.js.map
+//# sourceMappingURL=chunk-BC2C5GVI.js.map

package/dist/chunk-BSK7ELHU.js

@@ -0,0 +1,70 @@
+// src/fields/generated/field-methods.generated.ts
+var FIELD_METHODS = {
+  "decimal": {
+    "max": "int",
+    "min": "int"
+  },
+  "email": {
+    "lower": "bool",
+    "trim": "bool"
+  },
+  "int": {
+    "max": "int",
+    "min": "int"
+  },
+  "password": {
+    "max": "int",
+    "min": "int",
+    "minAlpha": "int",
+    "minDigit": "int",
+    "minLowerAlpha": "int",
+    "minSymbol": "int",
+    "minUpperAlpha": "int",
+    "salt": "text"
+  },
+  "tableRef": {
+    "max": "int",
+    "min": "int"
+  },
+  "text": {
+    "alphaOk": "bool",
+    "digitOk": "bool",
+    "lower": "bool",
+    "max": "int",
+    "min": "int",
+    "ok": "text",
+    "pattern": "text",
+    "startsWith": "text",
+    "trim": "bool",
+    "upper": "bool"
+  },
+  "vector": {
+    "max": "int",
+    "min": "int"
+  }
+};
+
+// src/statements/superseded.ts
+var SUPERSEDED_STATEMENTS = /* @__PURE__ */ new Map([
+  // Four crypto families, each phased forward with breaking changes between
+  // versions. The engine still registers a class for every one of them.
+  ["mvp:crypto_jwe_decode", "mvp:crypto_jwe_decode2"],
+  ["mvp:crypto_jwe_encode", "mvp:crypto_jwe_encode3"],
+  ["mvp:crypto_jwe_encode2", "mvp:crypto_jwe_encode3"],
+  ["mvp:crypto_jws_decode", "mvp:crypto_jws_decode2"],
+  ["mvp:crypto_jws_encode", "mvp:crypto_jws_encode2"],
+  // Retired outright — an old third-party log connector with no successor.
+  ["mvp:connect_ncscale_send_log", ""]
+]);
+function supersededBy(storedName, surfaceOf) {
+  const successor = SUPERSEDED_STATEMENTS.get(storedName);
+  if (successor === void 0 || successor === "") return null;
+  return surfaceOf(successor) ?? successor;
+}
+
+export {
+  FIELD_METHODS,
+  SUPERSEDED_STATEMENTS,
+  supersededBy
+};
+//# sourceMappingURL=chunk-BSK7ELHU.js.map