@xano/sdk 1.0.0

package/dist/chunk-TPHWJ7UG.js

@@ -0,0 +1,1981 @@
+import {
+  readPathEnvVar
+} from "./chunk-EUUUMY7J.js";
+import {
+  FIELD_METHODS
+} from "./chunk-3YW23UFH.js";
+import {
+  obj
+} from "./chunk-K5BBGTYZ.js";
+import {
+  FILTER_NAMES,
+  FILTER_REQUIRED_ARGS,
+  fl
+} from "./chunk-6HO3NCSJ.js";
+import {
+  WORKSPACE_SECRETS_FILE
+} from "./chunk-3JDU4VRL.js";
+import {
+  linkedTableOf,
+  tableRefOf
+} from "./chunk-EHP3WPEG.js";
+import {
+  clearLocalDboRefs,
+  hasNoListBounds,
+  isDeadResultItem,
+  isEmptyCustomize,
+  normalize
+} from "./chunk-L5JYN3NM.js";
+import {
+  f,
+  input
+} from "./chunk-N5GKCWE5.js";
+import {
+  TAGS,
+  auth,
+  c,
+  caught,
+  col,
+  env,
+  inp,
+  isTaggedValue,
+  isToolsetPath,
+  out,
+  ref,
+  resp,
+  setting,
+  sys,
+  toolset,
+  withFilters
+} from "./chunk-OXA6PSZT.js";
+import {
+  REFERENCEABLE_KIND_PAYLOAD_KEYS
+} from "./chunk-NZOWWHU5.js";
+import {
+  CATALOG_BY_TYPE,
+  COLUMN_CONTEXT,
+  INPUT_CONTEXT,
+  defaultNullable,
+  encodeField,
+  parseMethod
+} from "./chunk-TTEIYD5P.js";
+
+// src/codegen/report.ts
+var AUDIENCE_ORDER = [
+  ["workspace", "Problems in your workspace"],
+  ["modelling", "Things Xano SDK could not model"],
+  ["informational", "Stated so the output is not ambiguous"]
+];
+var CATEGORY_LABELS = [
+  ["verify-mismatch", "Round-trip mismatches", "error", "modelling"],
+  ["duplicate-source-guid", "Objects sharing one guid in the source", "error", "workspace"],
+  ["unresolved-ref", "References that could not be resolved", "error", "workspace"],
+  ["workspace-defect", "Defects in the source workspace", "warning", "workspace"],
+  ["decode-only", "Statements the engine writes but will not import", "warning", "workspace"],
+  ["blank-binding", "Bindings that are blank upstream", "warning", "workspace"],
+  ["name-bound-ref", "References stored by name, not by guid", "warning", "workspace"],
+  ["ambiguous-condition", "Conditions that mix AND and OR at one level", "warning", "workspace"],
+  ["raw-fallback", "Statements emitted as raw() passthroughs", "warning", "modelling"],
+  ["unsupported-section", "Unsupported payload sections", "warning", "modelling"],
+  ["file-not-recovered", "Files referenced but not recovered", "warning", "modelling"],
+  ["value-fallback", "Values emitted as annotated literals", "warning", "modelling"],
+  ["modernized", "Updated to the current form (evaluates differently)", "warning", "modelling"],
+  ["path-param-bound", "Unbound {param} segments given an input", "warning", "modelling"],
+  ["superseded", "Retired statement versions, carried verbatim", "notice", "informational"],
+  ["expected-omission", "Deliberately not carried into the tree", "notice", "informational"],
+  ["empty-source", "Objects that were already empty in the source", "notice", "informational"],
+  ["unconfigured-stub", "Statements that were never configured", "notice", "informational"],
+  ["unportable-id", "Internal ids that are not portable identity", "notice", "informational"],
+  ["consolidated-duplicate", "Repeated source records merged by guid", "notice", "informational"],
+  ["instance-owned", "Instance state, deliberately not carried as source", "notice", "informational"]
+];
+var COALESCE_BY_OBJECT = /* @__PURE__ */ new Set(["blank-binding"]);
+var SEVERITY_LABEL = {
+  error: "ERROR",
+  warning: "WARN",
+  notice: "note"
+};
+function location(entry) {
+  return entry.path ? `${entry.object} \u2192 ${entry.path}` : entry.object;
+}
+function coalesceByObject(entries) {
+  const byObject = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const found = byObject.get(entry.object);
+    if (found) found.push(entry);
+    else byObject.set(entry.object, [entry]);
+  }
+  return [...byObject].map(([object, group]) => {
+    if (group.length === 1) return group[0];
+    const subjects = [...new Set(group.map((e) => e.subject).filter((s) => s !== void 0))];
+    const named = subjects.length > 0 ? `${subjects.join(", ")} \u2014 ` : "";
+    return {
+      category: group[0].category,
+      object,
+      detail: `${named}${group.length} references in this object are blank upstream, recovered as \`null\`. The targets were deleted, or the bindings were never made. Fix them upstream, or bind them in the generated source.`
+    };
+  });
+}
+function groupByCause(entries) {
+  const byDetail = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const found = byDetail.get(entry.detail);
+    if (found) found.push(entry);
+    else byDetail.set(entry.detail, [entry]);
+  }
+  return [...byDetail].map(([detail, group]) => ({
+    detail,
+    count: group.length,
+    objects: [...new Set(group.map((e) => e.object))],
+    entries: group
+  }));
+}
+var OBJECTS_SHOWN = 4;
+function collapseObjects(objects) {
+  if (objects.length <= OBJECTS_SHOWN) return objects.join(", ");
+  const shown = objects.slice(0, OBJECTS_SHOWN).join(", ");
+  return `${shown} and ${objects.length - OBJECTS_SHOWN} more`;
+}
+var DecodeReport = class {
+  #entries = [];
+  /** Object label → the generated file it was written to. See {@link locate}. */
+  #files = /* @__PURE__ */ new Map();
+  /** Record a problem. */
+  add(entry) {
+    const key2 = JSON.stringify([entry.category, entry.object, entry.path, entry.detail, entry.subject]);
+    if (this.#seen.has(key2)) return;
+    this.#seen.add(key2);
+    this.#entries.push(entry);
+  }
+  #seen = /* @__PURE__ */ new Set();
+  /**
+   * Record which generated file an object was written to.
+   *
+   * A finding is keyed by the object it happened in (`query:dbo_direct_query`),
+   * but the fix happens in the file the object was written to — and assembly
+   * knows that path, because it just chose it. Recording it here is what lets
+   * every finding name a file the reader can open.
+   *
+   * The path only; there is no line. A finding's `path` (`stack[5]`) is a
+   * position in the STORED object, and mapping one to a line in the emitted
+   * source would mean the printer carrying positions through every expression it
+   * builds. The file is the part that makes a finding findable.
+   */
+  locate(object, file) {
+    this.#files.set(object, file);
+  }
+  /** The generated file an object was written to, when assembly recorded one. */
+  #fileFor(object) {
+    return this.#files.get(object);
+  }
+  /** The generated file the object labelled `object` (`query:pick`) was written to, when assembly recorded one. */
+  fileOf(object) {
+    return this.#fileFor(object);
+  }
+  /** A position in the entry log, for {@link rewind}. */
+  mark() {
+    return this.#entries.length;
+  }
+  /**
+   * Drop every entry recorded since `mark`. Used to discard a speculative decode
+   * attempt, so the report describes what was emitted rather than what was tried.
+   */
+  rewind(mark) {
+    this.#entries.length = mark;
+  }
+  /** Every entry, in the order it was recorded. */
+  get entries() {
+    return this.#entries;
+  }
+  /** Group and count. The one computation every rendering reads. */
+  summarize() {
+    const byCategory = [];
+    const bySeverity = { error: 0, warning: 0, notice: 0 };
+    const byAudience = {
+      workspace: 0,
+      modelling: 0,
+      informational: 0
+    };
+    let total = 0;
+    let distinctCauses = 0;
+    for (const [category, label, severity, audience] of CATEGORY_LABELS) {
+      const found = this.#entries.filter((e) => e.category === category);
+      if (found.length === 0) continue;
+      const entries = COALESCE_BY_OBJECT.has(category) ? coalesceByObject(found) : found;
+      const causes = groupByCause(entries);
+      byCategory.push({
+        category,
+        label,
+        severity,
+        audience,
+        count: entries.length,
+        entries,
+        causes
+      });
+      bySeverity[severity] += entries.length;
+      byAudience[audience] += entries.length;
+      distinctCauses += causes.length;
+      total += entries.length;
+    }
+    return { total, bySeverity, byAudience, distinctCauses, byCategory };
+  }
+  /**
+   * The headline, or an empty string when there is nothing to say.
+   *
+   * Answers the two questions a reader has before they start reading: how much
+   * of this is repetition, and how much of it is theirs to fix.
+   */
+  headline() {
+    const summary = this.summarize();
+    if (summary.total === 0) return "";
+    const causes = `${summary.distinctCauses} distinct issue${summary.distinctCauses === 1 ? "" : "s"}`;
+    const findings = `${summary.total} finding${summary.total === 1 ? "" : "s"}`;
+    const mine = summary.byAudience.workspace;
+    const errors = summary.byCategory.filter((g) => g.severity === "error" && g.audience !== "workspace").reduce((n, g) => n + g.count, 0);
+    const errorClause = (more) => `${errors}${more} ${errors === 1 ? "is an error" : "are errors"}`;
+    const warnings = summary.byCategory.filter((g) => g.severity === "warning" && g.audience !== "workspace").reduce((n, g) => n + g.count, 0);
+    const attention = mine === 0 ? errors === 0 ? warnings === 0 ? "none need your attention" : `${warnings} ${warnings === 1 ? "is a warning" : "are warnings"}` : errorClause("") : `${mine} need${mine === 1 ? "s" : ""} your attention` + (errors === 0 ? "" : `; ${errorClause(" more")}`);
+    return `${causes} across ${findings}; ${attention}`;
+  }
+  /** The findings as data — the shape `--report json` and the manifest carry. */
+  toJson() {
+    const summary = this.summarize();
+    return {
+      headline: this.headline(),
+      total: summary.total,
+      bySeverity: summary.bySeverity,
+      byAudience: summary.byAudience,
+      findings: summary.byCategory.flatMap(
+        (group) => group.entries.map((entry) => ({
+          category: group.category,
+          severity: group.severity,
+          audience: group.audience,
+          object: entry.object,
+          ...entry.path === void 0 ? {} : { path: entry.path },
+          ...this.#fileFor(entry.object) === void 0 ? {} : { file: this.#fileFor(entry.object) },
+          detail: entry.detail
+        }))
+      )
+    };
+  }
+  /** The generated README's report section. Empty string when there is nothing to say. */
+  renderMarkdown() {
+    const summary = this.summarize();
+    if (summary.total === 0) return "";
+    const lines = ["## What did not round-trip cleanly", "", this.headline(), ""];
+    for (const [audience, heading] of AUDIENCE_ORDER) {
+      const groups = summary.byCategory.filter((g) => g.audience === audience);
+      if (groups.length === 0) continue;
+      lines.push(`### ${heading}`, "");
+      for (const group of groups) {
+        lines.push(
+          `#### ${SEVERITY_LABEL[group.severity]} ${group.label} [${group.category}=${group.count}]`,
+          ""
+        );
+        for (const entry of group.entries) {
+          lines.push(`- \`${this.#locationOf(entry)}\` \u2014 ${entry.detail}`);
+        }
+        lines.push("");
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * The CLI summary. Empty string when there is nothing to say.
+   *
+   * Grouped by root cause by default: a cause that repeats across objects gets
+   * one line carrying its count and a collapsed object list, because 58 lines
+   * saying one sentence about 58 tools is not 58 times the signal. `full: true`
+   * restores the per-entry form for anyone who wants every site; `categories`
+   * limits it to those categories.
+   */
+  renderCli(opts = {}) {
+    const summary = this.summarize();
+    if (summary.total === 0) return "";
+    const lines = [];
+    for (const [audience, heading] of AUDIENCE_ORDER) {
+      const groups = summary.byCategory.filter(
+        (g) => g.audience === audience && (opts.categories === void 0 || opts.categories.includes(g.category))
+      );
+      if (groups.length === 0) continue;
+      lines.push(`  ${heading}`);
+      for (const group of groups) {
+        lines.push(
+          `    ${SEVERITY_LABEL[group.severity]} ${group.label} [${group.category}=${group.count}]`
+        );
+        if (opts.full === true) {
+          for (const entry of group.entries) {
+            lines.push(`      ${this.#locationOf(entry, opts.fileBase)} \u2014 ${entry.detail}`);
+          }
+          continue;
+        }
+        for (const cause of group.causes) {
+          if (cause.count === 1) {
+            lines.push(`      ${this.#locationOf(cause.entries[0], opts.fileBase)} \u2014 ${cause.detail}`);
+            continue;
+          }
+          lines.push(`      \xD7${cause.count} \u2014 ${cause.detail}`);
+          const sites = cause.objects.length === cause.count ? cause.objects.map((o) => this.#label(o, opts.fileBase)) : cause.entries.map((e) => this.#locationOf(e, opts.fileBase));
+          lines.push(`        in ${collapseObjects(sites)}`);
+        }
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * `object → path (file)`, with the file only when assembly recorded one.
+   *
+   * `base` is what the reader's paths are relative TO. The README sits inside
+   * the generated tree, so it prints the bare path; the CLI is read from the
+   * project root, so it prints the tree directory too and the path is one a
+   * terminal can open.
+   */
+  #locationOf(entry, base) {
+    const file = this.#fileFor(entry.object);
+    return file === void 0 ? location(entry) : `${location(entry)} (${base ?? ""}${file})`;
+  }
+  /** An object with its file appended, for the collapsed list on a grouped line. */
+  #label(object, base) {
+    const file = this.#fileFor(object);
+    return file === void 0 ? object : `${object} (${base ?? ""}${file})`;
+  }
+};
+
+// src/codegen/prove-diff.ts
+import { appendFileSync } from "fs";
+var MAX_PATHS = 40;
+var MAX_DEPTH = 12;
+var MAX_PREVIEW = 60;
+function sink() {
+  return readPathEnvVar("XANOSDK_PROVE_DIFF");
+}
+function preview(v) {
+  const json = JSON.stringify(v) ?? "undefined";
+  return json.length > MAX_PREVIEW ? `${json.slice(0, MAX_PREVIEW)}\u2026` : json;
+}
+function walk(encoded, stored, path, out2, depth) {
+  if (out2.length >= MAX_PATHS || depth > MAX_DEPTH) return;
+  const bothObjects = encoded !== null && stored !== null && typeof encoded === "object" && typeof stored === "object";
+  if (!bothObjects) {
+    if (JSON.stringify(encoded) !== JSON.stringify(stored)) {
+      out2.push(`${path}: encoded=${preview(encoded)} stored=${preview(stored)}`);
+    }
+    return;
+  }
+  const encodedIsArray = Array.isArray(encoded);
+  if (encodedIsArray !== Array.isArray(stored)) {
+    out2.push(
+      `${path}: shape encoded=${encodedIsArray ? "array" : "object"} stored=${Array.isArray(stored) ? "array" : "object"}`
+    );
+    return;
+  }
+  if (encodedIsArray) {
+    const a2 = encoded;
+    const b2 = stored;
+    if (a2.length !== b2.length) out2.push(`${path}: length encoded=${a2.length} stored=${b2.length}`);
+    for (let i = 0; i < Math.min(a2.length, b2.length); i++) {
+      walk(a2[i], b2[i], `${path}[]`, out2, depth + 1);
+    }
+    return;
+  }
+  const a = encoded;
+  const b = stored;
+  for (const key2 of /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])) {
+    if (out2.length >= MAX_PATHS) return;
+    if (!(key2 in a)) out2.push(`${path}.${key2}: MISSING from encoded (stored=${preview(b[key2])})`);
+    else if (!(key2 in b)) out2.push(`${path}.${key2}: EXTRA in encoded (${preview(a[key2])})`);
+    else walk(a[key2], b[key2], `${path}.${key2}`, out2, depth + 1);
+  }
+}
+function diffKeyPaths(encoded, stored) {
+  const out2 = [];
+  walk(encoded, stored, "", out2, 0);
+  return out2;
+}
+var NOTE_PATHS = 3;
+function recordProveDecline(arm, name, encoded, stored) {
+  const diffs = diffKeyPaths(encoded, stored);
+  if (diffs.length > 0) {
+    const shown = diffs.slice(0, NOTE_PATHS).join("; ");
+    const rest = diffs.length - NOTE_PATHS;
+    noteDecline(
+      `the re-encode disagrees with the stored bytes at ${shown}` + (rest > 0 ? ` (and ${rest} more)` : "")
+    );
+  }
+  const file = sink();
+  if (file === void 0 || file === "") return;
+  appendFileSync(file, `${JSON.stringify({ arm, name, diffs })}
+`);
+}
+function recordProveAbort(arm, name, why) {
+  const file = sink();
+  if (file === void 0 || file === "") return;
+  appendFileSync(file, `${JSON.stringify({ arm, name, diffs: [`ABORT: ${why}`] })}
+`);
+}
+var currentName = void 0;
+function withDeclineContext(name, body) {
+  const previous = currentName;
+  currentName = name;
+  try {
+    return body();
+  } finally {
+    currentName = previous;
+  }
+}
+var pendingNote;
+function noteDecline(why, category) {
+  pendingNote ??= category === void 0 ? { why } : { why, category };
+  return null;
+}
+function takePendingDecline() {
+  const note = pendingNote;
+  pendingNote = void 0;
+  return note;
+}
+function declineHere(where, category) {
+  noteDecline(where, category);
+  const file = sink();
+  if (file === void 0 || file === "") return null;
+  appendFileSync(
+    file,
+    `${JSON.stringify({ arm: "guard", name: currentName, diffs: [`GUARD: ${where}`] })}
+`
+  );
+  return null;
+}
+
+// src/codegen/context.ts
+var SDK_MODULE = "@xano/sdk";
+var CODEGEN_MODULE = "@xano/sdk/codegen";
+function moduleOrder(a, b) {
+  const relative = (m) => m.startsWith(".") ? 1 : 0;
+  return relative(a) - relative(b) || (a < b ? -1 : a > b ? 1 : 0);
+}
+var ImportCollector = class {
+  #value = /* @__PURE__ */ new Map();
+  #type = /* @__PURE__ */ new Map();
+  /** Record a value import. Returns the symbol so callers can use it inline. */
+  use(module, symbol) {
+    let symbols = this.#value.get(module);
+    if (!symbols) this.#value.set(module, symbols = /* @__PURE__ */ new Set());
+    symbols.add(symbol);
+    return symbol;
+  }
+  /** Record a type-only import. Returns the symbol. */
+  useType(module, symbol) {
+    let symbols = this.#type.get(module);
+    if (!symbols) this.#type.set(module, symbols = /* @__PURE__ */ new Set());
+    symbols.add(symbol);
+    return symbol;
+  }
+  /** Fold this collector's symbols into another (used to commit an attempt). */
+  mergeInto(target) {
+    for (const [module, symbols] of this.#value) {
+      for (const symbol of symbols) target.use(module, symbol);
+    }
+    for (const [module, symbols] of this.#type) {
+      for (const symbol of symbols) target.useType(module, symbol);
+    }
+  }
+  /** The file's import block, deduplicated and deterministically ordered. */
+  toStatements() {
+    const out2 = [];
+    for (const module of [...this.#value.keys()].sort(moduleOrder)) {
+      out2.push({ kind: "import", module, symbols: [...this.#value.get(module)].sort() });
+    }
+    for (const module of [...this.#type.keys()].sort(moduleOrder)) {
+      out2.push({
+        kind: "import",
+        module,
+        symbols: [...this.#type.get(module)].sort(),
+        typeOnly: true
+      });
+    }
+    return out2;
+  }
+};
+var BUNDLE_SCOPE = "(bundle)";
+var DecodeContext = class {
+  report = new DecodeReport();
+  /**
+   * Where the decode's caller writes the documentation-token sidecar, as the
+   * report names it — `xano/.secrets.json` for a project, `<out>/.secrets.json`
+   * for `generate --out`. Only the caller knows the directory.
+   */
+  secretsFile = WORKSPACE_SECRETS_FILE;
+  /**
+   * Whether the caller writes that sidecar at all. `--no-secrets` does not, and
+   * the report has to say so rather than promise a file and a restored gate.
+   */
+  writesSecrets = true;
+  /** The barrel's `workspace("…")` name when the payload carries no workspace object. */
+  fallbackWorkspaceName = "workspace";
+  /** The import block of the file currently being generated. */
+  imports = new ImportCollector();
+  #object = BUNDLE_SCOPE;
+  #path = [];
+  /**
+   * Test id → name for the object currently being decoded, so a statement's
+   * stored `mocks` (keyed by id) can be written back as the `mock` map an
+   * author reads (keyed by name). Ambient rather than threaded because a mock
+   * can sit on a statement nested arbitrarily deep inside the stack.
+   */
+  #testNames = /* @__PURE__ */ new Map();
+  /** Start a fresh import block. Called once per generated file. */
+  beginFile() {
+    this.imports = new ImportCollector();
+    return this.imports;
+  }
+  /** Record a symbol the current file imports. Returns the symbol. */
+  use(module, symbol) {
+    return this.imports.use(module, symbol);
+  }
+  /**
+   * Run a decode attempt whose result may be discarded.
+   *
+   * Dispatch tries several forms and keeps the first that provably re-encodes,
+   * so a losing attempt must leave nothing behind — an unused import in a
+   * generated file is dead weight at best, and a report entry describing an
+   * attempt that was thrown away is simply false. Imports and problems are
+   * buffered and merged only when `fn` returns a result.
+   */
+  speculate(fn) {
+    const outerImports = this.imports;
+    const mark = this.report.mark();
+    this.imports = new ImportCollector();
+    let result = null;
+    try {
+      result = fn();
+      return result;
+    } finally {
+      const attempted = this.imports;
+      this.imports = outerImports;
+      if (result === null) this.report.rewind(mark);
+      else attempted.mergeInto(this.imports);
+    }
+  }
+  /** Record a type-only symbol the current file imports. Returns the symbol. */
+  useType(module, symbol) {
+    return this.imports.useType(module, symbol);
+  }
+  /** Run `fn` with report entries attributed to `label` (e.g. `function:signup`). */
+  inObject(label, fn) {
+    const previousObject = this.#object;
+    const previousPath = this.#path;
+    this.#object = label;
+    this.#path = [];
+    try {
+      return fn();
+    } finally {
+      this.#object = previousObject;
+      this.#path = previousPath;
+    }
+  }
+  /** Run `fn` with this object's test id→name map in force. */
+  withTests(names, fn) {
+    const previous = this.#testNames;
+    this.#testNames = names;
+    try {
+      return fn();
+    } finally {
+      this.#testNames = previous;
+    }
+  }
+  /** The name of the test this id belongs to, if the current object declares it. */
+  testName(id2) {
+    return this.#testNames.get(id2);
+  }
+  /** The inverse: test name → id, for proving a decoded mock map re-encodes. */
+  testIds() {
+    return new Map([...this.#testNames].map(([id2, name]) => [name, id2]));
+  }
+  /** Run `fn` with `segment` appended to the reported path (e.g. `stack[2]`). */
+  at(segment, fn) {
+    this.#path.push(segment);
+    try {
+      return fn();
+    } finally {
+      this.#path.pop();
+    }
+  }
+  /**
+   * Record why this decode declined; last writer wins.
+   *
+   * Reserved for declines with a KNOWN, stable cause. A decoder that declined
+   * because something surprised it should stay silent rather than guess.
+   *
+   * The note itself lives in `prove-diff`, because the other writer — a guard
+   * several frames down inside a shared helper — has no context to reach. See
+   * {@link noteDecline} for why there is exactly one store.
+   */
+  declined(why, category) {
+    return noteDecline(why, category);
+  }
+  /** Read and clear the pending decline note. */
+  takeDeclineNote() {
+    return takePendingDecline();
+  }
+  /**
+   * Record a problem at the current object/path scope.
+   *
+   * `subject` names what the entry is about in a word or two, for the categories
+   * the report coalesces per object. Optional everywhere else and ignored there.
+   */
+  problem(category, detail, subject) {
+    this.report.add({
+      category,
+      object: this.#object,
+      ...this.#path.length > 0 ? { path: this.#path.join(".") } : {},
+      detail,
+      ...subject !== void 0 ? { subject } : {}
+    });
+  }
+};
+
+// src/codegen/print.ts
+function id(text) {
+  return { kind: "id", text };
+}
+function lit(value) {
+  return { kind: "literal", value };
+}
+function call(callee, ...args) {
+  return { kind: "call", callee, args };
+}
+function obj2(entries) {
+  return { kind: "object", entries };
+}
+function arr(items) {
+  return { kind: "array", items };
+}
+function spread(base, entries) {
+  return { kind: "spread", base, entries };
+}
+function arrow(params, body) {
+  return { kind: "arrow", params, body };
+}
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var INDENT = "  ";
+function key(name) {
+  if (name === "__proto__") return `[${JSON.stringify(name)}]`;
+  return IDENTIFIER.test(name) ? name : JSON.stringify(name);
+}
+function fromData(value) {
+  if (Array.isArray(value)) return arr(value.map(fromData));
+  if (value !== null && typeof value === "object") {
+    return obj2(Object.entries(value).map(([k, v]) => [k, fromData(v)]));
+  }
+  return { kind: "id", text: JSON.stringify(value) ?? "undefined" };
+}
+function printExpr(node, depth = 0) {
+  const pad = INDENT.repeat(depth);
+  const inner = INDENT.repeat(depth + 1);
+  switch (node.kind) {
+    case "id":
+      return node.text;
+    case "literal":
+      return printExpr(fromData(node.value), depth);
+    case "array": {
+      if (node.items.length === 0) return "[]";
+      const items = node.items.map((item) => `${inner}${printExpr(item, depth + 1)},`);
+      return `[
+${items.join("\n")}
+${pad}]`;
+    }
+    case "object": {
+      if (node.entries.length === 0) return "{}";
+      const entries = node.entries.map(
+        ([k, v]) => `${inner}${key(k)}: ${printExpr(v, depth + 1)},`
+      );
+      return `{
+${entries.join("\n")}
+${pad}}`;
+    }
+    case "spread": {
+      const lines = [`${inner}...${printExpr(node.base, depth + 1)},`];
+      for (const [k, v] of node.entries) lines.push(`${inner}${key(k)}: ${printExpr(v, depth + 1)},`);
+      return `{
+${lines.join("\n")}
+${pad}}`;
+    }
+    case "arrow": {
+      const body = printExpr(node.body, depth);
+      const params = [...node.params];
+      while (params.length > 0 && !new RegExp(`(^|[^\\w$.])${params[params.length - 1].replace(/\$/g, "\\$")}\\b`).test(body)) {
+        params.pop();
+      }
+      return `(${params.join(", ")}) => ${body.startsWith("{") ? `(${body})` : body}`;
+    }
+    case "call": {
+      if (node.args.length === 0) return `${node.callee}()`;
+      return `${node.callee}(${node.args.map((a) => printExpr(a, depth)).join(", ")})`;
+    }
+  }
+}
+function printModule(stmts) {
+  const lines = [];
+  for (const stmt of stmts) {
+    switch (stmt.kind) {
+      case "blank":
+        lines.push("");
+        break;
+      case "comment":
+        for (const line of stmt.text.split("\n")) lines.push(line === "" ? "//" : `// ${line}`);
+        break;
+      case "import": {
+        const kw = stmt.typeOnly ? "import type" : "import";
+        const symbols = [...stmt.symbols].sort().join(", ");
+        lines.push(`${kw} { ${symbols} } from ${JSON.stringify(stmt.module)};`);
+        break;
+      }
+      case "const":
+        lines.push(
+          `${stmt.exported ? "export " : ""}const ${stmt.name} = ${printExpr(stmt.value)};`
+        );
+        break;
+      case "exportDefault":
+        lines.push(`export default ${printExpr(stmt.value)};`);
+        break;
+      case "exportNamed": {
+        if (stmt.symbols.length === 0) break;
+        const symbols = [...stmt.symbols].sort();
+        const single = `export { ${symbols.join(", ")} };`;
+        if (single.length <= 100) lines.push(single);
+        else lines.push("export {", ...symbols.map((s) => `  ${s},`), "};");
+        break;
+      }
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// src/codegen/ref-index.ts
+var KINDS_BY_PAYLOAD_KEY = (() => {
+  const out2 = /* @__PURE__ */ new Map();
+  for (const [kind, payloadKey] of Object.entries(REFERENCEABLE_KIND_PAYLOAD_KEYS)) {
+    const kinds = out2.get(payloadKey) ?? [];
+    kinds.push(kind);
+    out2.set(payloadKey, kinds);
+  }
+  return out2;
+})();
+function discriminate(payloadKey, object) {
+  const candidates = KINDS_BY_PAYLOAD_KEY.get(payloadKey);
+  if (!candidates || candidates.length === 0) return null;
+  if (candidates.length === 1) return candidates[0];
+  const type = object.type;
+  if (type === "mcp") return "mcp_server";
+  if (type === "agent") return "agent";
+  return null;
+}
+var RefIndex = class _RefIndex {
+  #byGuid = /* @__PURE__ */ new Map();
+  /**
+   * Walk every payload array once, keying each object by its stored guid.
+   *
+   * An object with no usable guid is reported rather than assigned a derived one:
+   * a derived guid would look correct and quietly point somewhere else.
+   */
+  static fromPayload(payload, ctx) {
+    const index = new _RefIndex();
+    for (const payloadKey of KINDS_BY_PAYLOAD_KEY.keys()) {
+      const section = payload[payloadKey];
+      if (!Array.isArray(section)) continue;
+      section.forEach((entry, position) => {
+        if (entry === null || typeof entry !== "object") return;
+        const object = entry;
+        const name = typeof object.name === "string" ? object.name : "";
+        const kind = discriminate(payloadKey, object);
+        const guid = object.guid;
+        if (typeof guid !== "string" || guid === "") {
+          ctx.problem(
+            "unresolved-ref",
+            `${payloadKey}[${position}]${name ? ` "${name}"` : ""} has no stored guid; references to it cannot resolve`
+          );
+          return;
+        }
+        if (kind === null) {
+          ctx.problem(
+            "unresolved-ref",
+            `${payloadKey} "${name}" (guid ${guid}) has no recognizable kind; its stored \`type\` is ${JSON.stringify(object.type)}`
+          );
+          return;
+        }
+        index.#byGuid.set(guid, {
+          guid,
+          payloadKey,
+          kind,
+          name,
+          position,
+          ...payloadKey === "dbo" && Array.isArray(object.schema) ? { schema: object.schema } : {},
+          ...payloadKey === "microservice" ? { ports: servicePorts(object) } : {}
+        });
+      });
+    }
+    return index;
+  }
+  /** The object a guid names, or undefined when the bundle does not contain it. */
+  lookup(guid) {
+    return this.#byGuid.get(guid);
+  }
+  /** Every indexed object, in payload-walk order. */
+  all() {
+    return [...this.#byGuid.values()];
+  }
+  /**
+   * The ONE object of `kind` named `name` — for the references the engine
+   * resolves by name (a microservice request's `host`). Undefined when none or
+   * several match: a guess would repoint the reference.
+   */
+  byName(kind, name) {
+    const found = this.all().filter((o) => o.kind === kind && o.name === name);
+    return found.length === 1 ? found[0] : void 0;
+  }
+};
+function servicePorts(object) {
+  const seen = /* @__PURE__ */ new Set();
+  const containers = object.deployment?.containers;
+  for (const container of Array.isArray(containers) ? containers : []) {
+    const ports = container?.ports;
+    for (const port of Array.isArray(ports) ? ports : []) {
+      const servicePort = port?.servicePort;
+      if (typeof servicePort === "string" && servicePort !== "") seen.add(servicePort);
+    }
+  }
+  return [...seen];
+}
+function microserviceHost(refs, stored) {
+  const input2 = stored?.input;
+  const entry = (Array.isArray(input2) ? input2 : []).find((e) => e?.name === "host");
+  if (entry?.tag !== "const" || typeof entry.value !== "string" || entry.ignore === true) return void 0;
+  if (Array.isArray(entry.filters) && entry.filters.length > 0) return void 0;
+  const colon = entry.value.indexOf(":");
+  const name = colon === -1 ? entry.value : entry.value.slice(0, colon);
+  const port = colon === -1 ? void 0 : entry.value.slice(colon + 1);
+  const target = name === "" ? void 0 : refs.byName("microservice", name);
+  if (!target) return void 0;
+  const ports = target.ports ?? [];
+  if (port === void 0 ? ports.length !== 0 : port === "" || ports.length > 0 && !ports.includes(port)) return void 0;
+  return { target, port };
+}
+function isReferenceId(v) {
+  return typeof v === "string" || typeof v === "number" && Number.isFinite(v);
+}
+function isUnboundId(v) {
+  return v === "" || v === 0;
+}
+function isBoundNumericId(v) {
+  return typeof v === "number" && !isUnboundId(v);
+}
+function resolveReference(ctx, index, guid, options = {}) {
+  const target = index.lookup(guid);
+  if (!target) {
+    ctx.problem(
+      guid === "0" ? "unportable-id" : "unresolved-ref",
+      guid === "0" ? "a reference stored as `guid 0` \u2014 an internal row id rather than portable identity, so it cannot resolve to an object in any bundle and is carried verbatim" : `guid ${guid} is not present in this bundle`
+    );
+    return options.unresolved === "object-ref" ? obj2([
+      ["name", lit("")],
+      ["guid", lit(guid)]
+    ]) : lit(guid);
+  }
+  const symbol = options.symbolFor?.(target) ?? null;
+  if (symbol !== null) return id(symbol);
+  return obj2([
+    ["name", lit(target.name)],
+    ["guid", lit(target.guid)]
+  ]);
+}
+
+// src/codegen/obj-expr.ts
+var IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var REFERENCE = /^\$(input|var|auth|db)((?:\.[A-Za-z0-9_$]+)*)$/;
+var SETTING = /^\$env\.(\$?[A-Za-z0-9_]+)$/;
+var SYS_BY_NAME = new Map(
+  Object.entries(sys).map(([accessor, make]) => [make().value, accessor])
+);
+var Cursor = class {
+  #text;
+  #at = 0;
+  constructor(text) {
+    this.#text = text;
+  }
+  get done() {
+    return this.#at >= this.#text.length;
+  }
+  skipSpace() {
+    while (this.#at < this.#text.length && /\s/.test(this.#text[this.#at])) this.#at++;
+  }
+  /** Consume `token` if it is next, after whitespace. */
+  eat(token) {
+    this.skipSpace();
+    if (!this.#text.startsWith(token, this.#at)) return false;
+    this.#at += token.length;
+    return true;
+  }
+  peek() {
+    this.skipSpace();
+    return this.#text[this.#at];
+  }
+  /** Consume while `re` matches, returning the run (possibly empty). */
+  take(re) {
+    this.skipSpace();
+    const start = this.#at;
+    while (this.#at < this.#text.length && re.test(this.#text[this.#at])) this.#at++;
+    return this.#text.slice(start, this.#at);
+  }
+  /**
+   * Consume a JSON double-quoted string, honouring escapes. Returns null when
+   * the next token is not a well-formed string.
+   */
+  takeString() {
+    this.skipSpace();
+    if (this.#text[this.#at] !== '"') return null;
+    let i = this.#at + 1;
+    let out2 = "";
+    while (i < this.#text.length) {
+      const ch = this.#text[i];
+      if (ch === "\\") {
+        const next = this.#text[i + 1];
+        if (next === void 0) return null;
+        const decoded = tryJsonParse(`"\\${next}"`);
+        if (next === "u") {
+          const seq = this.#text.slice(i, i + 6);
+          const hex = tryJsonParse(`"${seq}"`);
+          if (typeof hex !== "string") return null;
+          out2 += hex;
+          i += 6;
+          continue;
+        }
+        if (typeof decoded !== "string") return null;
+        out2 += decoded;
+        i += 2;
+        continue;
+      }
+      if (ch === '"') {
+        this.#at = i + 1;
+        return out2;
+      }
+      out2 += ch;
+      i++;
+    }
+    return null;
+  }
+};
+function tryJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function parseReference(token) {
+  const m = REFERENCE.exec(token);
+  if (!m) return null;
+  const root = m[1];
+  const path = m[2].replace(/^\./, "");
+  switch (root) {
+    case "input":
+      return path === "" ? null : { expr: call("inp", lit(path)), built: inp(path), symbols: ["inp"] };
+    case "var":
+      return path === "" ? null : { expr: call("ref", lit(path)), built: ref(path), symbols: ["ref"] };
+    case "db":
+      return path === "" ? null : { expr: call("col", lit(path)), built: col(path), symbols: ["col"] };
+    case "auth":
+      return path === "" ? { expr: call("auth"), built: auth(), symbols: ["auth"] } : { expr: call("auth", lit(path)), built: auth(path), symbols: ["auth"] };
+    default:
+      return null;
+  }
+}
+function parseMember(cur) {
+  if (cur.eat("(")) {
+    const inner = parseMember(cur);
+    return inner && cur.eat(")") ? inner : null;
+  }
+  const atom = parseAtom(cur);
+  if (!atom) return null;
+  if (cur.peek() !== "|") return atom;
+  const lifted = liftToValue(atom);
+  if (!lifted) return null;
+  const expr = lifted.expr;
+  let built = lifted.built;
+  const symbols = [...lifted.symbols];
+  const filterExprs = [];
+  let absorbNowCoercion = built.tag === "const:epochms" && built.value === "now";
+  while (cur.eat("|")) {
+    const name = cur.take(/[A-Za-z0-9_]/);
+    if (name === "" || !FILTER_NAMES.includes(name)) return null;
+    const factory = fl[name];
+    if (typeof factory !== "function") return null;
+    const argExprs = [];
+    const argBuilt = [];
+    while (cur.eat(":")) {
+      const arg = parseAtom(cur);
+      if (!arg) return null;
+      if (arg.built !== null && typeof arg.built === "object" && !isTaggedValue(arg.built)) {
+        return null;
+      }
+      argExprs.push(arg.expr);
+      argBuilt.push(arg.built);
+      symbols.push(...arg.symbols);
+    }
+    let filterValue;
+    try {
+      filterValue = factory(...argBuilt);
+    } catch {
+      return null;
+    }
+    if (absorbNowCoercion && name === "to_epochms" && argBuilt.length === 0) {
+      absorbNowCoercion = false;
+      continue;
+    }
+    absorbNowCoercion = false;
+    built = withFilters(built, filterValue);
+    filterExprs.push(call(`fl.${name}`, ...argExprs));
+  }
+  if (filterExprs.length === 0) return { expr, built, symbols };
+  return {
+    expr: call("withFilters", expr, ...filterExprs),
+    built,
+    symbols: [...symbols, "withFilters", "fl"]
+  };
+}
+function liftToValue(parsed) {
+  const m = parsed.built;
+  if (isTaggedValue(m)) return { expr: parsed.expr, built: m, symbols: parsed.symbols };
+  if (typeof m === "string") return { expr: call("c.text", lit(m)), built: c.text(m), symbols: ["c"] };
+  if (typeof m === "number") {
+    return Number.isInteger(m) ? { expr: call("c.int", lit(m)), built: c.int(m), symbols: ["c"] } : { expr: call("c.decimal", lit(m)), built: c.decimal(m), symbols: ["c"] };
+  }
+  if (typeof m === "boolean") return { expr: call("c.bool", lit(m)), built: c.bool(m), symbols: ["c"] };
+  return null;
+}
+function parseAtom(cur) {
+  const next = cur.peek();
+  if (next === void 0) return null;
+  if (next === "{") return parseRecord(cur);
+  if (next === "[") {
+    if (!cur.eat("[")) return null;
+    const exprs = [];
+    const built = [];
+    const symbols = [];
+    if (cur.eat("]")) return { expr: arr([]), built: [], symbols: [] };
+    for (; ; ) {
+      const member = parseMember(cur);
+      if (!member) return null;
+      exprs.push(member.expr);
+      built.push(member.built);
+      symbols.push(...member.symbols);
+      if (cur.eat(",")) continue;
+      if (cur.eat("]")) break;
+      return null;
+    }
+    return { expr: arr(exprs), built, symbols };
+  }
+  if (next === '"') {
+    const text = cur.takeString();
+    return text === null ? null : { expr: lit(text), built: text, symbols: [] };
+  }
+  const token = cur.take(/[A-Za-z0-9_$.\-+]/);
+  if (token === "") return null;
+  const reference = parseReference(token);
+  if (reference) return reference;
+  if (token === "now") return { expr: call("c.now"), built: c.now(), symbols: ["c"] };
+  const settingMatch = SETTING.exec(token);
+  if (settingMatch) {
+    const name = settingMatch[1];
+    const accessor = SYS_BY_NAME.get(name);
+    if (accessor) {
+      return { expr: call(`sys.${accessor}`), built: setting(name), symbols: ["sys"] };
+    }
+    return name.startsWith("$") ? { expr: call("setting", lit(name)), built: setting(name), symbols: ["setting"] } : { expr: call("env", lit(name)), built: env(name), symbols: ["env"] };
+  }
+  if (token === "true" || token === "false") {
+    const value = token === "true";
+    return { expr: lit(value), built: value, symbols: [] };
+  }
+  if (token === "null") return { expr: call("c.null"), built: c.null(), symbols: ["c"] };
+  if (/^-?\d+(\.\d+)?$/.test(token)) {
+    const n = Number(token);
+    return Number.isFinite(n) && String(n) === token ? { expr: lit(n), built: n, symbols: [] } : null;
+  }
+  return null;
+}
+function parseRecord(cur) {
+  if (!cur.eat("{")) return null;
+  const entries = [];
+  const built = {};
+  const symbols = [];
+  if (cur.eat("}")) return { expr: obj2([]), built, symbols };
+  for (; ; ) {
+    const key2 = cur.take(/[A-Za-z0-9_$]/);
+    if (key2 === "" || !IDENT.test(key2)) return null;
+    if (!cur.eat(":")) return null;
+    const member = parseMember(cur);
+    if (!member) return null;
+    if (Object.hasOwn(built, key2)) return null;
+    entries.push([key2, member.expr]);
+    Object.defineProperty(built, key2, { value: member.built, enumerable: true, writable: true, configurable: true });
+    symbols.push(...member.symbols);
+    if (cur.eat(",")) continue;
+    if (cur.eat("}")) break;
+    return null;
+  }
+  return { expr: obj2(entries), built, symbols };
+}
+function parseObjExpr(value) {
+  const cur = new Cursor(value);
+  if (cur.peek() !== "{") return null;
+  const parsed = parseRecord(cur);
+  if (!parsed) return null;
+  cur.skipSpace();
+  if (!cur.done) return null;
+  return {
+    expr: call("obj", parsed.expr),
+    built: parsed.built,
+    symbols: ["obj", ...parsed.symbols]
+  };
+}
+
+// src/codegen/value.ts
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((item, i) => deepEqual(item, b[i]));
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  const ak = Object.keys(a);
+  const bk = Object.keys(b);
+  if (ak.length !== bk.length) return false;
+  return ak.every(
+    (k) => Object.hasOwn(b, k) && deepEqual(a[k], b[k])
+  );
+}
+function attempt(fn) {
+  try {
+    return fn();
+  } catch {
+    return null;
+  }
+}
+function sameValue(a, b) {
+  return deepEqual(normalize(a), normalize(b));
+}
+var REGEX_PATTERN_FILTERS = /* @__PURE__ */ new Set([
+  "regex_test",
+  "regex_match",
+  "regex_match_all",
+  "regex_matches",
+  "regex_replace",
+  "regex_get_all_matches",
+  "regex_get_first_match"
+]);
+function isBlankObject(value) {
+  return value === "" || value === null;
+}
+function splitSlashRegex(value) {
+  const m = /^\/(.*)\/([a-zA-Z]*)$/s.exec(value);
+  return m ? { body: m[1], flags: m[2] } : null;
+}
+function encodedTextOf(value) {
+  const m = /^\(("(?:[^"\\]|\\.)*")\)$/s.exec(value);
+  if (m === null) return void 0;
+  try {
+    const text = JSON.parse(m[1]);
+    return typeof text === "string" ? text : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isBlankTag(tag) {
+  return tag.startsWith("const") && tag !== "const" && tag !== "const:obj";
+}
+function decodeBase(v, regexPiped) {
+  const bare = { value: v.value, tag: v.tag, filters: [] };
+  const propose = (expr, built, ...symbols) => built && sameValue(built, bare) ? { expr, value: built, symbols } : null;
+  const blankTag = v.value === "" && isBlankTag(v.tag) ? v.tag : null;
+  if (blankTag) {
+    return propose(call("c.blank", lit(blankTag)), attempt(() => c.blank(blankTag)), "c");
+  }
+  switch (v.tag) {
+    case "const": {
+      if (regexPiped) {
+        const parts = splitSlashRegex(v.value);
+        if (parts) {
+          const args = parts.flags ? [lit(parts.body), lit(parts.flags)] : [lit(parts.body)];
+          const built = attempt(() => c.regex(parts.body, parts.flags));
+          const candidate = propose(call("c.regex", ...args), built, "c");
+          if (candidate) return candidate;
+        }
+        return null;
+      }
+      return propose(call("c.text", lit(v.value)), attempt(() => c.text(v.value)), "c");
+    }
+    case "const:encoded": {
+      const text = encodedTextOf(v.value);
+      if (text === void 0 || regexPiped) return null;
+      return propose(call("c.text", lit(text)), attempt(() => c.text(text)), "c");
+    }
+    case "const:int": {
+      const n = Number(v.value);
+      if (Number.isSafeInteger(n)) {
+        const asNumber = propose(call("c.int", lit(n)), attempt(() => c.int(n)), "c");
+        if (asNumber) return asNumber;
+      }
+      return propose(call("c.int", lit(v.value)), attempt(() => c.int(v.value)), "c");
+    }
+    case "const:decimal": {
+      const n = Number(v.value);
+      if (!Number.isFinite(n)) return null;
+      const asNumber = propose(call("c.decimal", lit(n)), c.decimal(n), "c");
+      if (asNumber) return asNumber;
+      return propose(call("c.decimal", lit(v.value)), c.decimal(v.value), "c");
+    }
+    case "const:bool": {
+      const b = v.value === "true";
+      return propose(call("c.bool", lit(b)), c.bool(b), "c");
+    }
+    case "const:null":
+      return propose(call("c.null"), c.null(), "c");
+    // The engine's native current-time constant. `c.now()` is the only authoring
+    // form, and it only reproduces `value:"now"` — every occurrence in a real
+    // workspace is exactly that, and any other value falls through to `rawValue`
+    // rather than being decoded as a "now" it is not.
+    case "const:epochms":
+      return propose(call("c.now"), c.now(), "c");
+    case "const:array":
+    case "const:obj": {
+      if (v.tag === "const:obj" && isBlankObject(v.value)) {
+        return propose(call("c.obj", lit(null)), attempt(() => c.obj(null)), "c");
+      }
+      if (v.tag === "const:obj" && v.value === "null") {
+        const objNull = "const:obj";
+        return propose(call("c.null", lit(objNull)), attempt(() => c.null(objNull)), "c");
+      }
+      const parsed = attempt(() => JSON.parse(v.value));
+      if (parsed === null && v.value !== "null") return null;
+      const isArray = Array.isArray(parsed);
+      if (isArray !== (v.tag === "const:array")) return null;
+      const built = attempt(
+        () => isArray ? c.array(parsed) : c.obj(parsed)
+      );
+      return propose(call(isArray ? "c.array" : "c.obj", lit(parsed)), built, "c");
+    }
+    case "var":
+      return propose(call("ref", lit(v.value)), attempt(() => ref(v.value)), "ref");
+    case "input":
+      return propose(call("inp", lit(v.value)), inp(v.value), "inp");
+    case "auth":
+      return propose(call("auth", lit(v.value)), auth(v.value), "auth");
+    case "col":
+      return propose(call("col", lit(v.value)), col(v.value), "col");
+    case "trycatch":
+      return propose(call("caught", lit(v.value)), caught(v.value), "caught");
+    case "output":
+      return propose(call("out", lit(v.value)), out(v.value), "out");
+    case "response": {
+      const path = parseRespPath(v.value);
+      if (path === null) return null;
+      return propose(
+        path === "" ? call("resp") : call("resp", lit(path)),
+        attempt(() => resp(path)),
+        "resp"
+      );
+    }
+    case "setting": {
+      const isEnvVar = !v.value.startsWith("$");
+      return isEnvVar ? propose(call("env", lit(v.value)), attempt(() => env(v.value)), "env") : propose(call("setting", lit(v.value)), attempt(() => setting(v.value)), "setting");
+    }
+    // The older expression form. `obj()` always emits `const:expr2`, so no
+    // object-building path can reproduce this tag — but `c.expressionLegacy` carries
+    // the source verbatim, which is both exact and readable.
+    case "const:expr":
+      return propose(call("c.expressionLegacy", lit(v.value)), attempt(() => c.expressionLegacy(v.value)), "c");
+    case "const:expr2": {
+      const parsed = parseObjExpr(v.value);
+      if (parsed) {
+        const built = attempt(() => obj(parsed.built));
+        const candidate = propose(parsed.expr, built, ...parsed.symbols);
+        if (candidate) return candidate;
+      }
+      return propose(call("c.expression", lit(v.value)), attempt(() => c.expression(v.value)), "c");
+    }
+    // A toolset-scoped binding. Guarded on the accepted path set rather than
+    // decoded for any value: the authoring type is a closed union, and emitting
+    // a call it rejects would leave the pulled tree failing its own type-check.
+    // An unrecognised name keeps its `rawValue` — exact, and honest about being
+    // a name the SDK does not model.
+    case "toolset":
+      return isToolsetPath(v.value) ? propose(call("toolset", lit(v.value)), toolset(v.value), "toolset") : null;
+    default:
+      return null;
+  }
+}
+function filterCallee(name) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? `fl.${name}` : `fl[${JSON.stringify(name)}]`;
+}
+function literalFilter(stored) {
+  return {
+    expr: lit(stored),
+    value: { value: "", tag: "const", filters: [] },
+    symbols: []
+  };
+}
+function decodeFilter(stored) {
+  const known = FILTER_NAMES.includes(stored.name);
+  if (!known || (stored.disabled ?? false) !== false || !Array.isArray(stored.arg)) {
+    return literalFilter(stored);
+  }
+  if (stored.arg.length < ((Object.hasOwn(FILTER_REQUIRED_ARGS, stored.name) ? FILTER_REQUIRED_ARGS[stored.name] : void 0) ?? 0)) {
+    return literalFilter(stored);
+  }
+  if (stored.arg.some((arg) => arg === null || typeof arg !== "object")) return null;
+  const args = [];
+  const symbols = /* @__PURE__ */ new Set(["fl"]);
+  const built = [];
+  for (const arg of stored.arg) {
+    const candidate = decodeValueCandidate(arg);
+    if (!candidate) return literalFilter(stored);
+    args.push(candidate.expr);
+    built.push(candidate.value);
+    for (const symbol of candidate.symbols) symbols.add(symbol);
+  }
+  const factory = fl[stored.name];
+  const encoded = factory ? attempt(() => factory(...built)) : null;
+  if (!encoded || !sameValue(encoded, stored)) return literalFilter(stored);
+  return {
+    expr: call(filterCallee(stored.name), ...args),
+    // A filter is not a value; the caller only reads `expr`/`symbols` here.
+    value: { value: "", tag: "const", filters: [] },
+    symbols: [...symbols]
+  };
+}
+function decodeFilterChain(filters) {
+  const exprs = [];
+  const symbols = /* @__PURE__ */ new Set();
+  for (const stored of filters) {
+    const decoded = decodeFilter(stored);
+    if (!decoded) {
+      exprs.push(lit(stored));
+      continue;
+    }
+    exprs.push(decoded.expr);
+    for (const symbol of decoded.symbols) symbols.add(symbol);
+  }
+  return { exprs, symbols: [...symbols] };
+}
+function decodeObjSetChain(filters) {
+  const out2 = /* @__PURE__ */ Object.create(null);
+  for (const f2 of filters) {
+    if (f2.name !== "set" || f2.disabled || f2.arg.length !== 2) return null;
+    const [path, member] = f2.arg;
+    if (path.tag !== "const" || (path.filters?.length ?? 0) > 0) return null;
+    const decoded = decodeObjMember(member);
+    if (!decoded) return null;
+    const key2 = parseSetPath(path.value);
+    if (key2 === "__proto__") return null;
+    out2[key2] = decoded.value;
+  }
+  return { ...out2 };
+}
+function parseSetPath(stored) {
+  const bracketed = /^\["(.*)"\]$/s.exec(stored);
+  return bracketed ? bracketed[1].replace(/\\(["\\])/g, "$1") : stored;
+}
+function parseRespPath(stored) {
+  if (stored === "response") return "";
+  if (!stored.startsWith("response")) return null;
+  let rest = stored.slice("response".length);
+  const segments = [];
+  while (rest.length > 0) {
+    const bare = /^\.([A-Za-z_][A-Za-z0-9_]*)/.exec(rest);
+    if (bare) {
+      segments.push(bare[1]);
+      rest = rest.slice(bare[0].length);
+      continue;
+    }
+    const bracketed = /^\["((?:[^"\\]|\\.)*)"\]/s.exec(rest);
+    if (bracketed) {
+      segments.push(bracketed[1].replace(/\\(["\\])/g, "$1"));
+      rest = rest.slice(bracketed[0].length);
+      continue;
+    }
+    return null;
+  }
+  return segments.join(".");
+}
+function decodeObjMember(m) {
+  const filters = Array.isArray(m.filters) ? m.filters : [];
+  if (m.tag === "const:obj" && m.value === "{}") {
+    const nested = decodeObjSetChain(filters);
+    return nested ? { value: nested } : null;
+  }
+  if (filters.length > 0) return null;
+  switch (m.tag) {
+    case "const":
+      return { value: m.value };
+    case "const:null":
+      return { value: null };
+    case "const:bool":
+      return { value: m.value === "true" };
+    case "const:int":
+    case "const:decimal":
+      return { value: Number(m.value) };
+    case "const:array":
+      return attempt(() => ({ value: JSON.parse(m.value) }));
+    default:
+      return null;
+  }
+}
+function decodeValueCandidate(v, regexSlot = false) {
+  if (v === null || typeof v !== "object") return null;
+  const filters = Array.isArray(v.filters) ? v.filters : [];
+  if (v.tag === "const:obj" && v.value === "{}" && filters.length > 0) {
+    const record = decodeObjSetChain(filters);
+    const built2 = record ? attempt(() => c.obj(record)) : null;
+    if (built2 && record && sameValue(built2, v)) {
+      return { expr: call("c.obj", lit(record)), value: built2, symbols: ["c"] };
+    }
+  }
+  const base = decodeBase(
+    v,
+    regexSlot || filters.some((filter) => REGEX_PATTERN_FILTERS.has(filter.name))
+  );
+  if (!base) return null;
+  if (filters.length === 0) return base;
+  const symbols = /* @__PURE__ */ new Set([...base.symbols, "withFilters"]);
+  const filterExprs = [];
+  const builtFilters = [];
+  for (const stored of filters) {
+    const decoded = decodeFilter(stored);
+    if (!decoded) return null;
+    filterExprs.push(decoded.expr);
+    builtFilters.push(stored);
+    for (const symbol of decoded.symbols) symbols.add(symbol);
+  }
+  const built = attempt(() => withFilters(base.value, ...builtFilters));
+  if (!built || !sameValue(built, v)) return null;
+  return {
+    expr: call("withFilters", base.expr, ...filterExprs),
+    value: built,
+    symbols: [...symbols]
+  };
+}
+function fallbackExpr(v) {
+  const entries = [
+    ["value", lit(v.value)],
+    ["tag", lit(v.tag)]
+  ];
+  if (Array.isArray(v.filters) && v.filters.length > 0) entries.push(["filters", lit(v.filters)]);
+  return call("rawValue", obj2(entries));
+}
+function decodeValue(ctx, v, opts = {}) {
+  const candidate = decodeValueCandidate(v, opts.regexPattern === true);
+  if (candidate) {
+    for (const symbol of candidate.symbols) ctx.use(SDK_MODULE, symbol);
+    return candidate.expr;
+  }
+  ctx.use(CODEGEN_MODULE, "rawValue");
+  ctx.problem("value-fallback", describeFallback(v));
+  return fallbackExpr(v);
+}
+function describeFallback(v) {
+  const hole = nonValueFilterArg(v);
+  if (hole !== void 0) {
+    return `filter \`${hole.filter}\` stores argument ${hole.index + 1} as ${hole.stored} rather than a value \u2014 the shape an earlier SDK wrote for a trigger input accessor (\`t.action\`) passed as a filter argument, which lost the value it named. Carried verbatim so the bytes do not change; put back the value that was meant (e.g. \`inp("action")\`)`;
+  }
+  if (!TAGS.includes(v.tag)) {
+    return `unknown tag ${v.tag} has no idiomatic form; emitted verbatim`;
+  }
+  if (v.value === "") {
+    return `a blank ${v.tag} \u2014 a reference that names nothing, so there is no target to resolve and no \`${v.tag}\` constructor call that would mean this. Carried verbatim so it keeps meaning exactly what it stores; bind it upstream to give it one`;
+  }
+  return `tag ${v.tag} stores ${JSON.stringify(v.value)}, which no \`c.*\` constructor reproduces exactly; emitted verbatim`;
+}
+function nonValueFilterArg(v) {
+  const stack = [v];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node === null || typeof node !== "object" || !Array.isArray(node.filters)) continue;
+    for (const f2 of node.filters) {
+      if (f2 === null || typeof f2 !== "object" || !Array.isArray(f2.arg)) continue;
+      const index = f2.arg.findIndex((a) => a === null || typeof a !== "object");
+      if (index !== -1) return { filter: String(f2.name), index, stored: describeStored(f2.arg[index]) };
+      stack.push(...f2.arg);
+    }
+  }
+  return void 0;
+}
+function describeStored(v) {
+  if (v === void 0) return "absent";
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "an array";
+  if (typeof v === "object") return "an object with no `tag`";
+  return `a ${typeof v}`;
+}
+function readValueOrBare(ctx, stored) {
+  if (typeof stored === "string" || typeof stored === "number" || typeof stored === "boolean") {
+    return { runtime: stored, expr: lit(stored) };
+  }
+  if (stored === null || typeof stored !== "object") return null;
+  const block = stored;
+  if (typeof block.tag !== "string" || block.value === void 0) return null;
+  const value = {
+    value: block.value,
+    tag: block.tag,
+    filters: Array.isArray(block.filters) ? block.filters : []
+  };
+  return { runtime: value, expr: decodeValue(ctx, value) };
+}
+
+// src/codegen/field.ts
+var INPUT_ONLY_BY_TYPE = { file: "file" };
+var ENCODER_FIXED = [
+  // `merge` and `hidden` are NOT here: they are authorable field options, which
+  // is what lets a merged/hidden field come back as a readable catalog call.
+  // Together they would be the largest single cause of `rawField()`.
+  ["override", []],
+  ["is_settings_registry", false]
+];
+function sameField(a, b) {
+  return deepEqual2(normalize(a), normalize(b));
+}
+function differingKeys(encoded, stored) {
+  const a = normalize(encoded);
+  const b = normalize(stored);
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return [];
+  const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  return [...keys].filter((key2) => !deepEqual2(a[key2], b[key2])).sort();
+}
+function describeDiff(encoded, stored) {
+  const keys = differingKeys(encoded, stored);
+  return keys.length === 0 ? "differs structurally" : `differs at ${keys.join(", ")}`;
+}
+function deepEqual2(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((item, i) => deepEqual2(item, b[i]));
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  const ak = Object.keys(a);
+  const bk = Object.keys(b);
+  if (ak.length !== bk.length) return false;
+  return ak.every(
+    (k) => Object.hasOwn(b, k) && deepEqual2(a[k], b[k])
+  );
+}
+function unrepresentableKeys(stored) {
+  const record = stored;
+  const fixed = [...ENCODER_FIXED];
+  return fixed.filter(
+    ([key2, value]) => Object.hasOwn(record, key2) && !deepEqual2(normalize({ [key2]: record[key2] }), normalize({ [key2]: value }))
+  ).map(([key2]) => key2);
+}
+function colonForm(name, args) {
+  if (name.includes(":")) return null;
+  if (args.length === 0) return name;
+  if (!args.every((a) => typeof a === "number" || typeof a === "string")) return null;
+  const candidate = [name, ...args].join(":");
+  const { name: reName, arg: recovered } = parseMethod(candidate);
+  if (reName !== name || recovered.length !== args.length) return null;
+  return recovered.every((value, i) => value === args[i]) ? candidate : null;
+}
+var ENUMERATED_METHODS = new Set(
+  Object.values(FIELD_METHODS).flatMap((methods) => Object.keys(methods))
+);
+function recoverMethods(stored) {
+  const out2 = [];
+  for (const method of stored) {
+    if ((method.disabled ?? false) !== false) return null;
+    const args = method.arg ?? [];
+    const shorthand = ENUMERATED_METHODS.has(method.name) ? colonForm(method.name, args) : null;
+    out2.push(shorthand ?? { name: method.name, arg: [...args] });
+  }
+  return out2;
+}
+function recoverCustomize(stored) {
+  if (isEmptyCustomize(stored)) return null;
+  if (stored === null || typeof stored !== "object" || Array.isArray(stored)) return void 0;
+  const out2 = {};
+  for (const [name, value] of Object.entries(stored)) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+    const node = value;
+    const known = /* @__PURE__ */ new Set(["hidden", "default", "methods", "required", "customize"]);
+    if (Object.keys(node).some((key2) => !known.has(key2))) return void 0;
+    const methods = recoverMethods(node.methods ?? []);
+    if (methods === null) return void 0;
+    const nested = recoverCustomize(node.customize);
+    if (nested === void 0) return void 0;
+    const recovered = {};
+    if (node.hidden === true) recovered.hidden = true;
+    if (node.required === true) recovered.required = true;
+    if (node.default !== void 0 && node.default !== "") {
+      recovered.default = node.default;
+    }
+    if (methods.length > 0) recovered.methods = methods;
+    if (nested !== null) recovered.customize = nested;
+    out2[name] = recovered;
+  }
+  return out2;
+}
+function recoverOptions(stored, context, elide = true) {
+  const options = {};
+  const values = Array.isArray(stored.values) ? stored.values : [];
+  const list = stored.list ?? { min: "", max: "" };
+  const vector = stored.vector ?? { size: 3 };
+  const style = stored.style ?? { type: "single" };
+  const access = stored.access ?? "public";
+  const format = stored.format ?? "";
+  const mode = stored.mode ?? "";
+  const fallbackDefault = stored.default ?? "";
+  if (stored.merge === true || !elide) options.merge = stored.merge === true;
+  const hidden = Array.isArray(stored.hidden) ? stored.hidden : [];
+  if (hidden.length > 0 || !elide) options.hidden = [...hidden];
+  const nullable = stored.nullable ?? false;
+  if (nullable !== defaultNullable(String(stored.type ?? ""), context) || !elide) options.nullable = nullable;
+  if (stored.required || !elide) options.required = stored.required ?? false;
+  if (stored.sensitive || !elide) options.sensitive = stored.sensitive ?? false;
+  if (!Object.hasOwn(stored, "default")) options.noDefault = true;
+  else if (fallbackDefault !== "" || !elide) options.default = fallbackDefault;
+  if (mode !== "" || !elide) options.mode = mode;
+  if (format !== "" || !elide) options.format = format;
+  if (access !== "public" || !elide) options.access = access;
+  if (values.length > 0) options.values = [...values];
+  if (!hasNoListBounds(list)) options.list = { ...list };
+  if (!deepEqual2(vector, { size: 3 })) options.vector = { ...vector };
+  if (style.type === "list") options.array = true;
+  else if (!deepEqual2(style, { type: "single" })) {
+    options.style = { type: style.type };
+  }
+  if (context.includeDescription && stored.description !== void 0 && stored.description !== "") {
+    options.description = stored.description;
+  }
+  const methods = recoverMethods(stored.methods ?? []);
+  if (methods === null) return null;
+  if (methods.length > 0) options.methods = methods;
+  const customize = recoverCustomize(stored.customize);
+  if (customize === void 0) return null;
+  if (customize !== null) options.customize = customize;
+  const children = [];
+  for (const child of storedChildren(stored)) {
+    const childOptions = recoverOptions(child, context);
+    if (childOptions === null) return null;
+    children.push({ name: child.name, type: child.type, ...childOptions });
+  }
+  if (children.length > 0) options.children = children;
+  return options;
+}
+function storedChildren(stored) {
+  return stored.children ?? [];
+}
+function unbindLocalCustomizeRefs(stored) {
+  const customize = stored.customize;
+  if (customize === null || typeof customize !== "object") return { field: stored, unbound: [] };
+  const cleared = /* @__PURE__ */ new Set();
+  const rewritten = clearLocalDboRefs(customize, cleared);
+  if (cleared.size === 0) return { field: stored, unbound: [] };
+  return { field: { ...stored, customize: rewritten }, unbound: [...cleared].sort() };
+}
+function optionsExpr(options, omit = []) {
+  const entries = [];
+  for (const [key2, value] of Object.entries(options)) {
+    if (omit.includes(key2)) continue;
+    entries.push([key2, lit(value)]);
+  }
+  return obj2(entries);
+}
+function decodeField(ctx, refs, stored, surface, resolve = {}) {
+  const context = surface === "input" ? INPUT_CONTEXT : COLUMN_CONTEXT;
+  const { field: stored_, unbound } = unbindLocalCustomizeRefs(stored);
+  if (unbound.length > 0) {
+    ctx.problem(
+      "unportable-id",
+      `field "${stored.name}" references ${unbound.join(", ")} inside \`customize\` by LOCAL row id rather than by guid \u2014 an internal id is not portable identity, so it is recovered as unbound (\`dbo=\`). A re-deploy will not re-link it, including back into the workspace it came from`
+    );
+  }
+  stored = stored_;
+  if (stored.name === "" && (stored.type === "" || stored.type === void 0)) {
+    ctx.problem(
+      "workspace-defect",
+      `an ${surface === "input" ? "input" : "column"} has no name and no type \u2014 an editor row that was added and never filled in. Nothing can bind to it (there is no name to bind), and the engine reads no type for it. Remove it upstream, or give it a name and a type. It is carried into the tree as stored so the pull still describes the workspace`,
+      "unnamed, untyped"
+    );
+  }
+  const options = recoverOptions(stored, context);
+  const missing = unrepresentableKeys(stored);
+  if (missing.length > 0) {
+    ctx.use(CODEGEN_MODULE, "rawField");
+    ctx.problem(
+      "value-fallback",
+      `field "${stored.name}" stores ${missing.join(", ")} in a shape no authoring surface can produce; emitted verbatim via rawField()`
+    );
+    return { idiomatic: false, expr: call("rawField", lit(stored)) };
+  }
+  const descriptorLiteral = () => {
+    const descriptor = obj2([
+      ["type", lit(stored.type)],
+      ["options", options === null ? lit({}) : optionsExpr(options)]
+    ]);
+    if (options !== null && sameField(encodeField(stored.name, stored.type, options, context), stored)) {
+      return { idiomatic: false, expr: descriptor };
+    }
+    ctx.use(CODEGEN_MODULE, "rawField");
+    return { idiomatic: false, expr: call("rawField", lit(stored)) };
+  };
+  const literalBecause = (why) => {
+    if (missing.length === 0) {
+      ctx.problem(
+        "value-fallback",
+        `field "${stored.name}" (${stored.type}) emitted as a descriptor literal: ${why}`
+      );
+    }
+    return descriptorLiteral();
+  };
+  if (options === null) {
+    return literalBecause("its options could not be recovered from the stored shape");
+  }
+  const reEncoded = encodeField(stored.name, stored.type, options, context);
+  if (!sameField(reEncoded, stored)) {
+    return literalBecause(`re-encoding the recovered options ${describeDiff(reEncoded, stored)}`);
+  }
+  const ns = ctx.use(SDK_MODULE, surface);
+  const opts = options;
+  let lastRejection = "no catalog form was attempted";
+  const proven = (expr, build) => {
+    let built;
+    try {
+      built = build();
+    } catch (err) {
+      lastRejection = `the catalog constructor threw (${err instanceof Error ? err.message : String(err)})`;
+      return null;
+    }
+    const encoded = encodeField(stored.name, built.type, built.options, context);
+    if (sameField(encoded, stored)) return { idiomatic: true, expr: asInputList(expr) };
+    lastRejection = `the catalog call ${describeDiff(encoded, stored)}`;
+    return null;
+  };
+  const asInputList = (expr) => {
+    if (surface !== "input" || opts.array !== true || expr.kind !== "call") return expr;
+    const last = expr.args[expr.args.length - 1];
+    if (last?.kind !== "object") return expr;
+    const entries = last.entries.filter(([key2]) => key2 !== "array");
+    const args = [...expr.args.slice(0, -1), ...entries.length > 0 ? [obj2(entries)] : []];
+    return call(`${ns}.list`, call(expr.callee, ...args));
+  };
+  const catalog = surface === "input" ? input : f;
+  if (stored.type === "enum") {
+    lastRejection = `its default ${JSON.stringify(opts.default)} is not one of its values, which the \`enum\` constructor refuses`;
+  }
+  const dbLinkGuid = linkedTableOf(stored);
+  if (dbLinkGuid !== null && surface === "input") {
+    const rest = { ...opts };
+    delete rest.merge;
+    const restExpr = optionsExpr(rest);
+    const args = [
+      resolveReference(ctx, refs, dbLinkGuid, { ...resolve, unresolved: "object-ref" })
+    ];
+    if (restExpr.kind === "object" && restExpr.entries.length > 0) args.push(restExpr);
+    const decoded = proven(
+      call(`${ns}.dbLink`, ...args),
+      () => input.dbLink({ name: "", guid: dbLinkGuid }, rest)
+    );
+    if (decoded) return decoded;
+  }
+  const refGuid = tableRefOf(stored);
+  if (refGuid !== null) {
+    const withoutRef = { ...opts, methods: opts.methods.slice(0, -1) };
+    if (withoutRef.methods.length === 0) delete withoutRef.methods;
+    const entries = stored.type === "uuid" ? [["type", lit("uuid")]] : [];
+    for (const [key2, value] of Object.entries(withoutRef)) entries.push([key2, lit(value)]);
+    const args = [
+      resolveReference(ctx, refs, refGuid, { ...resolve, unresolved: "object-ref" })
+    ];
+    const tail = { ...stored.type === "uuid" ? { type: "uuid" } : {}, ...withoutRef };
+    if (entries.length > 0) args.push(obj2(entries));
+    const decoded = proven(
+      call(`${ns}.tableRef`, ...args),
+      () => f.tableRef({ name: "", guid: refGuid }, tail)
+    );
+    if (decoded) return decoded;
+  } else if (stored.type === "enum" && // A stored default outside the values does not type-check as `f.enum(…)`
+  // (`EnumDefault`); the descriptor literal below still carries it.
+  (opts.default === void 0 || opts.default === "" || (opts.values ?? []).some((v) => String(v) === String(opts.default)))) {
+    const rest = optionsExpr(opts, ["values"]);
+    const args = [lit(opts.values ?? [])];
+    if (rest.kind === "object" && rest.entries.length > 0) args.push(rest);
+    const { values, ...restOpts } = opts;
+    const decoded = proven(
+      call(`${ns}.enum`, ...args),
+      () => catalog.enum(
+        values ?? [],
+        restOpts
+      )
+    );
+    if (decoded) return decoded;
+  } else if (stored.type === "vector") {
+    const rest = optionsExpr(opts, ["vector"]);
+    const args = [lit(opts.vector?.size ?? 3)];
+    if (rest.kind === "object" && rest.entries.length > 0) args.push(rest);
+    const { vector, ...restOpts } = opts;
+    const decoded = proven(
+      call(`${ns}.vector`, ...args),
+      () => catalog.vector(
+        vector?.size ?? 3,
+        restOpts
+      )
+    );
+    if (decoded) return decoded;
+  } else if (stored.type === "obj") {
+    const rest = optionsExpr(opts, ["children"]);
+    const children = storedChildren(stored);
+    const args = [
+      obj2(children.map((child) => [child.name, decodeField(ctx, refs, child, surface, resolve).expr]))
+    ];
+    if (rest.kind === "object" && rest.entries.length > 0) args.push(rest);
+    const { children: childOpts, ...restOpts } = opts;
+    const decoded = proven(
+      call(`${ns}.object`, ...args),
+      () => catalog.object(
+        Object.fromEntries(
+          (childOpts ?? []).map(({ name, type, ...rest2 }) => [name, { type, options: rest2 }])
+        ),
+        restOpts
+      )
+    );
+    if (decoded) return decoded;
+  } else {
+    const accessor = (Object.hasOwn(CATALOG_BY_TYPE, stored.type) ? CATALOG_BY_TYPE[stored.type] : void 0) ?? (surface === "input" ? Object.hasOwn(INPUT_ONLY_BY_TYPE, stored.type) ? INPUT_ONLY_BY_TYPE[stored.type] : void 0 : void 0);
+    if (accessor !== void 0) {
+      const [head, leaf] = accessor.split(".");
+      const factory = leaf === void 0 ? catalog[head] : catalog[head][leaf];
+      const candidates = [opts];
+      const bare = (() => {
+        try {
+          return factory({}).options;
+        } catch {
+          return null;
+        }
+      })();
+      if (bare) {
+        const lean = Object.fromEntries(
+          Object.entries(opts).filter(([key2, value]) => !deepEqual2(value, bare[key2]))
+        );
+        if (Object.keys(lean).length < Object.keys(opts).length) candidates.unshift(lean);
+        const full = recoverOptions(stored, context, false);
+        if (full) {
+          const restated = Object.fromEntries(
+            Object.keys(bare).filter((key2) => Object.hasOwn(full, key2)).map((key2) => [key2, full[key2]])
+          );
+          candidates.push({ ...opts, ...restated });
+        }
+      }
+      for (const candidate of candidates) {
+        const rest = optionsExpr(candidate);
+        const args = rest.kind === "object" && rest.entries.length > 0 ? [rest] : [];
+        const decoded = proven(call(`${ns}.${accessor}`, ...args), () => factory(candidate));
+        if (decoded) return decoded;
+      }
+    }
+  }
+  ctx.problem(
+    "value-fallback",
+    `field "${stored.name}" (${stored.type}) emitted as a descriptor literal: ${lastRejection}`
+  );
+  return descriptorLiteral();
+}
+function decodeFieldMap(ctx, refs, fields, surface, resolve = {}) {
+  return obj2(
+    fields.map((field) => [
+      field.name,
+      ctx.at(
+        `${surface === "input" ? "input" : "schema"}.${field.name}`,
+        () => decodeField(ctx, refs, field, surface, resolve).expr
+      )
+    ])
+  );
+}
+var ARRAY_INDEX_KEY = /^(?:0|[1-9][0-9]{0,9})$/;
+function decodeTableSchema(ctx, refs, fields, resolve = {}) {
+  if (!fields.some((field) => ARRAY_INDEX_KEY.test(field.name) && Number(field.name) < 2 ** 32 - 1)) {
+    return decodeFieldMap(ctx, refs, fields, "f", resolve);
+  }
+  return arr(
+    fields.map(
+      (field) => spread(
+        ctx.at(`schema.${field.name}`, () => decodeField(ctx, refs, field, "f", resolve).expr),
+        [["name", lit(field.name)]]
+      )
+    )
+  );
+}
+function decodeResponse(ctx, stored) {
+  if (stored.length === 0) return void 0;
+  const asValue = (item) => ({
+    value: item.value,
+    tag: item.tag,
+    filters: item.filters ?? []
+  });
+  const live = stored.filter((item) => !isDeadResultItem(item, stored.length));
+  if (live.length < stored.length) {
+    const dropped = stored.length - live.length;
+    ctx.problem(
+      "expected-omission",
+      `${dropped} response item${dropped === 1 ? " is" : "s are"} skipped by the engine \u2014 ${dropped === 1 ? "it sets" : "they set"} \`disabled\`, or ${dropped === 1 ? "names" : "name"} nothing to key the response by \u2014 so ${dropped === 1 ? "it contributes" : "they contribute"} no value and ${dropped === 1 ? "is" : "are"} not carried across`
+    );
+  }
+  if (live.length === 0) return void 0;
+  if (live.length === 1 && live[0].name === "") return decodeValue(ctx, asValue(live[0]));
+  const names = live.map((item) => item.name);
+  if (new Set(names).size !== names.length || names.some((name) => name === "")) {
+    ctx.use(CODEGEN_MODULE, "rawResponse");
+    ctx.problem(
+      "raw-fallback",
+      `the response has ${live.length} live items whose names do not key it (blank or repeated), which the record form cannot carry; emitted verbatim via rawResponse()`
+    );
+    return call("rawResponse", lit(stored));
+  }
+  return obj2(
+    live.map((item) => [item.name, ctx.at(`response.${item.name}`, () => decodeValue(ctx, asValue(item)))])
+  );
+}
+
+export {
+  diffKeyPaths,
+  recordProveDecline,
+  recordProveAbort,
+  withDeclineContext,
+  declineHere,
+  SDK_MODULE,
+  CODEGEN_MODULE,
+  DecodeContext,
+  id,
+  lit,
+  call,
+  obj2 as obj,
+  arr,
+  spread,
+  arrow,
+  printExpr,
+  printModule,
+  RefIndex,
+  microserviceHost,
+  isReferenceId,
+  isUnboundId,
+  isBoundNumericId,
+  resolveReference,
+  decodeFilterChain,
+  decodeValue,
+  describeStored,
+  readValueOrBare,
+  deepEqual2 as deepEqual,
+  recoverOptions,
+  decodeField,
+  decodeFieldMap,
+  decodeTableSchema,
+  decodeResponse
+};
+//# sourceMappingURL=chunk-TPHWJ7UG.js.map