@xano/sdk 1.0.0

package/dist/chunk-L5JYN3NM.js

@@ -0,0 +1,1038 @@
+import {
+  impliedInputs
+} from "./chunk-G554NZNI.js";
+
+// src/validate/normalize.ts
+var STRIP_KEYS = /* @__PURE__ */ new Set([
+  // server columns / persistence
+  "id",
+  "created_at",
+  "updated_at",
+  "deleted_at",
+  "guid",
+  "_draft",
+  // auto-generated xsids / runtime keys
+  "_xsid",
+  "@guid",
+  "@index",
+  "stack_id",
+  "index",
+  // deploy-target / market binding (deferred)
+  "workspace",
+  "branch",
+  "market_item",
+  // The CREATOR of a knowledge item (`{id: 0}` for anything an import created).
+  // Server-assigned provenance, in the same family as the already-stripped
+  // `workspace`/`branch` bindings: the SDK never authors it, and a workspace
+  // synced by two different people would otherwise diff on who touched it last.
+  // Verified to be a knowledge-only key — no encoder in this SDK emits `user`
+  // anywhere in a compiled payload.
+  "user",
+  // engine-stored source artifact (the raw XanoScript text), not authored data
+  "xanoscript",
+  // A workflow test's LAST RUN result — when it ran, how long it took, and the
+  // pass/fail of each statement. Instance state produced by executing the test,
+  // not workspace source, so the SDK neither authors nor emits it. A stored
+  // object always carries the key (`null` until the test has been run once), so
+  // without this the whole kind reads as a failed round trip.
+  "lastRun",
+  // storage-mode flag the golden table corpus predates (those fixtures were
+  // captured before `use_xdo` was serialized). The SDK always emits it; it
+  // doesn't change the authored schema, so drop it from both sides — same as
+  // the already-stripped `index`, whose gin entry `use_xdo` only gates.
+  "use_xdo",
+  // A dead key, dropped for the same reason as `iterator` (see
+  // {@link returnWithoutIterator}) and traced the same way.
+  //
+  // Xano's frontend writes `context: {dbo:{id}, allow_notfound: true}` from ONE
+  // place — the auth scaffold generator that builds a signup/login query. No
+  // engine class reads it: the `mvp` get-by class consults `dbo`, `output`, and
+  // its args and nothing else, and the older non-MVP class reads a differently
+  // named `allow_null`. So the member cannot change what a query does.
+  //
+  // It is deliberately NOT modelled — an authoring surface for a key the engine
+  // ignores is the mistake this file already refuses to make elsewhere. But the
+  // exclusion was only half-done: the encoder correctly declined to write it
+  // while the comparison still demanded it, so a correct decision read as a
+  // round-trip failure and sent every scaffolded auth query to `raw()`.
+  "allow_notfound"
+]);
+function isEmptyObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v) && Object.keys(v).length === 0;
+}
+function isEmptyCustomize(v) {
+  return v === "" || isEmptyObject(v) || isEmptyArray(v);
+}
+function isSavedTest(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const rec = value;
+  return typeof rec.name === "string" && Array.isArray(rec.expect);
+}
+function isEmptyArray(v) {
+  return Array.isArray(v) && v.length === 0;
+}
+function isNumber(v, n) {
+  return v === n || typeof v === "string" && v !== "" && Number(v) === n;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
+  const aArr = Array.isArray(a);
+  if (aArr !== Array.isArray(b)) return false;
+  if (aArr) {
+    const x2 = a;
+    const y2 = b;
+    return x2.length === y2.length && x2.every((v, i) => deepEqual(v, y2[i]));
+  }
+  const x = a;
+  const y = b;
+  const keys = Object.keys(x);
+  return keys.length === Object.keys(y).length && keys.every((k) => deepEqual(x[k], y[k]));
+}
+var TIMESTAMP_RE = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})(?:\.\d+)?(Z|z|[+-]\d{2}:?\d{2})?$/;
+function canonicalizeTimestamp(s) {
+  const m = TIMESTAMP_RE.exec(s);
+  if (!m) return void 0;
+  let tz = m[3] ?? "Z";
+  if (tz === "z") tz = "Z";
+  if (/^[+-]\d{4}$/.test(tz)) tz = `${tz.slice(0, 3)}:${tz.slice(3)}`;
+  const d = /* @__PURE__ */ new Date(`${m[1]}T${m[2]}${tz}`);
+  return Number.isNaN(d.getTime()) ? void 0 : d.toISOString();
+}
+var DEFAULT_CONTEXT_RETURN = {
+  list: {
+    sort: [],
+    paging: { page: 1, offset: 0, totals: false, enabled: false, metadata: true, per_page: 25 },
+    distinct: "auto"
+  },
+  type: "list",
+  single: { sort: [] },
+  stream: { sort: [], paging: { page: 1, enabled: false, per_page: 25 }, distinct: "auto" },
+  aggregate: {
+    eval: [],
+    sort: [],
+    group: [],
+    index: [],
+    paging: { page: 1, enabled: false, metadata: true, per_page: 25 }
+  }
+};
+var DEFAULT_RETURN_BLOCKS = {
+  list: DEFAULT_CONTEXT_RETURN.list,
+  single: DEFAULT_CONTEXT_RETURN.single,
+  stream: DEFAULT_CONTEXT_RETURN.stream,
+  aggregate: DEFAULT_CONTEXT_RETURN.aggregate
+};
+var MINIMAL_CONTEXT_RETURN = { type: "list" };
+function hasNoListBounds(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const entries = Object.entries(value);
+  if (entries.length === 0) return false;
+  return entries.every(
+    ([member, bound]) => (member === "min" || member === "max") && (bound === "" || typeof bound === "object" && bound !== null && isEmptyObject(bound))
+  );
+}
+var PAGING_INT_KEYS = /* @__PURE__ */ new Set(["page", "per_page", "offset"]);
+var UNREADABLE_INPUT = /* @__PURE__ */ new Set(["mvp:create_image"]);
+function hasUnreadableInput(name) {
+  return typeof name === "string" && UNREADABLE_INPUT.has(name);
+}
+var RETIRED_INPUT = {
+  "mvp:datadog_log": { ddtags: "tags" },
+  "mvp:datadog_metric": { ddtags: "tags" },
+  "mvp:amazon_opensearch_query": { hidden_cols: "included_fields" },
+  "mvp:elasticsearch_query": { hidden_cols: "included_fields" }
+};
+var NO_RETIRED_INPUTS = [];
+function retiredInputs(name) {
+  const row = typeof name === "string" ? Object.hasOwn(RETIRED_INPUT, name) ? RETIRED_INPUT[name] : void 0 : void 0;
+  return row ? Object.keys(row) : NO_RETIRED_INPUTS;
+}
+function retiredInputSuccessor(name, input) {
+  const row = typeof name === "string" ? Object.hasOwn(RETIRED_INPUT, name) ? RETIRED_INPUT[name] : void 0 : void 0;
+  return row?.[input] ?? null;
+}
+var NAME_KEYED_INPUT = /* @__PURE__ */ new Set([
+  "mvp:create_auth",
+  "mvp:api_request",
+  "mvp:amazon_opensearch_document",
+  "mvp:elasticsearch_document"
+]);
+var EMPTY_SEARCH = { expression: [] };
+function isBlankGroupStatement(v) {
+  if (v === null || typeof v !== "object" || Array.isArray(v)) return false;
+  const node = v;
+  if (node.op !== "=") return false;
+  const blankSide = (side) => side !== null && typeof side === "object" && side.tag === "const" && side.operand === "";
+  return blankSide(node.left) && blankSide(node.right);
+}
+var RETURN_BLOCKS = ["single", "list", "stream", "aggregate"];
+var RETURN_TYPES = /* @__PURE__ */ new Set([...RETURN_BLOCKS, "count", "exists"]);
+function liveReturnSection(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const section = value;
+  const type = section.type;
+  if (typeof type !== "string" || !RETURN_TYPES.has(type)) return void 0;
+  const dead = RETURN_BLOCKS.filter((b) => b !== type && b in section);
+  if (dead.length === 0) return void 0;
+  const live = {};
+  for (const [k, v] of Object.entries(section)) {
+    if (!RETURN_BLOCKS.includes(k) || k === type) live[k] = v;
+  }
+  return live;
+}
+function unboundAuthTable(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const block = value;
+  if (block.dbo_id !== 0 || !("row_id" in block)) return void 0;
+  const rest = { ...block };
+  delete rest["dbo_id"];
+  return rest;
+}
+function returnWithoutIterator(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const section = value;
+  if (typeof section.type !== "string" || !RETURN_TYPES.has(section.type)) return void 0;
+  let found = false;
+  const out = {};
+  for (const [k, v] of Object.entries(section)) {
+    if (RETURN_BLOCKS.includes(k) && v !== null && typeof v === "object" && !Array.isArray(v) && "iterator" in v) {
+      found = true;
+      const rest = { ...v };
+      delete rest.iterator;
+      out[k] = rest;
+      continue;
+    }
+    out[k] = v;
+  }
+  return found ? out : void 0;
+}
+var DEDICATED_RUNTIME_KEYS = ["cpu", "memory", "timeout", "max_retry"];
+function liveAsyncRuntime(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const block = value;
+  const mode = block.mode;
+  if (typeof mode !== "string") return void 0;
+  if (mode === "disabled") return {};
+  if (mode !== "async-shared") return void 0;
+  if (!DEDICATED_RUNTIME_KEYS.some((k) => k in block)) return void 0;
+  const live = {};
+  for (const [k, v] of Object.entries(block)) {
+    if (!DEDICATED_RUNTIME_KEYS.includes(k)) live[k] = v;
+  }
+  return live;
+}
+function isDeadResultItem(item, total) {
+  if (item === null || typeof item !== "object" || Array.isArray(item)) return false;
+  const entry = item;
+  if (entry.disabled !== void 0 && entry.disabled !== false) return true;
+  return entry.name === "" && total !== 1;
+}
+function isResultList(value) {
+  return Array.isArray(value) && value.length > 0 && value.every(
+    (e) => e !== null && typeof e === "object" && !Array.isArray(e) && "name" in e && "value" in e && "tag" in e && "filters" in e
+  );
+}
+function liveResultItems(value) {
+  if (!isResultList(value)) return void 0;
+  const live = value.filter((e) => !isDeadResultItem(e, value.length));
+  return live.length === value.length ? void 0 : live;
+}
+function isBlankAgentSettings(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const settings = value;
+  if (settings.type !== "") return false;
+  if (settings.structuredOutputs === true) return false;
+  const schema = settings.structuredOutputsSchema;
+  if (Array.isArray(schema) && schema.length > 0) return false;
+  return true;
+}
+function configuredDeadReturnBlocks(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return [];
+  const section = value;
+  const type = section.type;
+  if (typeof type !== "string" || !RETURN_TYPES.has(type)) return [];
+  return RETURN_BLOCKS.filter((b) => b !== type && isConfiguredReturnBlock(section[b]));
+}
+function isConfiguredReturnBlock(block) {
+  if (block === null || typeof block !== "object" || Array.isArray(block)) return false;
+  const b = block;
+  for (const list of ["sort", "group", "eval", "index"]) {
+    if (Array.isArray(b[list]) && b[list].length > 0) return true;
+  }
+  const paging = b.paging;
+  return paging !== null && typeof paging === "object" && paging.enabled === true;
+}
+var DEFAULT_CONTEXT_EXTERNAL = {
+  tag: "input",
+  value: "",
+  permissions: { page: true, sort: true, search: true, per_page: false }
+};
+function bindsNoPagingFacet(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const facets = Object.values(value);
+  if (facets.length === 0) return false;
+  return facets.every(
+    (facet) => facet !== null && typeof facet === "object" && !Array.isArray(facet) && facet.value === "" && (facet.filters ?? []).length === 0
+  );
+}
+var DEFAULT_CORS = {
+  mode: "default",
+  allowOrigins: [],
+  allowHeaders: [],
+  allowCredentials: false,
+  maxAge: 0,
+  allowMethods: { delete: false, get: false, head: false, patch: false, post: false, put: false }
+};
+var DEFAULT_DOCUMENTATION = { require_token: false, token: "" };
+var DEFAULT_MIDDLEWARE = { pre: [], post: [], pre_customize: false, post_customize: false };
+function isRawSqlContext(container) {
+  return container !== null && typeof container === "object" && typeof container.code === "string";
+}
+function withoutLeadingJoin(v) {
+  if (v === null || typeof v !== "object") return v;
+  const expression = v.expression;
+  if (!Array.isArray(expression)) return v;
+  const cleared = expression.map((entry, i) => {
+    if (entry === null || typeof entry !== "object") return entry;
+    const node = entry;
+    const group = "group" in node ? { group: withoutLeadingJoin(node.group) } : {};
+    if (i > 0) return { ...node, ...group };
+    const rest = Object.fromEntries(Object.entries(node).filter(([key]) => key !== "or"));
+    return { ...rest, ...group };
+  });
+  return { ...v, expression: cleared };
+}
+function isDefaultEnvelopeMember(key, v) {
+  switch (key) {
+    // An empty `mocks` arrives as `[]` from the engine and `{}` from the SDK — the
+    // empty-associative-collection artifact again. Both mean "no mocks".
+    case "mocks":
+      return isEmptyObject(v) || isEmptyArray(v);
+    // An UNSET runtime binding, in both stored spellings: the `null` the engine
+    // writes on one generation and the blank-member object it writes on another
+    // (`{id: "", mode: ""}` on 6 real `mvp:function` statements). A binding that
+    // names anything is preserved and still compares.
+    case "runtime":
+      return v === null || typeof v === "object" && v !== null && !Array.isArray(v) && Object.values(v).every((member) => member === "");
+    case "settings_registry":
+      return v === null || isEmptyArray(v);
+    case "addon":
+      return isEmptyArray(v);
+    case "disabled":
+      return v === false;
+    case "as":
+    case "description":
+    case "sql_name":
+      return v === "";
+    // The object-level members below are the same generational gap one level up
+    // — an object saved by an older engine generation omits them, while both the
+    // current engine and the SDK always write them at a fixed default. They were
+    // 1,716 of the 1,744 round-trip mismatches in a 187-workspace sweep, and
+    // each default is evidenced twice: the engine reads the absent key as this
+    // value, and real workspaces store present-at-default and absent side by
+    // side on one instance.
+    case "docs":
+    case "datasource":
+    case "view_alias":
+      return v === "";
+    // An MCP tool entry's optional metadata, and the agent provider-config
+    // members whose unset spelling is the empty string. Both store the empty
+    // form and the absent form side by side across the corpus.
+    case "tool_meta":
+    case "resource_uri":
+    case "alias":
+    case "baseURL":
+    case "safetySettings":
+    case "dynamicRetrievalConfig":
+    case "apiKey":
+      return v === "";
+    // `headers` is an empty STRING on an unset agent config and a string[] on an
+    // api_request statement — dropping only the string spelling leaves an empty
+    // header list comparing as the authored value it is.
+    case "headers":
+      return v === "";
+    // MCP metadata a newer engine fills on every tool and toolset, at the value
+    // an older one reads the absent key as: a tool's `icons`/`title`/
+    // `annotations`/`output_schema`, a toolset's `prompt`/`resource` lists. The
+    // SDK writes none of them, so a pulled tree re-exported without them and
+    // every MCP server and tool on a current instance failed its round trip.
+    // Array-only for `prompt` — an agent's own `prompt` is a string.
+    case "icons":
+    case "output_schema":
+    case "prompt":
+    case "resource":
+      return isEmptyArray(v);
+    case "title":
+      return v === "";
+    case "annotations":
+      return typeof v === "object" && v !== null && !Array.isArray(v) && Object.values(v).every((m) => m === null || isEmptyArray(m));
+    // A tool entry's kind. Absent means `tool`; a `resource` or `prompt` entry
+    // says so and still compares. Value-distinct from the other `type`
+    // discriminators (an expression node, a column type), none of which is `tool`.
+    case "type":
+      return v === "tool";
+    // Four stored spellings of "no thinking budget" across 16 real configs: the
+    // empty string, absent, and the block with its budget as either `0` or `""`.
+    case "thinkingConfig":
+      return v === "" || typeof v === "object" && v !== null && !Array.isArray(v) && v["includeThoughts"] === false && (v["thinkingBudget"] === 0 || v["thinkingBudget"] === "");
+    // A query with no declared response type. Type- and value-distinct from the
+    // raw-SQL `response_type`, whose values are `list`/`single`/`count` and
+    // whose own default (`list`) is spelled differently.
+    case "response_type":
+      return v === "standard";
+    // Empty list members. `tag` is the load-bearing one: it is also the
+    // discriminator every tagged value carries, so the rule is restricted to the
+    // ARRAY spelling — a `tag: "const:str"` is a string and never matches.
+    case "tag":
+    case "views":
+    case "result":
+      return isEmptyArray(v);
+    // Two API-group gates with opposite defaults, each the value the engine
+    // falls back to when the key is absent: a group serves unless disabled,
+    // documentation is off unless turned on.
+    case "api_group_enabled":
+      return v === true;
+    case "swagger":
+      return v === false;
+    case "documentation":
+      return deepEqual(normalize(v), normalize(DEFAULT_DOCUMENTATION));
+    // A CORS block is applied ONLY when its `mode` is `"custom"` — the engine
+    // reads an absent mode as `""`, which is not custom — so a block that does
+    // not say `custom` configures nothing.
+    //
+    // Two spellings therefore mean the same default. The current one says
+    // `mode: "default"`; an older one predates `mode` entirely and carries
+    // `enabled: false`, a key that request path never reads.
+    case "cors": {
+      if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
+      const block = { ...v };
+      if (block["enabled"] === false) delete block["enabled"];
+      block["mode"] ??= "default";
+      return deepEqual(normalize(block), normalize(DEFAULT_CORS));
+    }
+    // Both stored spellings of "no middleware": the engine hands an empty
+    // associative map back as a JSON array, the same artifact already absorbed
+    // for `mocks`, `customize` and an empty `context`. A phase explicitly
+    // customized to run nothing still compares — that is not inheriting.
+    case "middleware":
+      return isEmptyArray(v) || deepEqual(normalize(v), normalize(DEFAULT_MIDDLEWARE));
+    // Two unrelated `offset`s, both at a default. An addon's is the response path
+    // its rows are spliced into, `""` when spliced at the root. A list context's
+    // paging offset is declared to default to 0. Neither carries information at
+    // its default; any other value is preserved.
+    case "offset":
+      return v === "" || isNumber(v, 0);
+    // Return-block paging members, each at its declared default. Type-distinct
+    // from their same-named neighbours in a permissions block (`page: true`,
+    // `per_page: false`), which are booleans and so untouched.
+    case "page":
+      return isNumber(v, 1);
+    case "per_page":
+      return isNumber(v, 25);
+    case "metadata":
+      return v === true;
+    case "totals":
+      return v === false;
+    case "distinct":
+      return v === "auto";
+    // `s.setheader`'s duplicate-handling mode. The engine declares it
+    // `duplicates?=replace` and reads it as `($data["duplicates"] ?? "replace")`,
+    // so an absent key IS "replace"; 3 real statements omit it against 8 that
+    // store it present-at-default. The key appears on no other statement.
+    case "duplicates":
+      return v === "replace";
+    // A return sub-block whose every member sat at a default. These are checked
+    // against their NORMALIZED form because the member rules above are what empty
+    // them — without this the block survives as `{}` and the whole return envelope
+    // never collapses, which is the only reason it matters.
+    //
+    // `list` also names a foreach's iterated value; a tagged value never
+    // normalizes to empty, so that one is untouched.
+    //
+    // `enabled:false` is the one member no rule above empties, deliberately — it
+    // is meaningful on a history block, so it cannot be dropped by name. It IS
+    // droppable here, where the key says the block is paging: 7 real db.query
+    // statements omit `paging` outright against 149 that store it present at
+    // `enabled:false`, and the two spellings mean the same thing.
+    //
+    // Evidenced twice before being trusted. Every engine consumer reads the flag
+    // as `["paging"]["enabled"] ?? false`, so an absent block IS a disabled one,
+    // and the serializer returns before writing anything when it is off — a
+    // disabled block emits no source at all. The siblings are provably inert
+    // meanwhile: every read of `page`/`per_page`/`offset`/`metadata` sits behind
+    // that same gate.
+    //
+    // Still narrow: this fires only once every OTHER member has normalized away.
+    // A disabled block that customizes something (`{enabled:false, per_page:50}`)
+    // keeps both and compares as itself.
+    case "paging": {
+      const normalized = normalize(v);
+      return isEmptyObject(normalized) || deepEqual(normalized, { enabled: false });
+    }
+    // The same four blocks, plus the residue the member rules above cannot reach.
+    //
+    // The engine writes ALL FOUR result-shape blocks on every query; the SDK writes
+    // only the one its `returnType` selects. Emptiness alone does not collapse a
+    // default sibling, because two of its members have no rule that empties them —
+    // the paging `enabled:false` gate and an aggregate's empty `group`/`index`
+    // lists. So one customized `per_page` left every default sibling mismatching,
+    // and a paged query could never verify.
+    //
+    // Deep-equality against each block's own frozen default is what reaches those
+    // members WITHOUT a global rule on their generic names — `enabled:false` is
+    // meaningful on a history block, and an empty `group` is a condition default
+    // elsewhere. A block with anything authored inside it still compares.
+    case "list":
+      if (hasNoListBounds(v)) return true;
+    // falls through to the result-shape block of the same name
+    case "single":
+    case "stream":
+    case "aggregate":
+      return isEmptyObject(normalize(v)) || deepEqual(normalize(v), normalize(Object.hasOwn(DEFAULT_RETURN_BLOCKS, key) ? DEFAULT_RETURN_BLOCKS[key] : void 0));
+    // Field-envelope members the engine fills with a fixed default on save. A
+    // field saved by an older engine generation omits them entirely, while both
+    // the current engine and the SDK always write them — the same lean-vs-full
+    // generational gap as the members above, and by far the most common one in
+    // the wild: nearly every field in a workspace that has not been re-saved
+    // lacks `is_settings_registry`. Without these the decoder cannot prove ANY
+    // authored form reproduces such a field, so every one of them degrades to a
+    // descriptor literal or `rawField()` — including foreign keys, which lose
+    // their `f.tableRef(table)` form and the table import with it.
+    case "is_settings_registry":
+    case "sensitive":
+      return v === false;
+    case "mode":
+    case "format":
+      return v === "";
+    // A field's `vector.size` is only authored on a `vector` column; on every
+    // other type the engine writes this exact default. Dropping it at the
+    // default is symmetric, so a real `vector` column of size 3 still compares
+    // equal, and any other size is preserved and still compared.
+    case "vector":
+      return deepEqual(v, { size: 3 });
+    // Agent `agent_settings.model`: the engine persists a top-level empty
+    // `model:""` (the real model lives under `configs.<provider>.model`); the SDK
+    // omits the empty top-level field. Drop it on both sides when empty.
+    case "model":
+      return v === "";
+    // Statement input-entry members: the lean parser form omits these; the full
+    // persisted form carries them. Drop at their defaults (a meaningful
+    // `ignore:true` on a system column, or non-empty `children`, is kept).
+    case "ignore":
+    case "expand":
+      return v === false;
+    // Expression right-operand flag: the engine schema marks it `?=false` and
+    // drops it at the default on save, so the persisted form (and the SDK) omit
+    // it; older parser-generation fixtures still carry `ignore_empty:false`.
+    case "ignore_empty":
+      return v === false;
+    case "children":
+      return isEmptyArray(v);
+    // The two stored generations of an external database connection sit in
+    // SEPARATE fields, and a statement that uses one leaves the other at its
+    // unset value rather than dropping it: the engine's optional-schema pass
+    // gives the bare `connection_string` the text default `""` and leaves the
+    // nested `connection_string_flex` as nothing at all. Neither unset spelling
+    // says anything about the connection, so both drop on both sides — which is
+    // what lets a statement stored in either generation prove against the one
+    // field it actually uses. A populated field of either
+    // generation is preserved and still compared.
+    case "connection_string":
+      return v === "";
+    case "connection_string_flex":
+      return v === null || v === "{}" || isEmptyObject(v);
+    // A value's filter chain: an empty `filters:[]` is identical to no filter
+    // chain. The engine always serializes it on a nested value (e.g. a
+    // `context`-nested `filename`); the SDK omits it there. Drop the empty form
+    // on both sides so the representational gap doesn't fail an otherwise-equal
+    // value. A non-empty chain is preserved and still compared.
+    case "filters":
+      return isEmptyArray(v);
+    // Statement/object input-entry array: the lean parser form omits an empty
+    // `input`; the full persisted form carries `input:[]`; and the engine writes
+    // `input:null` for a statement that takes no inputs at all. All three are the
+    // same "no inputs" state — the SDK emits the `[]` spelling, so without the
+    // null arm every input-less statement in a pulled workspace fails to prove
+    // and degrades to `raw()`. Drop all three on both sides; a populated `input`
+    // is preserved. Same two-spellings-of-empty shape as `settings_registry`.
+    case "input":
+      return v === null || isEmptyArray(v);
+    case "shared_workspace":
+      return v !== null && typeof v === "object" && v.is_shared === false;
+    // A trigger's `obj_id`: a table trigger's is the referenced table's GUID
+    // *string* (authored, derived by the SDK, kept and compared). A workspace /
+    // realtime / error trigger has no table, so the engine stores a *numeric*
+    // branch/workspace reference (`1`) while the SDK emits a `0` placeholder —
+    // deploy-target state, same rationale as the stripped `branch`. Drop the
+    // numeric form on both sides; the guid-string form is preserved.
+    case "obj_id":
+      return typeof v === "number";
+    // Toolset/query/function inherit-tier `history` block: when `inherit` is true
+    // nothing is customized (the limit/enabled members are the inherited
+    // defaults, not authored). The SDK omits it on a toolset; drop the inheriting
+    // form on both sides. A customized (`inherit:false`) history is preserved.
+    case "history":
+      return Array.isArray(v) || v !== null && typeof v === "object" && v.inherit === true;
+    // An MCP-server toolset persists `agent_settings:null` (only agents carry a
+    // real settings block); the SDK omits it. Drop the null form.
+    // `null`, and the engine's BLANK SCAFFOLD — an MCP toolset that configures no
+    // model still gets the whole block written, inert (see
+    // {@link isBlankAgentSettings}). The SDK spells both by omitting it.
+    case "agent_settings":
+      return v === null || isBlankAgentSettings(v);
+    // An agent's default `agent_settings.telemetry` (all providers off, empty
+    // keys): the SDK omits it. Drop when telemetry is disabled.
+    case "telemetry":
+      return v !== null && typeof v === "object" && v.enabled === false;
+    // A tool/query/function `test:[]` scaffold array — the SDK omits it on a tool;
+    // an empty test list is identical to none. Drop the empty form both sides.
+    case "test":
+      return isEmptyArray(v);
+    // A query's saved request/response sample at its empty spelling. The SDK
+    // writes `{}` whenever no sample is authored and the engine may store the
+    // key not at all, or with both halves null. All three mean "no sample".
+    // A POPULATED one is preserved and compared (and copied through opaquely —
+    // see the `example` branch in the recursion below).
+    case "example":
+      return v === null || isEmptyArray(v) || typeof v === "object" && Object.values(v).every((half) => half === null);
+    // A default `auth:false` (public / no auth table): the engine persists it on a
+    // tool where the SDK omits it. Drop the `false` form; `auth:true` and an
+    // auth-table id are preserved and still compared.
+    // `false` and `""` are both "no auth table"; a guid names one and compares —
+    // the round trip translates the compiled guid into the engine's re-minted
+    // one first (`./guid-remap.ts`), so naming the WRONG table still diffs.
+    case "auth":
+      return v === false || v === "";
+    // Default db-query `context` members the engine fills when an addon (or any
+    // db context) customizes nothing; the SDK omits them. Empty-collection /
+    // false members drop directly; the three structured members below match
+    // their exact engine default (a customized context is preserved).
+    case "bind":
+    case "eval":
+    case "sort":
+      return isEmptyArray(v);
+    case "future":
+      return v === false;
+    // Compare NORMALIZED against NORMALIZED default: normalize strips empty
+    // `sort`/`eval`/`index` members from the nested subtree, so the frozen
+    // default must pass through the same reduction to compare equal.
+    case "lock":
+      return deepEqual(normalize(v), normalize({ tag: "const:bool", value: "" }));
+    // A condition container that holds nothing, in either stored spelling: the
+    // `{expression: []}` the SDK writes and the empty associative-map form `[]`
+    // the engine hands back — the same artifact already absorbed for `mocks`,
+    // `customize` and an empty `context`. Both mean "no condition configured".
+    // A populated container is untouched and still compares node for node.
+    case "expr":
+      return isEmptyArray(v) || v !== null && typeof v === "object" && isEmptyArray(v.expression);
+    case "search":
+      return deepEqual(normalize(v), normalize({ expression: [] }));
+    // Two spellings of an all-defaults return block. The engine's declared shape
+    // defaults the result type to a list and leaves every sub-block optional, so
+    // a query that customizes nothing persists either the whole subtree (when the
+    // engine filled it on save) or nothing but the type — and the SDK omits it
+    // entirely. Accept both, and preserve any customized paging/sort/distinct.
+    case "return":
+      return deepEqual(normalize(v), normalize(DEFAULT_CONTEXT_RETURN)) || deepEqual(normalize(v), MINIMAL_CONTEXT_RETURN);
+    // A condition entry's nested group. The engine declares it optional with no
+    // default, so an entry that nests nothing omits the key while the SDK
+    // materializes an empty search. Same state; drop the empty form on both
+    // sides. A group that actually nests expressions is preserved and compared.
+    case "group":
+      return deepEqual(normalize(v), EMPTY_SEARCH);
+    // A condition entry's or-flag, declared to default false: the persisted form
+    // omits it at the default where the SDK writes it.
+    case "or":
+      return v === false;
+    // Generated-asset visibility, declared to default public wherever it appears.
+    case "access":
+      return v === "public";
+    // A precondition's error class, declared to default to the standard error.
+    case "error_type":
+      return v === "standard";
+    case "external":
+      return deepEqual(normalize(v), normalize(DEFAULT_CONTEXT_EXTERNAL));
+    case "simpleExternal":
+      return bindsNoPagingFacet(v);
+    default:
+      return false;
+  }
+}
+function isEmptyOutput(v) {
+  if (v === null) return true;
+  if (typeof v !== "object" || Array.isArray(v)) return false;
+  const o = v;
+  const noItems = o.items === void 0 || Array.isArray(o.items) && o.items.length === 0;
+  const noFilters = o.filters === void 0 || Array.isArray(o.filters) && o.filters.length === 0;
+  return noItems && noFilters && o.customize !== true;
+}
+function historyWithDefaultLimit(v) {
+  if (v === null || typeof v !== "object" || Array.isArray(v)) return void 0;
+  const block = v;
+  if (block.inherit !== false) return void 0;
+  const enabledKey = Object.keys(block).find((key) => key === "enabled" || key.endsWith("_enabled"));
+  if (enabledKey === void 0) return void 0;
+  const limitKey = enabledKey === "enabled" ? "limit" : `${enabledKey.slice(0, -"_enabled".length)}_limit`;
+  if (Object.hasOwn(block, limitKey)) return void 0;
+  return { ...block, [limitKey]: ENGINE_HISTORY_LIMIT };
+}
+function withoutDefaultMcpHistoryPairs(v) {
+  if (v === null || typeof v !== "object" || Array.isArray(v)) return void 0;
+  const block = v;
+  if (Object.hasOwn(block, "inherit")) return void 0;
+  const drop = ["prompt", "resource"].filter(
+    (type) => block[`${type}_enabled`] === true && block[`${type}_limit`] === ENGINE_HISTORY_LIMIT
+  );
+  if (drop.length === 0) return void 0;
+  const out = { ...block };
+  for (const type of drop) {
+    delete out[`${type}_enabled`];
+    delete out[`${type}_limit`];
+  }
+  return out;
+}
+var ENGINE_HISTORY_LIMIT = 100;
+var LOCAL_DBO_REF = /^dbo=\d+$/;
+function clearLocalDboRefs(value, cleared) {
+  if (Array.isArray(value)) {
+    return value.map((item) => clearLocalDboRefs(item, cleared));
+  }
+  if (value === null || typeof value !== "object") return value;
+  const next = Object.fromEntries(
+    Object.entries(value).map(([key, member]) => [
+      key,
+      clearLocalDboRefs(member, cleared)
+    ])
+  );
+  if (next.name === "@" && Array.isArray(next.arg)) {
+    const target = next.arg[0];
+    if (typeof target === "string" && LOCAL_DBO_REF.test(target)) {
+      cleared?.add(target);
+      return { ...next, arg: ["dbo=", ...next.arg.slice(1)] };
+    }
+  }
+  return next;
+}
+var EMPTY_CONTEXT_FILL = /* @__PURE__ */ new Map([
+  // Its name rides the envelope `as`, so the context is the value alone.
+  ["mvp:set_var", { tag: "const", named: false }],
+  // Standalone classes, each declaring its own default tag.
+  ["mvp:sleep", { tag: "const:int", named: false }],
+  ["mvp:die", { tag: "input", named: false }],
+  ["mvp:setheader", { tag: "input", named: false }],
+  // `array_pop`/`array_shift` carry NO `tag`, because they take no operand:
+  // popping or shifting reads nothing, their specs route no spread field, and
+  // the encoder writes `name` alone. The fill must be exactly what the encoder
+  // writes — filling a value they cannot author invents members the comparison
+  // then demands forever, which is what shipped once when they were given the
+  // full `UpdateVarBase` treatment below.
+  //
+  // A name-only fill is a different claim from that one, and it is evidenced
+  // twice on the engine, both times on the SCALAR `name`:
+  //   • the statement's own XanoScript schema declares `name?='': context.name`
+  //     — the default for an absent name IS the empty string; and
+  //   • the shared base class declares `name` as a plain `text` member and runs
+  //     it through the same optional-schema pass that licenses every entry here.
+  //
+  // That second point is exactly where the loops failed (see
+  // {@link LOOP_EMPTY_ITERAND}): that pass materializes a SCALAR member but
+  // defaults a NESTED object to the literal string `"{}"`. `name` is a scalar,
+  // `list`/`cnt` are not, and the shape is what decides. The engine's own
+  // statement-transform corpus stores `{"context":{}}` for `mvp:array_shift`.
+  ["mvp:array_pop", { named: true }],
+  ["mvp:array_shift", { named: true }],
+  // The `UpdateVarBase` family: `{name, value, tag, filters}`, `tag` overridden
+  // per subclass by `getDefaultTag()`. `test/codegen/spec-inverse` asserts every
+  // entry's members against the spec catalog so the two cannot drift.
+  ["mvp:update_var", { tag: "const", named: true }],
+  ["mvp:array_merge", { tag: "const:array", named: true }],
+  ["mvp:array_push", { tag: "const", named: true }],
+  ["mvp:array_unshift", { tag: "const", named: true }],
+  ["mvp:bitwise_and", { tag: "const:int", named: true }],
+  ["mvp:bitwise_or", { tag: "const:int", named: true }],
+  ["mvp:bitwise_xor", { tag: "const:int", named: true }],
+  ["mvp:math_add", { tag: "const:decimal", named: true }],
+  ["mvp:math_sub", { tag: "const:decimal", named: true }],
+  ["mvp:math_mul", { tag: "const:decimal", named: true }],
+  ["mvp:math_div", { tag: "const:decimal", named: true }],
+  ["mvp:math_mod", { tag: "const:int", named: true }],
+  ["mvp:text_append", { tag: "const", named: true }],
+  ["mvp:text_prepend", { tag: "const", named: true }],
+  ["mvp:text_trim", { tag: "const", named: true }],
+  ["mvp:text_ltrim", { tag: "const", named: true }],
+  ["mvp:text_rtrim", { tag: "const", named: true }],
+  ["mvp:text_starts_with", { tag: "const", named: true }],
+  ["mvp:text_istarts_with", { tag: "const", named: true }],
+  ["mvp:text_ends_with", { tag: "const", named: true }],
+  ["mvp:text_iends_with", { tag: "const", named: true }],
+  ["mvp:text_contains", { tag: "const", named: true }],
+  ["mvp:text_icontains", { tag: "const", named: true }],
+  // The file-resource family and `debug_log`: the context IS the value, like
+  // `set_var`, but the file resources declare a sibling SCALAR (`access`) that
+  // the same optional pass materializes alongside it — so the fill carries it.
+  // The nested `filename` is NOT filled: a nested object defaults to the literal
+  // string `"{}"` and materializes nothing.
+  //
+  // `extra` is exactly where the `array_pop` note above applies. `create_attachment`
+  // ALSO declares `include_meta?=false`, and filling it failed the round trip —
+  // the SDK's spec models no such field, so the encoder never writes it and the
+  // fill demanded a member the recovered record could not produce. The fill has
+  // to equal what the ENCODER writes, not everything the engine would supply.
+  // (A workspace that stores a real `include_meta` still degrades to `raw()`,
+  // which is the correct handling for an unmodelled member.)
+  //
+  // Read off each statement class's own schema, and the default tag is NOT
+  // uniform across them — the file resources declare `tag?=input` while
+  // `debug_log` declares `tag?=const`, the same split `die`/`setheader` have.
+  ["mvp:create_image", { tag: "input", named: false, extra: { access: "public" } }],
+  ["mvp:create_audio", { tag: "input", named: false, extra: { access: "public" } }],
+  ["mvp:create_attachment", { tag: "input", named: false, extra: { access: "public" } }],
+  ["mvp:debug_log", { tag: "const", named: false }]
+]);
+var LOOP_EMPTY_ITERAND = /* @__PURE__ */ new Map([
+  ["mvp:foreach", { member: "list", value: "[]", tag: "const:array" }],
+  ["mvp:for", { member: "cnt", value: "0", tag: "const:int" }]
+]);
+function blankValue(tag) {
+  return { value: "", tag, filters: [] };
+}
+function liveSwitchContext(stored) {
+  if (stored === null || typeof stored !== "object") return void 0;
+  const { name, context } = stored;
+  if (name !== "mvp:switch") return void 0;
+  if (context === null || typeof context !== "object" || Array.isArray(context)) return void 0;
+  const block = context;
+  const subject = block.value;
+  const nested = subject !== null && typeof subject === "object" && !Array.isArray(subject) && typeof subject.tag === "string";
+  if (!nested) return void 0;
+  const strays = ["tag", "filters"].filter((key) => key in block);
+  if (strays.length === 0) return void 0;
+  return Object.fromEntries(Object.entries(block).filter(([k]) => !strays.includes(k)));
+}
+function liveArrayMapContext(stored) {
+  if (stored === null || typeof stored !== "object") return void 0;
+  const { name, context } = stored;
+  if (name !== "mvp:array_map") return void 0;
+  if (context === null || typeof context !== "object" || Array.isArray(context)) return void 0;
+  const block = context;
+  const dead = (block.output_type ?? "value") === "object" ? "transform_value" : "transform_object";
+  if (!(dead in block)) return void 0;
+  return Object.fromEntries(Object.entries(block).filter(([k]) => k !== dead));
+}
+function filledContext(stored) {
+  if (stored === null || typeof stored !== "object") return null;
+  const { name, context } = stored;
+  if (typeof name !== "string") return null;
+  const whole = EMPTY_CONTEXT_FILL.get(name);
+  if (whole) {
+    const empty = context === null || Array.isArray(context) && context.length === 0 || typeof context === "object" && Object.keys(context).length === 0;
+    if (!empty) return null;
+    if (whole.tag === void 0) return { name: "" };
+    return {
+      ...whole.named ? { name: "" } : {},
+      ...blankValue(whole.tag),
+      ...whole.extra ?? {}
+    };
+  }
+  const loop = LOOP_EMPTY_ITERAND.get(name);
+  if (loop) {
+    if (context === null || typeof context !== "object" || Array.isArray(context)) return null;
+    const block = context;
+    if (block[loop.member] !== void 0) return null;
+    return { ...block, [loop.member]: { value: loop.value, tag: loop.tag, filters: [] } };
+  }
+  return null;
+}
+var INERT_TRIGGER_META_GROUPS = {
+  database: {
+    datasource: [],
+    search: { expression: [] },
+    action: { delete: false, insert: false, truncate: false, update: false }
+  },
+  toolset: { action: { connection: false } },
+  workspace: { action: { branch_live: false, branch_merge: false, branch_new: false } },
+  workspace_realtime_channel: { action: { message: false, join: false } },
+  realtime_server: { action: { connect: false, disconnect: false } },
+  channel: { action: { join: false, leave: false, deliver: false } }
+};
+function withoutInertTriggerMetaGroups(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entries = Object.entries(value);
+  if (entries.length === 0) return void 0;
+  if (!entries.every(([k]) => Object.hasOwn(INERT_TRIGGER_META_GROUPS, k))) return void 0;
+  const kept = entries.filter(([k, v]) => !deepEqual(v, Object.hasOwn(INERT_TRIGGER_META_GROUPS, k) ? INERT_TRIGGER_META_GROUPS[k] : void 0));
+  return kept.length === entries.length ? void 0 : Object.fromEntries(kept);
+}
+var canonicalToolsetPrimitives;
+function toolsetPrimitive(name) {
+  canonicalToolsetPrimitives ??= new Map(
+    impliedInputs("toolset", "mcp").filter((i) => i.name === "prompts" || i.name === "resources" || i.name === "auth").map((i) => [i.name, normalize(i)])
+  );
+  return typeof name === "string" ? canonicalToolsetPrimitives.get(name) : void 0;
+}
+function withoutToolsetPrimitiveInputs(value) {
+  if (!Array.isArray(value)) return value;
+  return value.filter((i) => {
+    const canonical = toolsetPrimitive(i?.name);
+    return canonical === void 0 || !deepEqual(normalize(i), canonical);
+  });
+}
+function normalize(value) {
+  if (Array.isArray(value)) {
+    return value.map((v) => normalize(v));
+  }
+  if (value !== null && typeof value === "object") {
+    const out = /* @__PURE__ */ Object.create(null);
+    const blankObj = value.tag === "const:obj" && "value" in value && (value.value === "" || value.value === null);
+    const isTable = "schema" in value && !("context" in value);
+    const sortsInput = NAME_KEYED_INPUT.has(value.name);
+    const dropsInput = UNREADABLE_INPUT.has(value.name);
+    const retired = retiredInputs(value.name);
+    const contextFill = filledContext(value);
+    const arrayMapContext = liveArrayMapContext(value);
+    const switchContext = liveSwitchContext(value);
+    const isGroupNode = value.type === "group";
+    const isMiddlewareBlock = "pre_customize" in value || "post_customize" in value;
+    const isDescriptor = "type" in value && "required" in value;
+    const requiredEntry = value.required === true;
+    for (const [k, stored] of Object.entries(value)) {
+      const v = k === "expr" ? withoutLeadingJoin(stored) : k === "result" ? liveResultItems(stored) ?? stored : k === "return" ? (() => {
+        const live = liveReturnSection(stored) ?? stored;
+        return returnWithoutIterator(live) ?? live;
+      })() : k === "runtime" ? liveAsyncRuntime(stored) ?? stored : stored;
+      if (k === "token" && isSavedTest(value)) continue;
+      if (k === "id" && isSavedTest(value)) {
+        out[k] = v;
+        continue;
+      }
+      if (STRIP_KEYS.has(k)) continue;
+      if (isTable && k === "as") continue;
+      if (isGroupNode && k === "statement") continue;
+      if (isMiddlewareBlock && (k === "pre" || k === "post") && value[`${k}_customize`] !== true) {
+        continue;
+      }
+      if (k === "arg" && isEmptyArray(v) && isRawSqlContext(value)) continue;
+      if (isDefaultEnvelopeMember(k, v)) continue;
+      if (isDescriptor && k === "default") {
+        if (requiredEntry || v === null || v === "") {
+          out[k] = null;
+          continue;
+        }
+      }
+      if (k === "output" && isEmptyOutput(v)) continue;
+      if (k === "history") {
+        const trimmed = withoutDefaultMcpHistoryPairs(v);
+        if (trimmed !== void 0) {
+          out[k] = normalize(trimmed);
+          continue;
+        }
+        const filled = historyWithDefaultLimit(v);
+        if (filled !== void 0) {
+          out[k] = normalize(filled);
+          continue;
+        }
+      }
+      if (k === "meta") {
+        const reduced = withoutInertTriggerMetaGroups(v);
+        if (reduced !== void 0) {
+          out[k] = normalize(reduced);
+          continue;
+        }
+      }
+      if (k === "input" && value.obj_type === "toolset" && "meta" in value) {
+        out[k] = normalize(withoutToolsetPrimitiveInputs(v));
+        continue;
+      }
+      if (k === "customize" && isEmptyCustomize(v)) {
+        out[k] = {};
+        continue;
+      }
+      if (k === "customize") {
+        out[k] = normalize(clearLocalDboRefs(v));
+        continue;
+      }
+      if (k === "example") {
+        out[k] = Object.fromEntries(
+          Object.entries(v).filter(([, half]) => half !== null)
+        );
+        continue;
+      }
+      if (dropsInput && k === "input") continue;
+      if (k === "input" && Array.isArray(v) && retired.length > 0) {
+        out[k] = v.filter((entry) => !retired.includes(String(entry?.name ?? ""))).map((entry) => normalize(entry));
+        continue;
+      }
+      if (sortsInput && k === "input" && Array.isArray(v)) {
+        out[k] = [...v].sort(
+          (a, b) => String(a?.name ?? "").localeCompare(
+            String(b?.name ?? "")
+          )
+        ).map((entry) => normalize(entry));
+        continue;
+      }
+      if (k === "auth") {
+        const unbound = unboundAuthTable(v);
+        if (unbound) {
+          out[k] = normalize(unbound);
+          continue;
+        }
+      }
+      if (k === "context" && arrayMapContext) {
+        out[k] = normalize(arrayMapContext);
+        continue;
+      }
+      if (k === "context" && switchContext) {
+        out[k] = normalize(switchContext);
+        continue;
+      }
+      if (k === "context" && contextFill) {
+        out[k] = normalize(contextFill);
+        continue;
+      }
+      if (k === "context" && (isEmptyArray(v) || v === null)) {
+        out[k] = {};
+        continue;
+      }
+      if (k === "arg" && Array.isArray(v)) {
+        out[k] = v.map((e) => typeof e === "number" ? String(e) : normalize(e));
+        continue;
+      }
+      if (PAGING_INT_KEYS.has(k) && typeof v === "string" && /^-?\d+$/.test(v)) {
+        out[k] = Number(v);
+        continue;
+      }
+      if (k === "value" && blankObj) {
+        out[k] = "";
+        continue;
+      }
+      out[k] = (k === "value" || k === "operand" || k === "temperature") && (typeof v === "number" || typeof v === "boolean") ? String(v) : normalize(v);
+    }
+    return out;
+  }
+  if (typeof value === "string") {
+    const ts = canonicalizeTimestamp(value);
+    if (ts !== void 0) return ts;
+  }
+  return value;
+}
+
+export {
+  isEmptyCustomize,
+  deepEqual,
+  hasNoListBounds,
+  hasUnreadableInput,
+  retiredInputs,
+  retiredInputSuccessor,
+  isBlankGroupStatement,
+  isDeadResultItem,
+  isBlankAgentSettings,
+  configuredDeadReturnBlocks,
+  isDefaultEnvelopeMember,
+  isEmptyOutput,
+  ENGINE_HISTORY_LIMIT,
+  clearLocalDboRefs,
+  liveArrayMapContext,
+  filledContext,
+  normalize
+};
+//# sourceMappingURL=chunk-L5JYN3NM.js.map