@xanots/sdk 0.0.1

package/dist/chunk-EMCAWMHC.js

@@ -0,0 +1,3982 @@
+import {
+  assertPathParamInputs,
+  fillPathParams,
+  parsePathParams
+} from "./chunk-WHOJWOSV.js";
+import {
+  COLUMN_CONTEXT,
+  INPUT_CONTEXT,
+  RAW_ENVELOPE,
+  annotate,
+  encodeField,
+  encodeStatement,
+  rawResponseItems,
+  registerStatement
+} from "./chunk-LH6Z6KFV.js";
+import {
+  deriveGuid,
+  getLockedCanonical,
+  lockKey,
+  resolveRef,
+  sha1Bytes
+} from "./chunk-4HT3BNZ7.js";
+
+// src/types/xdo.ts
+var TAGS = [
+  "const",
+  "const:int",
+  "const:decimal",
+  "const:bool",
+  "const:array",
+  "const:obj",
+  "const:null",
+  // The engine's native epoch-milliseconds constant (`value:"now"`) — what
+  // `c.now()` emits. Distinct from `const` + a `to_epoch_ms` filter: both
+  // evaluate to the same number (live-verified), but this one needs no filter.
+  "const:epochms",
+  "const:expr",
+  "const:expr2",
+  "var",
+  "input",
+  "auth",
+  "env",
+  "setting",
+  "col",
+  "output",
+  "response",
+  "trycatch",
+  "toolset"
+];
+
+// src/values/expression-arg.ts
+var EXPRESSION_ARG_FILTERS = {
+  transform: 0
+};
+var UNBOUND_HERE = ["$this", "$parent", "$index", "$result"];
+function withoutStringLiterals(source) {
+  return source.replace(/(['"])(?:\\.|(?!\1)[^\\])*\1?/g, (m) => {
+    const closed = m.length > 1 && m.at(-1) === m[0];
+    return m[0] + " ".repeat(m.length - (closed ? 2 : 1)) + (closed ? m[0] : "");
+  });
+}
+function assertExpressionFilterArgs(name, args) {
+  const slot = EXPRESSION_ARG_FILTERS[name];
+  if (slot === void 0) return;
+  const arg = args[slot];
+  if (!isInspectableSource(arg) || arg.value.trim() === "") return;
+  assertExpressionArg(arg.value, `fl.${name}`);
+}
+function isInspectableSource(arg) {
+  return typeof arg === "object" && arg !== null && arg.tag === "const" && typeof arg.value === "string" && (arg.filters?.length ?? 0) === 0;
+}
+function assertExpressionArg(source, fn2) {
+  const scannable = withoutStringLiterals(source);
+  const unbound = UNBOUND_HERE.find((b) => new RegExp(`\\${b}\\b`).test(scannable));
+  if (unbound !== void 0) {
+    const bare = unbound.slice(1);
+    throw new Error(
+      `${fn2}: \`${unbound}\` is not bound in an expression \u2014 it resolves to null, and the filter still returns HTTP 200 with a wrong answer. ${fn2} takes Xano Expression Engine source, and the piped value arrives in the POSITIONAL slot: write \`$0\` (or \`$$\`) where you wrote \`${unbound}\`. ${unbound === "$this" ? "The engine's own filter description says `$this`; it is wrong. " : ""}\`$var\`, \`$input\`, \`$env\` and \`$auth\` DO resolve. (If a stack variable is genuinely named \`${bare}\`, spell it \`$var.${bare}\`.) (issue #245)`
+    );
+  }
+  const js = /(?<![$\w.])return\b/.test(scannable) && "a `return` statement" || /=>/.test(scannable) && "an arrow function" || /;/.test(scannable) && "a statement separator (`;`)";
+  if (js) {
+    throw new Error(
+      `${fn2}: the expression contains ${js}, so it is being written as a JavaScript body. ${fn2} is NOT a lambda \u2014 it takes Xano Expression Engine source, which is a single expression with no \`return\`. The engine parses it either way: \`return $0 * 2\` throws "Not numeric.", and \`const x = $0; return x\` returns the text "const x" with HTTP 200. Write the expression alone \u2014 \`$0 * 2\` \u2014 using \`$0\` (or \`$$\`) for the piped value. For real JavaScript use \`fl.lambda\`, whose body DOES bind \`$this\`. (issue #245)`
+    );
+  }
+}
+
+// src/values/enum-arg.ts
+var ENUM_ARG_FILTERS = {
+  fsort: {
+    slot: 1,
+    arg: "type",
+    members: ["text", "itext", "natural", "inatural", "number"],
+    why: 'The engine accepts any spelling here and validates none of them: an unrecognized comparator falls through to "itext" and sorts numbers as TEXT, so the array comes back in the wrong order with no error. Only "number" compares numerically.'
+  }
+};
+function assertEnumFilterArgs(name, args) {
+  const spec = ENUM_ARG_FILTERS[name];
+  if (spec === void 0) return;
+  const arg = args[spec.slot];
+  if (!isInspectableConst(arg) || arg.value === "") return;
+  if (spec.members.includes(arg.value)) return;
+  throw new Error(
+    `fl.${name}: \`${spec.arg}\` is ${JSON.stringify(arg.value)}, which is not one of ${spec.members.map((m) => JSON.stringify(m)).join(", ")}. ${spec.why} (issue #198)`
+  );
+}
+function isInspectableConst(arg) {
+  return typeof arg === "object" && arg !== null && arg.tag === "const" && typeof arg.value === "string" && (arg.filters?.length ?? 0) === 0;
+}
+
+// src/workspace/diagnostics.ts
+var consoleSink = (diagnostic) => {
+  console.warn(formatDiagnostic(diagnostic));
+};
+var sink = consoleSink;
+function formatDiagnostic(diagnostic) {
+  return `xanots: ${diagnostic.message}`;
+}
+function emitDiagnostic(diagnostic) {
+  if (diagnostic.severity === "error") throw new Error(formatDiagnostic(diagnostic));
+  sink(diagnostic);
+}
+var DiagnosticBag = class {
+  /**
+   * `strict`: report every warning as an error, so the build fails instead of
+   * printing.
+   *
+   * Warnings here are the shapes that deploy clean and then do the wrong thing —
+   * a `bulk.update` zero-filling the columns an item omits, an `ignoreEmpty`
+   * that returns the whole table. They stay warnings by default because each has
+   * a legitimate use, and the author who means it should not have to work around
+   * a guard. But the audience for this SDK is largely an agent that never reads
+   * stderr, and CI has no way to notice a message nobody fails on. `strict`
+   * gives a pipeline one switch that turns "printed something" into "did not
+   * ship" (issue #15).
+   *
+   * Scope: the diagnostics an EXPORT collects. A guard that runs while a
+   * statement is being built ({@link emitDiagnostic}) has already had its say by
+   * then — those throw or warn on the spot, at the line that caused them.
+   */
+  constructor(strict = false) {
+    this.strict = strict;
+  }
+  strict;
+  items = [];
+  add(diagnostic) {
+    this.items.push(diagnostic);
+  }
+  error(code, message) {
+    this.add({ severity: "error", code, message });
+  }
+  warn(code, message) {
+    this.add({ severity: "warning", code, message });
+  }
+  /** Report something the author must know, which is not a defect. See the module note. */
+  notice(code, message) {
+    this.add({ severity: "notice", code, message });
+  }
+  /** Everything recorded so far, in the order it was found. */
+  all() {
+    return [...this.items];
+  }
+  /**
+   * Emit the warnings, then throw if anything was an error. Warnings are
+   * emitted first and unconditionally: an author fixing the error still wants
+   * to see the rest of what the build found. Under `strict` a warning IS an
+   * error — it is still printed, and it also fails the export. A notice is
+   * printed at both settings and fails at neither.
+   */
+  flush() {
+    for (const item of this.items) {
+      if (item.severity !== "error") sink(item);
+    }
+    const errors = this.items.filter(
+      (item) => item.severity === "error" || this.strict && item.severity === "warning"
+    );
+    if (errors.length === 0) return;
+    const strictNote = this.strict ? " (`strict`: warnings are errors)" : "";
+    if (errors.length === 1) {
+      throw new Error(`${formatDiagnostic(errors[0])}${strictNote}`);
+    }
+    throw new Error(
+      `xanots: export failed with ${errors.length} errors${strictNote}.
+` + errors.map((error, i) => `  ${i + 1}. ${error.message}`).join("\n")
+    );
+  }
+};
+
+// src/values/value.ts
+var REJECT_TAGGED_VALUE = "c.obj/c.array embed a plain JSON constant and cannot contain a tagged value (inp/ref/auth/col/env/c.int/c.text/c.bool/\u2026) \u2014 those serialize as internal representation the engine can't decode. For a computed object response, use a record of values \u2014 `response: { key: value }` \u2014 not `c.obj({ key: value })`. For a request body (`s.api.request({ params })`) a tagged value is fine at the TOP LEVEL of a plain object; nested, wrap the whole body in `obj({...})`, which encodes any depth. (issue #42)";
+function isTaggedValue(x) {
+  return (
+    // A trigger field accessor (`t.new`) is a *callable* Value — a function
+    // carrying the `{value,tag,filters}` props — so `typeof` is "function", not
+    // "object". Accept both, or a bare `t.new` slips past this check, falls
+    // through coerceObj's record path, and trips the #42 c.obj guard (issue #78).
+    (typeof x === "object" || typeof x === "function") && x !== null && "value" in x && "filters" in x && Array.isArray(x.filters) && TAGS.includes(x.tag)
+  );
+}
+function assertPlainJson(root) {
+  const stack = [root];
+  while (stack.length > 0) {
+    const x = stack.pop();
+    if (isTaggedValue(x)) throw new Error(REJECT_TAGGED_VALUE);
+    if (Array.isArray(x)) {
+      for (let i = x.length - 1; i >= 0; i--) stack.push(x[i]);
+    } else if (typeof x === "object" && x !== null) {
+      const values = Object.values(x);
+      for (let i = values.length - 1; i >= 0; i--) stack.push(values[i]);
+    }
+  }
+}
+function val(value, tag, filters = []) {
+  return { value, tag, filters };
+}
+function isPlainRecord(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+var BARE_SET_PATH = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function setPath(key) {
+  if (BARE_SET_PATH.test(key)) return key;
+  return `["${key.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"]`;
+}
+function objMember(m) {
+  if (isPlainRecord(m)) return val("{}", "const:obj", objSetFilters(m));
+  if (Array.isArray(m)) return val(JSON.stringify(m), "const:array");
+  if (m === null) return val("null", "const:null");
+  if (typeof m === "boolean") return val(m ? "true" : "false", "const:bool");
+  if (typeof m === "number") {
+    if (!Number.isFinite(m)) return val("null", "const:null");
+    return Number.isInteger(m) && Number.isSafeInteger(m) ? val(String(m), "const:int") : val(String(m), "const:decimal");
+  }
+  return val(String(m), "const");
+}
+function warnZeroBasedNumericKeys(o) {
+  const keys = Object.keys(o);
+  if (keys.length === 0) return;
+  if (!keys.every((k) => /^(0|[1-9][0-9]*)$/.test(k))) return;
+  const indices = new Set(keys.map(Number));
+  for (let i = 0; i < keys.length; i++) if (!indices.has(i)) return;
+  emitDiagnostic({
+    severity: "warning",
+    code: "value.obj-zero-based-numeric-keys",
+    message: `c.obj({${keys.map((k) => JSON.stringify(k)).join(", ")}: \u2026}) has zero-based numeric keys, so the engine evaluates it as a LIST \u2014 ${JSON.stringify(keys.map((k) => o[k]))} \u2014 not an object. A numeric key IS an index in that data model, which is not something this encoding introduces. If you want the list, write c.array([\u2026]) and the intent is on the page; if you want an object, prefix the keys so they are not an index run (e.g. "k0"). A non-zero-based numeric key ({"2": \u2026}) survives as a key.`
+  });
+}
+function objSetFilters(o) {
+  return Object.entries(o).filter(([, m]) => m !== void 0).map(([key, m]) => filter("set", val(setPath(key), "const"), objMember(m)));
+}
+var PCRE_JS_FLAGS = "imsxu";
+function escapeRegexSlashes(body) {
+  let out2 = "";
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i];
+    if (ch === "\\") {
+      out2 += ch + (body[i + 1] ?? "");
+      i++;
+      continue;
+    }
+    out2 += ch === "/" ? "\\/" : ch;
+  }
+  return out2;
+}
+function isValidPcreLiteral(s) {
+  if (s.length < 2) return false;
+  const d = s[0];
+  if (/[a-zA-Z0-9\\\s]/.test(d)) return false;
+  const close = { "(": ")", "[": "]", "{": "}", "<": ">" }[d] ?? d;
+  let i = 1;
+  for (; i < s.length; i++) {
+    if (s[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (s[i] === close) break;
+  }
+  if (i >= s.length) return false;
+  return /^[a-zA-Z]*$/.test(s.slice(i + 1));
+}
+function barePatternRefusal(value) {
+  if (value.filters.length > 0 || value.tag !== "const") return null;
+  if (isValidPcreLiteral(value.value)) return null;
+  return `${JSON.stringify(value.value)} is a BARE regex pattern. PHP \`preg_*\` reads the first character as the delimiter, so the engine matches nothing for every input \u2014 the assertion or precondition built on it fails (or passes) against text that plainly should not. Build it with c.regex(${JSON.stringify(value.value)}) instead of c.text(...), which wraps and escapes it into a valid PCRE literal`;
+}
+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 intLiteral(n) {
+  if (typeof n === "bigint") return String(n);
+  if (typeof n === "string") {
+    if (!/^[+-]?\d+$/.test(n)) {
+      throw new Error(
+        `c.int() takes an integer literal as a string (digits, optional sign), got ${JSON.stringify(n)}. For a fractional number use c.decimal(), and for the editor's empty value box use c.blank("const:int").`
+      );
+    }
+    return n;
+  }
+  if (!Number.isInteger(n)) {
+    throw new Error(
+      `c.int() takes an integer, got ${n}. Use c.decimal(${n}) for a fractional number.`
+    );
+  }
+  if (!Number.isSafeInteger(n)) {
+    throw new Error(
+      `c.int() was given ${n}, which is past Number.MAX_SAFE_INTEGER \u2014 the literal has already lost precision before reaching here. Pass it as a string to store it exactly: c.int("${BigInt(n).toString()}") if that is the number you meant.`
+    );
+  }
+  return String(n);
+}
+var c = {
+  /**
+   * Plain string constant → `tag:"const"`.
+   *
+   * `null` is accepted alongside a string because the engine stores both: 47
+   * values in the sweep are a bare `const` holding `null` rather than `""`,
+   * mostly ignored statement-input entries the engine never reads. They are
+   * distinct bytes — `normalize` keeps them apart, unlike the `const:obj` blanks
+   * it does canonicalize — so a pull has to be able to spell the null form, and
+   * `c.text(null)` did not type-check.
+   *
+   * Write `c.text("")` for an empty string. The null form is here so a pulled
+   * workspace round-trips, not to be authored.
+   */
+  text(s) {
+    return val(s, "const");
+  },
+  /**
+   * Integer constant → `tag:"const:int"`, value stringified (e.g. `"123"`).
+   *
+   * Pass a **string** or `bigint` for an integer outside JavaScript's safe
+   * range. The engine stores integers as strings and has no such limit, so
+   * `c.int("18446744073709551615")` — 2^64 − 1, what a bitwise NOT returns —
+   * is exact, where the number literal for it silently rounds to `…616`.
+   *
+   * A `number` that is not an integer, or is past `Number.MAX_SAFE_INTEGER`,
+   * **throws**: by the time such a literal reaches here its precision is already
+   * gone, so encoding it would write a value the caller did not type. The throw
+   * names the string form. (issue #153)
+   */
+  int(n) {
+    return val(intLiteral(n), "const:int");
+  },
+  /**
+   * Decimal constant → `tag:"const:decimal"`.
+   *
+   * Pass a **string** to preserve a stored spelling a number literal cannot
+   * reproduce — `c.decimal("10.00")` keeps its trailing zeros, where
+   * `c.decimal(10)` writes `"10"`. The engine stores decimals as strings either
+   * way, so this is exactness rather than a workaround; prefer the number form
+   * whenever it reproduces the value you want.
+   */
+  decimal(n) {
+    return val(String(n), "const:decimal");
+  },
+  /**
+   * The editor's **unconfigured value box** — a value cell added and never
+   * filled in, stored as `{value: "", tag}`.
+   *
+   * This is not a zero, an empty string, or an empty collection. The engine
+   * reads `""` and `"0"` differently, so `c.blank("const:int")` and `c.int(0)`
+   * are different stored values and the SDK will not canonicalize one into the
+   * other. It exists because 13 real values in the survey corpus are in this
+   * state and had no authoring form, so a pull emitted them as annotated
+   * literals with a warning attached — describing a workspace that was fine.
+   *
+   * Constant tags only. A blank `var` or `input` is an unbound REFERENCE, which
+   * is a different defect with a different fix, and is deliberately not
+   * spellable here. `const` and `const:obj` are excluded too: they already have
+   * exact blank forms in `c.text("")` and `c.obj(null)`, and a second spelling
+   * for the same bytes is how two constructors start disagreeing.
+   */
+  blank(tag) {
+    return val("", tag);
+  },
+  /** Boolean constant → `"true"`/`"false"` with `tag:"const:bool"`. */
+  bool(b) {
+    return val(b ? "true" : "false", "const:bool");
+  },
+  /**
+   * Null constant → value `"null"` (per engine fixture).
+   *
+   * Bare `c.null()` is the plain `const:null`. Pass a tag for the **object-typed
+   * null** the engine writes into a `db.*` statement's `@meta` slot —
+   * `c.null("const:obj")` → `{tag:"const:obj", value:"null"}`, 16 of them across
+   * eight ordinary queries in the survey corpus, which had no spelling and came
+   * back as `rawValue` (issue #151).
+   *
+   * ⚠ Not the same bytes as `c.obj(null)`, which is the BLANK object
+   * (`value: ""`). Both evaluate to null — the engine JSON-decodes the stored
+   * string and `""` and `"null"` both decode to it — but they are two stored
+   * spellings, and the SDK writes back the one it was given rather than
+   * re-pointing a pulled workspace at the other.
+   */
+  null(tag = "const:null") {
+    return val("null", tag);
+  },
+  /**
+   * Build a **regex pattern value** for the pattern-piped regex filters
+   * (`fl.regex_test`/`regex_match`/`regex_replace`/…). Xano runs PHP `preg_*`, so
+   * the pattern MUST be delimiter-wrapped — a bare `c.text("^…$")` is an invalid
+   * PCRE and the filter then matches *nothing* for every input, so a precondition
+   * built on it silently rejects all values (issue #128). This wraps the raw
+   * pattern in `/…/`, escapes any interior `/`, and appends `flags`, so the result
+   * is always valid; `withFilters` rejects a bare `c.text` pattern and points here.
+   *
+   * Pass a JS `RegExp` (source + flags used directly, minus JS-only `g`/`y`/`d`):
+   * `c.regex(/^[^@\s]+@[^@\s]+\.[^@\s]+$/i)`, or a raw body + optional PCRE flags:
+   * `c.regex("^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$", "i")`. The pattern is the piped
+   * value; the filter's `subject` arg is the text tested against it.
+   */
+  regex(pattern, flags) {
+    const body = typeof pattern === "string" ? pattern : pattern.source;
+    const raw2 = flags ?? (typeof pattern === "string" ? "" : [...pattern.flags].filter((ch) => PCRE_JS_FLAGS.includes(ch)).join(""));
+    if (!/^[a-zA-Z]*$/.test(raw2)) {
+      throw new Error(`c.regex: flags must be letters (e.g. "i", "im"), got ${JSON.stringify(raw2)}`);
+    }
+    return val(`/${escapeRegexSlashes(body)}/${raw2}`, "const");
+  },
+  /**
+   * Current time as an **epoch-milliseconds** value — the engine's native
+   * `const:epochms` constant. Xano has no `$now` *setting*, so this lives on
+   * `c.*` (a current-time literal) rather than {@link sys} (which emits
+   * `setting("$…")` and would reference a dead `$now` var).
+   *
+   * Emits `{tag:"const:epochms", value:"now"}` — an UNFILTERED value, valid
+   * inline as a `where`/`cmp` operand. It previously emitted the equivalent
+   * `text("now") |to_epoch_ms` chain; both evaluate to the same epoch-ms number
+   * on a live engine, and both persist verbatim, but the native tag is what the
+   * editor writes and needs no filter to get there. Chain math onto it as usual:
+   * `withFilters(c.now(), fl.epochms_add_ms(c.int(-maxAgeMs)))`. (issues #120,
+   * #145)
+   */
+  now() {
+    return val("now", "const:epochms");
+  },
+  /**
+   * Object constant → JSON-string value with `tag:"const:obj"`. Takes **plain
+   * JSON literals only**: nesting a tagged value (`inp`/`ref`/`auth`/`c.*`) is a
+   * compile error and throws at runtime — it would serialize as internal
+   * representation the engine can't decode. For a computed/multi-key object
+   * response use a record of values (`response: { key: value }`), not `c.obj`.
+   * See issue #42.
+   *
+   * Called with no argument it is the **empty object**, `{}` — the same default
+   * the editor gives a new object variable, and the only empty form current
+   * editors write.
+   *
+   * Called with an explicit `null` it is the **blank** form (stored `value: ""`),
+   * which the engine evaluates to `null` rather than `{}` — it JSON-decodes the
+   * stored string, and decoding `""` yields null. That is a real difference in
+   * what the statement sees, so the two are separate spellings rather than one
+   * "empty object": `c.obj()` is `{}`, `c.obj(null)` is null.
+   *
+   * ⚠ **Prefer `c.obj()`.** The blank form is legacy — no current editor path
+   * writes it — and it exists here so a pulled workspace round-trips to the
+   * same bytes instead of being quietly re-pointed at `{}`.
+   *
+   * A **populated** object is stored the way the editor stores one: an empty
+   * `{}` base carrying one `set` filter per key (issue #248). It is NOT a
+   * populated JSON string — that form fails the request at runtime, see
+   * {@link objSetFilters}.
+   *
+   * ⚠ **Zero-based numeric keys come back as a LIST**, not an object:
+   * `c.obj({ "0": "a" })` evaluates to `["a"]`. That is the engine's data model
+   * — a numeric key IS an index there, and the same object decoded from JSON
+   * anywhere else behaves identically — not something this encoding introduces.
+   * A non-zero-based numeric key (`{ "2": … }`) survives as a key. Live-verified.
+   */
+  obj(o) {
+    if (o === null) return val("", "const:obj");
+    const j = o ?? {};
+    assertPlainJson(j);
+    if (!isPlainRecord(j)) return val(JSON.stringify(j), "const:obj");
+    warnZeroBasedNumericKeys(j);
+    return val("{}", "const:obj", objSetFilters(j));
+  },
+  /**
+   * Array constant → JSON-string value with `tag:"const:array"`. Takes **plain
+   * JSON literals only** — like {@link obj}, a nested tagged value is a compile
+   * error and throws at runtime. See issue #42.
+   */
+  array(a) {
+    assertPlainJson(a);
+    return val(JSON.stringify(a), "const:array");
+  },
+  /**
+   * A **Xano Expression Engine** expression, passed through verbatim →
+   * `tag:"const:expr2"`. The string IS the expression, exactly as it would be
+   * typed into the expression editor:
+   *
+   *   c.expression('"Hello, " ~ $input.name')
+   *   c.expression("$var.price * $var.qty")
+   *   c.expression("{ id: $var.user.id, tier: $var.plan }")
+   *
+   * ⚠️ **THE STRING IS NOT VALIDATED.** XanoTS does not parse it, does not
+   * type-check it, and cannot tell a working expression from a typo — the whole
+   * string is handed to the engine as-is. Nothing here participates in
+   * `InferResponse`, so a var referenced inside it is invisible to the type
+   * system, and a rename that updates every typed `ref()` will NOT update this.
+   * A malformed expression surfaces at RUNTIME, and one that is merely wrong
+   * (`$var.tota1`) surfaces as a wrong answer, not an error. Play at your own
+   * risk until validation exists.
+   *
+   * Prefer the typed surfaces whenever they cover the case: `ref`/`inp`/`col`
+   * for references, `withFilters(..., fl.*)` for transforms, {@link obj} for a
+   * dynamic object (it BUILDS a checked expression for you). Reach for this only
+   * for expression-engine syntax the typed surfaces cannot express — string
+   * concatenation with `~`, inline arithmetic, conditionals.
+   *
+   * NOT the `expr()` condition builder. `expr(col("id"), "=", inp("id"))` builds
+   * a comparison for a `where`; this builds a VALUE from raw expression source.
+   */
+  expression(source) {
+    assertExpressionSource(source, "c.expression");
+    return val(source, "const:expr2");
+  },
+  /**
+   * The **older** expression form → `tag:"const:expr"`, kept because real
+   * workspaces still hold values stored that way and codegen has to bring them
+   * back as something readable. New code wants {@link expression}, which is what
+   * the expression editor writes today.
+   *
+   * ⚠️ Unvalidated passthrough, exactly like {@link expression} — see the
+   * warning there. This one additionally uses the older syntax generation, so an
+   * expression copied out of the current editor may not mean the same thing
+   * here.
+   */
+  expressionLegacy(source) {
+    assertExpressionSource(source, "c.expressionLegacy");
+    return val(source, "const:expr");
+  }
+};
+function assertExpressionSource(source, fn2) {
+  if (typeof source !== "string") {
+    const tagged = isTaggedValue(source);
+    throw new Error(
+      `${fn2}() takes the expression SOURCE as a string, got ${tagged ? "a Value" : typeof source}. ` + (tagged ? `To reference a value inside an expression, write its path into the string (e.g. ${fn2}("$var.total * 2")). For a comparison in a where/condition use expr(left, op, right) or cmp(...), not ${fn2}().` : `Pass expression-engine source, e.g. ${fn2}('"Hi, " ~ $input.name').`)
+    );
+  }
+  if (source === "") {
+    throw new Error(
+      `${fn2}() was given an empty string, which the engine cannot evaluate. Pass expression source, or use c.text("") for an empty string constant.`
+    );
+  }
+}
+function ref(name, opts) {
+  const dot = name.indexOf(".");
+  if (opts?.safe && dot !== -1) {
+    const base = name.slice(0, dot);
+    const path = name.slice(dot + 1);
+    return withFilters(val(base, "var"), filter("get", c.text(path), c.null()));
+  }
+  return val(name, "var");
+}
+function assertNoRefOptions(creator, opts) {
+  if (opts === void 0) return;
+  const safe = typeof opts === "object" && opts !== null && "safe" in opts;
+  throw new Error(
+    `${creator}() takes only a name \u2014 ${safe ? "`safe`" : "a second argument"} is a ref() option and was silently dropped here before this guard (issue #80). Null-safe drilling into a dotted path is implemented on ref() alone: \`ref("owner.id", { safe: true })\` compiles to \`$owner|get:"id"\`, which yields null instead of 500ing when the base is null. To drill safely from ${creator}(), bind it to a variable first (\`s.set_var\`) and ref() that.`
+  );
+}
+function inp(name, opts) {
+  assertNoRefOptions("inp", opts);
+  return val(name, "input");
+}
+function col(name, opts) {
+  assertNoRefOptions("col", opts);
+  return val(name, "col");
+}
+function auth(path = "", opts) {
+  assertNoRefOptions("auth", opts);
+  return val(path, "auth");
+}
+function drill(base, path) {
+  if (path === "") return base;
+  return path.split(".").reduce((out2, seg) => BARE_SET_PATH.test(seg) ? `${out2}.${seg}` : out2 + setPath(seg), base);
+}
+function resp(path = "", opts) {
+  assertNoRefOptions("resp", opts);
+  return val(drill("response", path), "response");
+}
+function caught(path = "", opts) {
+  assertNoRefOptions("caught", opts);
+  return val(path, "trycatch");
+}
+function isToolsetPath(value) {
+  return value === "token" || value === "params" || value.startsWith("params.");
+}
+function toolset(path, opts) {
+  assertNoRefOptions("toolset", opts);
+  return val(path, "toolset");
+}
+function env(name, opts) {
+  assertNoRefOptions("env", opts);
+  return val(name, "setting");
+}
+function setting(name, opts) {
+  assertNoRefOptions("setting", opts);
+  return val(name, "setting");
+}
+var sys = {
+  /** Client IP address (`$remote_ip`, text). Best public-endpoint rate-limit key. */
+  remoteIp: () => val("$remote_ip", "setting"),
+  /** HTTP method of the request — `GET`, `POST`, … (`$request_method`, text). */
+  requestMethod: () => val("$request_method", "setting"),
+  /** Full request URI/path (`$request_uri`, text). */
+  requestUri: () => val("$request_uri", "setting"),
+  /** Raw query-string portion of the URL (`$request_querystring`, text). */
+  requestQueryString: () => val("$request_querystring", "setting"),
+  /** Request headers as an object/map (`$http_headers`, object). */
+  httpHeaders: () => val("$http_headers", "setting"),
+  /** The caller's `Authorization` bearer token, if present (`$request_auth_token`, text). */
+  requestAuthToken: () => val("$request_auth_token", "setting"),
+  /** API base URL for the request (`$api_baseurl`, text). */
+  apiBaseUrl: () => val("$api_baseurl", "setting"),
+  /** Active data source name — e.g. `live` or a branch source (`$datasource`, text). */
+  datasource: () => val("$datasource", "setting"),
+  /** Active branch name (`$branch`, text). */
+  branch: () => val("$branch", "setting"),
+  /** Tenant identifier for multi-tenant instances (`$tenant`, text). */
+  tenant: () => val("$tenant", "setting"),
+  /** Current release number (`$release`, int). */
+  release: () => val("$release", "setting"),
+  /** Platform identifier (`$platform`, int). */
+  platform: () => val("$platform", "setting"),
+  /** `true` when the request is running under the debugger (`$debugger`, bool). */
+  isDebugger: () => val("$debugger", "setting")
+};
+function out(name, opts) {
+  assertNoRefOptions("out", opts);
+  return val(name, "output");
+}
+function filter(name, ...args) {
+  const last = args.reduce((acc, a, i) => a !== void 0 ? i : acc, -1);
+  const hole = args.slice(0, last).findIndex((a) => a === void 0);
+  if (hole !== -1) {
+    throw new Error(
+      `Filter \`${name}\`: argument ${hole + 1} is omitted but argument ${last + 1} is supplied. Filter arguments are positional, so an omitted one in the middle would shift every argument after it into the wrong slot. Pass a value for argument ${hole + 1}, or use the named form \u2014 \`fl.${name}({ \u2026 })\` \u2014 which cannot mis-slot. (issue #221)`
+    );
+  }
+  assertLambdaFilterArgs(name, args);
+  assertExpressionFilterArgs(name, args);
+  assertEnumFilterArgs(name, args);
+  return { name, disabled: false, arg: args.filter((a) => a !== void 0) };
+}
+function withFilters(value, ...filters) {
+  const added = filters.flat(Infinity);
+  const malformed = added.findIndex(
+    (f2) => f2 === null || typeof f2 !== "object" || typeof f2.name !== "string"
+  );
+  if (malformed !== -1) {
+    const got = added[malformed];
+    throw new Error(
+      `withFilters: argument ${malformed} of the filter chain is not a filter \u2014 got ${JSON.stringify(got) ?? String(got)}. Each entry must come from an \`fl.*\` factory (or \`filter(name, ...)\`), which returns \`{name, arg, disabled}\`. A tagged value is not a filter: to pipe one value through another, pass it as a filter ARGUMENT (\`fl.concat(other)\`), not as a chain member.`
+    );
+  }
+  const pipedIsBarePattern = barePatternRefusal(value) !== null;
+  const offending = pipedIsBarePattern ? added.find((filter2) => REGEX_PATTERN_FILTERS.has(filter2.name)) : void 0;
+  if (offending) {
+    const escapeHatch = added[0] === offending ? "" : ` If this chain BUILDS the pattern rather than normalizing it, apply the prefix in its own \`withFilters(...)\` call \u2014 the guard only inspects an unfiltered const, so a filtered base passes through untouched.`;
+    throw new Error(
+      `Regex filter \`${offending.name}\` is pattern-piped: the value it filters is the regex PATTERN, which PHP \`preg_*\` requires to be delimiter-wrapped. ${JSON.stringify(value.value)} is a bare pattern, so the engine matches nothing for every input (a precondition on it silently rejects all values). Build it with c.regex(${JSON.stringify(value.value)}) instead of c.text(...).${escapeHatch} (issue #128)`
+    );
+  }
+  return { ...value, filters: [...value.filters, ...added] };
+}
+
+// src/values/lambda.ts
+var LAMBDA_BINDINGS = {
+  // Runs once, over no element and no piped value.
+  "s.lambda": ["$env", "$input", "$var", "$auth"],
+  // Runs once, over the piped value — which it binds as `$this` (NOT `$parent`).
+  "fl.lambda": ["$env", "$input", "$var", "$auth", "$this"],
+  // The array-iterating filters: one run per element.
+  map: ["$env", "$input", "$var", "$auth", "$this", "$index", "$parent"],
+  filter: ["$env", "$input", "$var", "$auth", "$this", "$index", "$parent"],
+  some: ["$env", "$input", "$var", "$auth", "$this", "$index", "$parent"],
+  every: ["$env", "$input", "$var", "$auth", "$this", "$index", "$parent"],
+  find: ["$env", "$input", "$var", "$auth", "$this", "$index", "$parent"],
+  findIndex: ["$env", "$input", "$var", "$auth", "$this", "$index", "$parent"],
+  // …plus the accumulator, which is `$result`. This is issue #221.
+  reduce: ["$env", "$input", "$var", "$auth", "$this", "$index", "$parent", "$result"]
+};
+var LAMBDA_GLOBALS = ["console", "crypto"];
+var LAMBDA_MODULE_GLOBALS = [
+  "_",
+  "aws4",
+  "axios",
+  "cryptojs",
+  "DateTime",
+  "ethers",
+  "fastXmlParser",
+  "jose",
+  "luxon",
+  "mailparser",
+  "math",
+  "moment",
+  "nodemailer",
+  "socks",
+  "uuid",
+  "utils"
+];
+var LAMBDA_CODE_FILTERS = {
+  lambda: { slot: 0, surface: "fl.lambda" },
+  map: { slot: 0, surface: "map" },
+  filter: { slot: 0, surface: "filter" },
+  some: { slot: 0, surface: "some" },
+  every: { slot: 0, surface: "every" },
+  find: { slot: 0, surface: "find" },
+  findIndex: { slot: 0, surface: "findIndex" },
+  reduce: { slot: 1, surface: "reduce" }
+};
+function assertLambdaFilterArgs(name, args) {
+  const site = LAMBDA_CODE_FILTERS[name];
+  if (site === void 0) return;
+  const code = args[site.slot];
+  if (!isInspectableBody(code) || code.value.trim() === "") return;
+  assertLambdaBody(code.value, site.surface, `fl.${name}`);
+}
+var LAMBDA_STATEMENTS = {
+  "mvp:lambda": { field: "code", surface: "s.lambda" }
+};
+function coerceLambdaFields(storedName, authored) {
+  const site = LAMBDA_STATEMENTS[storedName];
+  if (site === void 0 || typeof authored[site.field] !== "function") return authored;
+  return { ...authored, [site.field]: toLambdaValue(authored[site.field], site.surface, storedName === "mvp:lambda" ? "s.lambda" : storedName) };
+}
+function assertLambdaStatement(storedName, authored) {
+  const site = LAMBDA_STATEMENTS[storedName];
+  if (site === void 0) return;
+  const code = authored[site.field];
+  if (!isInspectableBody(code) || code.value.trim() === "") return;
+  assertLambdaBody(code.value, site.surface, "s.lambda");
+}
+function isInspectableBody(code) {
+  return typeof code === "object" && code !== null && code.tag === "const" && typeof code.value === "string" && (code.filters?.length ?? 0) === 0;
+}
+function toLambdaValue(x, surface, source) {
+  if (typeof x !== "function") return x;
+  return lambdaValue(extractFunctionBody(String(x), source), { surface }, source);
+}
+var PREFIX = "lam";
+function extractFunctionBody(source, caller) {
+  const src = source.trim();
+  if (src.includes("[native code]")) {
+    throw new Error(
+      `${caller}: this function has no readable source (it is native, bound, or otherwise not authored here), so there is no body to send to the engine. Write the body inline as an arrow function, or use lam.raw(...) with the code as text. (issue #221)`
+    );
+  }
+  const mask = maskNonCode(src);
+  const kw = /^(?:async\s+)?function\b/.exec(src);
+  if (kw) {
+    const open = mask.indexOf("{", closingParen(mask, kw[0].length));
+    const close = mask.lastIndexOf("}");
+    if (open === -1 || close <= open) {
+      throw new Error(`${caller}: could not find the function body in ${JSON.stringify(src.slice(0, 80))}.`);
+    }
+    assertDestructuredParams(src.slice(kw[0].length, open), mask.slice(open + 1, close), caller);
+    return stripKeepNames(dedent(src.slice(open + 1, close).trim()));
+  }
+  const arrow = topLevelArrow(mask);
+  if (arrow === -1) {
+    throw new Error(
+      `${caller}: expected an arrow function or a function expression, got ${JSON.stringify(src.slice(0, 80))}. A class method or an object shorthand method does not extract; write it as an arrow function.`
+    );
+  }
+  assertDestructuredParams(src.slice(0, arrow), mask.slice(arrow + 2), caller);
+  const rest = src.slice(arrow + 2).trim();
+  const restMask = mask.slice(arrow + 2).trim();
+  if (restMask.startsWith("{")) {
+    const close = restMask.lastIndexOf("}");
+    if (close === -1) throw new Error(`${caller}: unbalanced braces in the function body.`);
+    return stripKeepNames(dedent(rest.slice(1, close).trim()));
+  }
+  return stripKeepNames(`return ${rest.replace(/[;,]\s*$/, "")};`);
+}
+function stripKeepNames(body) {
+  let out2 = body;
+  for (; ; ) {
+    const mask = maskNonCode(out2);
+    const call = /(^|[^A-Za-z0-9_$.])__name\s*\(/.exec(mask);
+    if (call === null) break;
+    const start = call.index + (call[1] ?? "").length;
+    const open = mask.indexOf("(", start);
+    const close = closingParen(mask, start) - 1;
+    if (close <= open) break;
+    const args = out2.slice(open + 1, close);
+    const comma = splitTopLevel(maskNonCode(args))[0]?.length ?? args.length;
+    const first = args.slice(0, comma).trim();
+    const before = mask.slice(0, start);
+    const isStatement = /(^|[;{}])\s*$/.test(before) && /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(first);
+    const trailing = isStatement ? /^\s*;?/.exec(out2.slice(close + 1))?.[0].length ?? 0 : 0;
+    out2 = out2.slice(0, start) + (isStatement ? "" : first) + out2.slice(close + 1 + trailing);
+  }
+  return out2.trim();
+}
+function dedent(body) {
+  if (body.includes("`")) return body;
+  const lines = body.split("\n");
+  const indents = lines.slice(1).filter((l) => l.trim() !== "").map((l) => /^[ \t]*/.exec(l)?.[0].length ?? 0);
+  const common = indents.length ? Math.min(...indents) : 0;
+  if (common === 0) return body;
+  return [lines[0], ...lines.slice(1).map((l) => l.slice(common))].join("\n");
+}
+function assertDestructuredParams(params, bodyMask, caller) {
+  const inner = /\(([\s\S]*)\)/.exec(params)?.[1] ?? params;
+  for (const part of splitTopLevel(inner)) {
+    const name = /^\s*(?:\.\.\.)?\s*([A-Za-z_$][A-Za-z0-9_$]*)/.exec(part)?.[1];
+    if (name === void 0) continue;
+    const referenced = new RegExp(`(^|[^A-Za-z0-9_$.])${name.replace(/\$/g, "\\$")}\\b`).test(bodyMask);
+    if (!referenced) continue;
+    throw new Error(
+      `${caller}: the body reads \`${name}\`, but a lambda's parameters are not real \u2014 only the BODY is sent, and the engine injects the bindings as free identifiers. DESTRUCTURE them instead: \`({ ${name === "b" ? "$this" : name} }) => \u2026\` rather than \`(${name}) => \u2026 ${name}.$this \u2026\`. As written, \`${name}\` is undefined at runtime and the engine returns that failure as text in the value slot. (issue #221)`
+    );
+  }
+}
+function splitTopLevel(text) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    else if (ch === ")" || ch === "]" || ch === "}") depth--;
+    else if (ch === "," && depth === 0) {
+      parts.push(text.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(text.slice(start));
+  return parts;
+}
+function closingParen(mask, from) {
+  const open = mask.indexOf("(", from);
+  if (open === -1) return from;
+  let depth = 0;
+  for (let i = open; i < mask.length; i++) {
+    if (mask[i] === "(") depth++;
+    else if (mask[i] === ")" && --depth === 0) return i + 1;
+  }
+  return from;
+}
+function topLevelArrow(mask) {
+  let depth = 0;
+  for (let i = 0; i < mask.length - 1; i++) {
+    const ch = mask[i] ?? "";
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    else if (ch === ")" || ch === "]" || ch === "}") depth--;
+    else if (depth === 0 && ch === "=" && mask[i + 1] === ">") return i;
+  }
+  return -1;
+}
+function maskNonCode(src) {
+  const out2 = [];
+  const templates = [];
+  let i = 0;
+  let prevSignificant = "";
+  let prevWord = "";
+  const at = (k) => src[k] ?? "";
+  const top = () => templates[templates.length - 1] ?? 0;
+  const setTop = (v2) => {
+    templates[templates.length - 1] = v2;
+  };
+  const push = (ch, masked = false) => {
+    out2.push(masked ? ch === "\n" ? "\n" : " " : ch);
+    if (/\s/.test(ch)) return;
+    prevSignificant = ch;
+    if (!masked && /[A-Za-z0-9_$]/.test(ch)) prevWord += ch;
+    else prevWord = "";
+  };
+  const REGEX_PRECEDING_KEYWORDS = /* @__PURE__ */ new Set([
+    "return",
+    "typeof",
+    "case",
+    "in",
+    "of",
+    "new",
+    "delete",
+    "void",
+    "do",
+    "else",
+    "yield",
+    "await"
+  ]);
+  while (i < src.length) {
+    const ch = at(i);
+    const next = at(i + 1);
+    if (templates.length > 0 && top() >= 0) {
+      if (ch === "{") setTop(top() + 1);
+      else if (ch === "}") {
+        setTop(top() - 1);
+        if (top() === 0) {
+          setTop(-1);
+          push(ch, true);
+          i++;
+          continue;
+        }
+      }
+    }
+    if (templates.length > 0 && top() === -1) {
+      if (ch === "\\") {
+        push(ch, true);
+        push(at(i + 1), true);
+        i += 2;
+        continue;
+      }
+      if (ch === "`") {
+        templates.pop();
+        push(ch, true);
+        i++;
+        continue;
+      }
+      if (ch === "$" && next === "{") {
+        setTop(1);
+        push(ch, true);
+        push("{", true);
+        i += 2;
+        continue;
+      }
+      push(ch, true);
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      while (i < src.length && at(i) !== "\n") push(at(i++), true);
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      push(at(i++), true);
+      push(at(i++), true);
+      while (i < src.length && !(at(i) === "*" && at(i + 1) === "/")) push(at(i++), true);
+      if (i < src.length) {
+        push(at(i++), true);
+        push(at(i++), true);
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      push(ch, true);
+      i++;
+      while (i < src.length && at(i) !== ch) {
+        if (at(i) === "\\") push(at(i++), true);
+        if (i < src.length) push(at(i++), true);
+      }
+      if (i < src.length) push(at(i++), true);
+      continue;
+    }
+    if (ch === "`") {
+      templates.push(-1);
+      push(ch, true);
+      i++;
+      continue;
+    }
+    if (ch === "/" && (prevSignificant === "" || REGEX_PRECEDING_KEYWORDS.has(prevWord) || prevWord === "" && "(,=:[!&|?{};+-*%~^<>".includes(prevSignificant))) {
+      push(ch, true);
+      i++;
+      let closed = false;
+      while (i < src.length && at(i) !== "\n") {
+        if (at(i) === "\\") {
+          push(at(i++), true);
+          if (i < src.length) push(at(i++), true);
+          continue;
+        }
+        if (at(i) === "[") {
+          while (i < src.length && at(i) !== "]" && at(i) !== "\n") push(at(i++), true);
+          continue;
+        }
+        if (at(i) === "/") {
+          push(at(i++), true);
+          closed = true;
+          break;
+        }
+        push(at(i++), true);
+      }
+      if (!closed) {
+      }
+      continue;
+    }
+    push(ch);
+    i++;
+  }
+  return out2.join("");
+}
+function declaredLocals(mask, pattern = /\$[A-Za-z_][A-Za-z0-9_]*/g) {
+  const declared = /* @__PURE__ */ new Set();
+  const add = (text) => {
+    for (const m of (text ?? "").matchAll(pattern)) declared.add(m[0]);
+  };
+  for (const m of mask.matchAll(/\b(?:const|let|var)\s+([^;\n]+)/g)) {
+    for (const declarator of (m[1] ?? "").split(",")) add(declarator.split("=")[0]);
+  }
+  for (const m of mask.matchAll(/\b(?:function|class)\s+(\$[A-Za-z0-9_]*)/g)) add(m[1]);
+  for (const m of mask.matchAll(/\bcatch\s*\(([^)]*)\)/g)) add(m[1]);
+  for (const m of mask.matchAll(/(\([^()]*\)|[A-Za-z_$][A-Za-z0-9_$]*)\s*=>/g)) add(m[1]);
+  for (const m of mask.matchAll(/\bfunction\b[^(]*\(([^)]*)\)/g)) add(m[1]);
+  return declared;
+}
+function dollarTokens(mask) {
+  return tokens(mask, /(^|[^A-Za-z0-9_$.])(\$[A-Za-z_][A-Za-z0-9_]*)/g);
+}
+function tokens(mask, pattern, skipKeys = false) {
+  const seen = /* @__PURE__ */ new Set();
+  const out2 = [];
+  for (const m of mask.matchAll(pattern)) {
+    const name = m[2] ?? "";
+    if (name === "" || seen.has(name)) continue;
+    if (skipKeys) {
+      const before = mask.slice(0, m.index + (m[1] ?? "").length).trimEnd().slice(-1);
+      const after = mask.slice(m.index + m[0].length).trimStart().slice(0, 1);
+      if (after === ":" && (before === "{" || before === ",")) continue;
+    }
+    seen.add(name);
+    out2.push(name);
+  }
+  return out2;
+}
+var BUNDLER_HELPERS = {
+  __name: "a named inner function",
+  __publicField: "a class field",
+  __privateGet: "a #private field",
+  __privateSet: "a #private field",
+  __privateAdd: "a #private field",
+  __privateMethod: "a #private method",
+  __decorateClass: "a decorator",
+  __decorateParam: "a parameter decorator",
+  __async: "async/await",
+  __generator: "a generator",
+  __await: "await",
+  __forAwait: "for await",
+  __yieldStar: "yield*",
+  __spreadValues: "an object spread",
+  __spreadProps: "an object spread",
+  __objRest: "a rest destructuring",
+  __restKey: "a rest destructuring",
+  __pow: "the `**` operator",
+  __using: "`using`",
+  __callDispose: "`using`",
+  __toESM: "an import",
+  __toCommonJS: "an export",
+  __require: "a require",
+  __awaiter: "async/await",
+  __assign: "an object spread",
+  __rest: "a rest destructuring",
+  __decorate: "a decorator",
+  __extends: "a class",
+  __spreadArray: "an array spread"
+};
+var HELPER_LOOKALIKES = /* @__PURE__ */ new Set(["__proto__", "__dirname", "__filename"]);
+function suggestion(token, surface) {
+  const ACCUMULATOR_GUESSES = ["$acc", "$accumulator", "$carry", "$memo", "$total", "$prev", "$previous"];
+  if (ACCUMULATOR_GUESSES.includes(token) && LAMBDA_BINDINGS[surface].includes("$result")) {
+    return `\`$result\` is the accumulator at this surface`;
+  }
+  if (ACCUMULATOR_GUESSES.includes(token)) {
+    return `\`$result\` is the accumulator, and only \`reduce\` binds it`;
+  }
+  const elsewhere = Object.keys(LAMBDA_BINDINGS).filter(
+    (s) => LAMBDA_BINDINGS[s].includes(token)
+  );
+  if (elsewhere.length) return `\`${token}\` is bound at ${elsewhere.join(", ")}, but not here`;
+  if (token === "$parent" || token === "$this") {
+    return `the value a filter is applied to is \`$this\` in \`fl.lambda\`, and \`$parent\` in the array-iterating filters`;
+  }
+  return void 0;
+}
+function assertLambdaBody(body, surface, source = `${PREFIX}.fn`) {
+  try {
+    assertBody(body, surface, source);
+  } catch (err) {
+    if (collector === null) throw err;
+    collector(err instanceof Error ? err.message : String(err));
+  }
+}
+var collector = null;
+function collectLambdaBodyProblems(onProblem, fn2) {
+  const previous = collector;
+  collector = onProblem;
+  try {
+    return fn2();
+  } finally {
+    collector = previous;
+  }
+}
+function assertBody(body, surface, source) {
+  if (body.trim() === "") {
+    throw new Error(
+      `${source}: the lambda body is empty. A lambda must return a value \u2014 the engine refuses a statement with no code. (issue #221)`
+    );
+  }
+  const mask = maskNonCode(body);
+  const legal = LAMBDA_BINDINGS[surface];
+  const locals = declaredLocals(mask);
+  for (const token of dollarTokens(mask)) {
+    if (legal.includes(token) || locals.has(token)) continue;
+    const hint = suggestion(token, surface);
+    throw new Error(
+      `${source}: \`${token}\` is not a binding in a \`${surface}\` lambda body${hint ? ` \u2014 ${hint}` : ""}. It reads as undefined at runtime and raises NOTHING: the body runs, \`typeof\` reports "undefined", the value comes back null with HTTP 200, and a defensive \`typeof x !== "undefined"\` guard takes the wrong branch. Author time is the only place this is catchable. Bound here: ${legal.join(", ")} (plus the ${LAMBDA_GLOBALS.join(" / ")} globals). A stack variable is reached as \`$var.name\`, never as \`$name\`. (issue #221)`
+    );
+  }
+  assertNoBundlerHelpers(mask, source);
+  const moduleSyntax = /(^|[;{}\n])\s*(import|export)\b(?![\s]*[.(])/.exec(mask);
+  if (moduleSyntax) {
+    const kw = moduleSyntax[2];
+    throw new Error(
+      `${source}: a top-level \`${kw}\` is a syntax error in a lambda body \u2014 the body is a function body, not a module, so it must \`return\` its value and cannot declare module syntax. Reach a dependency through the PRELOADED globals, which need no specifier: ${LAMBDA_MODULE_GLOBALS.join(", ")} (plus ${LAMBDA_GLOBALS.join(" / ")}, fetch, Buffer, TextEncoder). A dynamic \`import("...")\` or \`require("...")\` with a literal specifier is NOT portable: on an instance that bundles the body before running it, every literal specifier is resolved ahead of time and none of them exist, so the call comes back as the text \`Could not resolve "..."\` with HTTP 200. (issues #221, #265)`
+    );
+  }
+}
+function assertNoBundlerHelpers(mask, source) {
+  const declared = declaredLocals(mask, /__[A-Za-z0-9_$]*/g);
+  for (const token of tokens(mask, /(^|[^A-Za-z0-9_$.])(__[A-Za-z][A-Za-z0-9_$]*)/g, true)) {
+    if (declared.has(token) || HELPER_LOOKALIKES.has(token)) continue;
+    const wrote = BUNDLER_HELPERS[token];
+    throw new Error(
+      `${source}: \`${token}\` is a bundler helper, not something this body can call \u2014 the body was TRANSPILED before it could be read back${wrote ? `, because it writes ${wrote}` : ""}. An inline body is recovered from the live function with \`toString()\`, and a \`.ts\` loader (tsx/esbuild, which is how a TypeScript entry is evaluated) returns rewritten source. The helper is defined at MODULE scope and only the body travels, so \`${token}\` is undefined at runtime: the body throws, and the engine returns that failure as TEXT in the value slot with HTTP 200 \u2014 a wrong value, not an error. Move the body to its own module and load it with \`lam.file(...)\`, or write it as text with \`lam.raw(...)\`; neither is transpiled. (issue #256)`
+    );
+  }
+}
+var UNREPRESENTABLE_CLASSES = [
+  {
+    ctor: Date,
+    name: "Date",
+    fix: "capture the epoch number (`d.getTime()`) or the ISO string and rebuild it in the body (`new Date(d)`)"
+  },
+  {
+    ctor: Map,
+    name: "Map",
+    fix: "capture a plain object (`Object.fromEntries(m)`) \u2014 or the entries array, and rebuild with `new Map(entries)` in the body"
+  },
+  {
+    ctor: Set,
+    name: "Set",
+    fix: "capture an array (`[...s]`) \u2014 and rebuild with `new Set(arr)` in the body if you need set semantics"
+  },
+  {
+    ctor: RegExp,
+    name: "RegExp",
+    fix: "capture the source and flags as strings and rebuild with `new RegExp(src, flags)` in the body"
+  }
+];
+function article(word) {
+  return /^[aeiou]/i.test(word) ? "an" : "a";
+}
+function assertJsonCapture(name, value, source) {
+  const type = typeof value;
+  if (type === "function" || type === "symbol" || type === "bigint" || type === "undefined") {
+    throw new Error(
+      `${source}: capture \`${name}\` is ${article(type)} ${type}, which cannot cross into the engine \u2014 the body is sent as TEXT and runs in a different process. Capture JSON data (string, number, boolean, null, object, array); for behaviour, inline it in the body. (issue #221)`
+    );
+  }
+  assertNoUnrepresentableClass(name, value, source, /* @__PURE__ */ new Set());
+}
+function assertNoUnrepresentableClass(path, value, source, seen) {
+  if (value === null || typeof value !== "object") return;
+  for (const entry of UNREPRESENTABLE_CLASSES) {
+    if (!(value instanceof entry.ctor)) continue;
+    throw new Error(
+      `${source}: capture \`${path}\` is ${article(entry.name)} ${entry.name}, which cannot cross into the engine \u2014 the body is sent as TEXT, and JSON-encoding ${article(entry.name)} ${entry.name} yields ${entry.name === "Date" ? "a string" : "`{}`"}, not ${article(entry.name)} ${entry.name}. The body would read a different type than the one TypeScript gave it, and fail INSIDE the engine \u2014 which returns that failure as TEXT with HTTP 200, a wrong value rather than an error. Instead, ${entry.fix}. (issue #246)`
+    );
+  }
+  if (seen.has(value)) return;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    value.forEach((item, i) => assertNoUnrepresentableClass(`${path}[${i}]`, item, source, seen));
+    return;
+  }
+  for (const [key, item] of Object.entries(value)) {
+    assertNoUnrepresentableClass(`${path}.${key}`, item, source, seen);
+  }
+}
+function capturePrelude(capture, source) {
+  if (capture === void 0) return "";
+  const lines = [];
+  for (const [name, value] of Object.entries(capture)) {
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name)) {
+      throw new Error(`${source}: capture key ${JSON.stringify(name)} is not a valid JavaScript identifier.`);
+    }
+    assertJsonCapture(name, value, source);
+    lines.push(`const ${name} = ${JSON.stringify(value)};`);
+  }
+  return lines.length ? lines.join("\n") + "\n" : "";
+}
+function assertCaptureNotRenamed(body, capture, source) {
+  if (capture === void 0) return;
+  const keys = Object.keys(capture);
+  if (keys.length === 0) return;
+  const mask = maskNonCode(body);
+  const declared = declaredLocals(mask, /[A-Za-z_$][A-Za-z0-9_$]*/g);
+  for (const token of tokens(mask, /(^|[^A-Za-z0-9_$.])([A-Za-z_$][A-Za-z0-9_$]*[0-9])/g, true)) {
+    if (declared.has(token)) continue;
+    const key = keys.find((k) => new RegExp(`^${k.replace(/\$/g, "\\$")}[0-9]+$`).test(token));
+    if (key === void 0) continue;
+    throw new Error(
+      `${source}: capture key \`${key}\` collides with a module-scope binding of the same name, so the body was rewritten to read \`${token}\` \u2014 which the capture prelude does not declare. An inline body is recovered from the live function with \`toString()\`, and a \`.ts\` loader (tsx/esbuild) renames one of two same-named bindings; the prelude is written afterwards, under the ORIGINAL name. As it stands \`${token}\` is undefined at runtime: the body throws, and the engine returns that failure as TEXT in the value slot with HTTP 200 \u2014 a wrong value, not an error. Give the capture a key that nothing at module scope shares \u2014 it does not have to keep the name of what it carries (\`capture: { <newName>: ${key} }\`, destructured as \`(_, { <newName> }) => \u2026\`) \u2014 or move the body to its own module with \`lam.file(...)\`. (issue #256)`
+    );
+  }
+}
+function lambdaValue(body, opts, source) {
+  const code = capturePrelude(opts?.capture, source) + body;
+  assertCaptureNotRenamed(body, opts?.capture, source);
+  if (opts?.surface !== void 0) assertLambdaBody(code, opts.surface, source);
+  return c.text(code);
+}
+function fn(body, opts) {
+  return lambdaValue(extractFunctionBody(String(body), `${PREFIX}.fn`), opts, `${PREFIX}.fn`);
+}
+function raw(code, opts) {
+  return lambdaValue(code, opts, `${PREFIX}.raw`);
+}
+function fileOnNodeEntryOnly() {
+  throw new Error(
+    `${PREFIX}.file: this entry has no filesystem. It ships on the Node entry only \u2014 \`import { lam } from "@xanots/sdk/node"\` (that \`lam\` carries \`fn\` and \`raw\` too). In a browser bundle, use \`${PREFIX}.raw(code, { surface })\` with the body as text. (issue #257)`
+  );
+}
+var lam = Object.assign({ fn, raw }, { file: fileOnNodeEntryOnly });
+
+// src/fields/catalog.ts
+var DEFAULTABLE_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "int",
+  "decimal",
+  "enum",
+  "bool",
+  "email",
+  "json",
+  "date",
+  "epochms"
+]);
+var ACCESS_VALUES = /* @__PURE__ */ new Set(["public", "private", "internal"]);
+var FORMAT_VALUES = /* @__PURE__ */ new Set(["", "plaintext", "yaml", "html", "xml", "markdown"]);
+function descriptor(type, options) {
+  if (options.format && type !== "text") {
+    throw new Error(`f: \`format\` is only valid on text fields, not "${type}".`);
+  }
+  if (options.format !== void 0 && !FORMAT_VALUES.has(options.format)) {
+    throw new Error(
+      `f: invalid text \`format\` "${options.format}"; valid: plaintext/yaml/html/xml/markdown.`
+    );
+  }
+  if (options.access !== void 0 && !ACCESS_VALUES.has(options.access)) {
+    throw new Error(
+      `f: invalid \`access\` "${options.access}"; valid: public/private/internal.`
+    );
+  }
+  if (options.default !== void 0 && options.default !== "" && !DEFAULTABLE_TYPES.has(type)) {
+    throw new Error(
+      `f: \`default\` is not supported on "${type}" fields (the engine drops it); valid on text/int/decimal/enum/bool/email/json/date/timestamp.`
+    );
+  }
+  if (options.noDefault === true && options.default !== void 0) {
+    throw new Error(
+      `f: \`noDefault\` and \`default\` are mutually exclusive on "${type}" fields \u2014 \`noDefault\` omits the key entirely, so there is no value to set.`
+    );
+  }
+  return { type, options };
+}
+function make(type, defaults) {
+  return (options = {}) => descriptor(type, { ...defaults, ...options });
+}
+function targetKeyType(table2) {
+  if (typeof table2 === "string") return void 0;
+  const def = table2;
+  if (def.idType === "int" || def.idType === "uuid") return def.idType;
+  if (def.schema === void 0 || def.schema === null) return void 0;
+  const idType = Array.isArray(def.schema) ? def.schema.find((col2) => col2?.name === "id")?.type : def.schema.id?.type;
+  if (idType === "uuid") return "uuid";
+  return idType === void 0 || idType === "int" ? "int" : void 0;
+}
+function assertTableRefKeyType(table2, columnType) {
+  const idType = targetKeyType(table2);
+  if (idType === void 0 || idType === columnType) return;
+  const name = (typeof table2 === "string" ? table2 : table2.name) || "<unnamed>";
+  throw new Error(
+    `f.tableRef("${name}"): the column is "${columnType}" but that table's primary key is "${idType}". The engine requires a reference column to match the target's key type, so this fails at import. Use f.tableRef(${name}, { type: "${idType}" }).`
+  );
+}
+function toNestedFields(map) {
+  return Object.entries(map).map(([name, d]) => ({ name, type: d.type, ...d.options }));
+}
+var f = {
+  // --- scalars ---
+  text: make("text"),
+  int: make("int"),
+  decimal: make("decimal"),
+  bool: make("bool"),
+  uuid: make("uuid"),
+  date: make("date"),
+  email: make("email"),
+  /** Password field; defaults to `access:"internal"` (the engine's stored default). */
+  password: make("password", { access: "internal" }),
+  /**
+   * JSON column. Accepts an optional nested `children` schema — the structure the
+   * editor shows when a `json` field is expanded, and what a pulled workspace
+   * carries.
+   *
+   * `children` is spelled as an ARRAY of named, typed fields rather than the
+   * `FieldMap` {@link FieldCatalog.object} takes positionally. The two are not
+   * interchangeable: an object column's children are the column's own schema,
+   * while a json column's are a description of the shape stored inside it, which
+   * the engine persists in the order given. That order is part of the stored
+   * bytes, and a map does not preserve it.
+   *
+   * Without this there is no way to author a structured JSON column at all
+   * (issue #135).
+   */
+  json(options = {}) {
+    return descriptor("json", { ...options });
+  },
+  /** Epoch-millisecond timestamp (authored as `timestamp`). */
+  timestamp: make("epochms"),
+  // --- file resources (authoring name → blob_* stored name) ---
+  /** Image file resource (stored `blob_img`). */
+  image: make("blob_img"),
+  /** Video file resource (stored `blob_video`). */
+  video: make("blob_video"),
+  /** Audio file resource (stored `blob_audio`). */
+  audio: make("blob_audio"),
+  /** Generic file attachment (stored `blob`). */
+  attachment: make("blob"),
+  // --- geo ---
+  geo: {
+    point: make("geo_point"),
+    multipoint: make("geo_multipoint"),
+    linestring: make("geo_linestring"),
+    multilinestring: make("geo_multilinestring"),
+    polygon: make("geo_polygon"),
+    multipolygon: make("geo_multipolygon")
+  },
+  // --- composite (positional payload + options) ---
+  /**
+   * Enum field. `values` may be empty — that is an enum column added in the
+   * editor and not yet given its options, which the engine stores and which
+   * appears in the survey corpus. Refusing it made the SDK stricter than the
+   * engine and cost a real table its readable form.
+   *
+   * An empty `values` brands the column `never` — an enum permitting nothing can
+   * hold nothing. Note what that becomes downstream: `InferRow` surfaces the
+   * column as `undefined`, not `never`, so a read-time narrow written against
+   * `never` (`if (row.e === "x")`) is dead differently than it looks.
+   */
+  enum(values, options = {}) {
+    return descriptor("enum", { ...options, values: [...values] });
+  },
+  /** Vector field; `size` (>= 1) is the embedding dimensionality. */
+  vector(size, options = {}) {
+    if (!Number.isInteger(size) || size < 1) {
+      throw new Error(`f.vector: size must be an integer >= 1, got ${size}.`);
+    }
+    return descriptor("vector", { ...options, vector: { size } });
+  },
+  /** Nested object field (stored `obj`); `children` is a named field map. */
+  object(children, options = {}) {
+    return descriptor("obj", { ...options, children: toNestedFields(children) });
+  },
+  /**
+   * Table-reference (foreign-key) field — the column holds the referenced
+   * table's primary key. The engine persists the link as a trailing `@` method
+   * carrying the target table's id (`{name:"@", arg:["dbo=<guid>"]}`); on import
+   * it parses that back into the column's `tableref_id`. The reference resolves to the
+   * table's deterministic guid via the shared cross-object resolver, so it
+   * agrees with the target table's payload `guid` with no shared registry.
+   *
+   * Defaults to an `int` column (matching an `int` primary key); pass
+   * `{ type: "uuid" }` to reference a uuid-keyed table. A reference column may
+   * only be `int` or `uuid` — the two valid primary-key types.
+   *
+   * @param table The referenced table (a `table()` def handle or its bare name).
+   *   For a **self-reference** (e.g. `tweets.reply_to → tweets`), the table's
+   *   `const` binding isn't assigned yet inside its own initializer — using the
+   *   handle throws a "used before declaration" error. Pass the **bare name**
+   *   instead: `f.tableRef("tweets", { type: "int" })`. Identity guids derive
+   *   from `(type, name)`, so the name form resolves to the same guid.
+   *
+   * Byte-verified whole-object against a persisted table readback
+   * (`test/fixtures/tables/ex_field_table_ref.json`, asserted in
+   * `test/conformance/kinds-corpus.test.ts`): the `@` method carries
+   * `disabled:false`, sits last in `methods`, and its `dbo=` arg is the target
+   * table's payload guid.
+   *
+   * The engine asserts the referenced table's primary-key type matches
+   * (int↔int, uuid↔uuid). When the target is passed as a **def handle** its
+   * `idType` is in hand, so a mismatch throws here instead of surfacing as an
+   * import failure. The bare-name form (self-references) carries no schema —
+   * there is nothing to check against, and it is not guessed at.
+   */
+  tableRef(table2, options = {}) {
+    const { type = "int", methods = [], ...rest } = options;
+    assertTableRefKeyType(table2, type);
+    const guid = resolveRef("dbo", table2);
+    return descriptor(type, {
+      ...rest,
+      methods: [...methods ?? [], { name: "@", arg: [`dbo=${guid}`] }]
+    });
+  }
+};
+
+// src/inputs/input.ts
+function makeInput(type) {
+  return (options = {}) => ({ type, options });
+}
+var input = {
+  // --- scalars ---
+  text: makeInput("text"),
+  int: makeInput("int"),
+  decimal: makeInput("decimal"),
+  bool: makeInput("bool"),
+  email: makeInput("email"),
+  /**
+   * Password input — hashes its value **when the input binds**, before your stack
+   * runs. This breaks the natural signup/login shape and is the single most common
+   * way to ship silently-broken auth:
+   * - **Login:** `s.security.check_password` receives the *already-hashed* submission
+   *   (a fresh random salt each request), compares it against the stored hash, and
+   *   never matches — so login always fails with a false "invalid password".
+   * - **Signup:** the value is hashed here at bind, so the `f.password` column then sees
+   *   an already-hashed `salt.hash` value and stores it as-is (the column's hash-on-write
+   *   skips a value already in that shape) — the plaintext never lands in the column.
+   *
+   * Recipe: use {@link input.text} (e.g. `input.text({ methods: ["min:6"] })`) for the
+   * password on **both** signup and login, let the `f.password` *column* hash on write,
+   * and pass the plaintext straight to `check_password`. See the auth recipe in the
+   * README. Reach for `input.password` only when you specifically want bind-time hashing
+   * and are not also comparing it with `check_password` (issue #109).
+   */
+  password: makeInput("password"),
+  /**
+   * URL input — a `text` field that names the intent "this holds a URL". There
+   * is no native engine `url` type, and this does **not** by itself enforce an
+   * http(s) scheme: a `javascript:`/`data:` URL still type-checks and imports.
+   * When the value is security-relevant (e.g. a link that gets navigated to),
+   * reject bad input at the boundary in the stack with `s.precondition` — see
+   * the "validate input at the boundary" recipe in the README. Carries the same
+   * `TextMethod` options as {@link input.text}.
+   */
+  url: makeInput("text"),
+  uuid: makeInput("uuid"),
+  date: makeInput("date"),
+  /** Epoch-millisecond timestamp (stored `epochms`). */
+  timestamp: makeInput("epochms"),
+  json: makeInput("json"),
+  /**
+   * Raw file **upload** (stored `file`) — the bytes as they arrive on the
+   * request (multipart, base64, or a fetched URI). Input-only: there is no
+   * `f.file` column, because an upload is not something a table holds.
+   *
+   * It is NOT a stored file resource and cannot be written to a file column
+   * directly. Store it first and write what you get back:
+   * `s.storage.create_image({ as: "img", value: ref("input.avatar") })`, then
+   * write `ref("img")` to an `f.image()` column. Use {@link input.image} and
+   * friends only when the caller already sends a stored file resource.
+   */
+  file: makeInput("file"),
+  /**
+   * **Database link** — one input that EXPANDS into one input per column of the
+   * linked table (stored `<tableGuid>_mvpschema`; XanoScript `dblink`). A table
+   * with three columns turns this single entry into three request inputs, so
+   * read them by their own column names: `inp("email")`, not `inp("user__")`.
+   * The expansion is live — adding a column to the table adds an input here.
+   *
+   * `hidden` is how you drop columns from that expansion (`["created_at", "id"]`)
+   * and is the common case in the wild, not an edge case. `merge: true` is what
+   * makes the engine expand rather than nest, so it is forced and cannot be
+   * unset — a dblink that does not merge is not a dblink.
+   *
+   * `customize` overrides individual expanded columns — `{ email: { required:
+   * true, methods: ["lower"] } }` — where `hidden` drops them wholesale. Both
+   * are read per column by the engine's expansion, and a column named in
+   * `customize` with `hidden: true` is dropped exactly as the outer list does it.
+   *
+   * Input-only: `excludedTypesForDatabase` rules it out as a column, and a
+   * column linking a whole table would be a foreign key — use
+   * {@link f.tableRef} for that.
+   *
+   * By convention the editor names the entry after the table with a trailing
+   * `__` (`user__`), but the name is just the key in your `input:` map and any
+   * name round-trips.
+   */
+  dbLink(table2, options = {}) {
+    return {
+      type: `${resolveRef("dbo", table2)}_mvpschema`,
+      options: { ...options, merge: true }
+    };
+  },
+  // --- file resources / geo / vector / table refs (shared with the `f.*` catalog) ---
+  /** Image file input (stored `blob_img`). */
+  image: f.image,
+  /** Video file input (stored `blob_video`). */
+  video: f.video,
+  /** Audio file input (stored `blob_audio`). */
+  audio: f.audio,
+  /** Generic file-attachment input (stored `blob`). */
+  attachment: f.attachment,
+  /** Geo inputs: `input.geo.point()`, `.polygon()`, … (six geometry types). */
+  geo: f.geo,
+  /** Vector input; `size` (>= 1) is the embedding dimensionality. */
+  vector: f.vector,
+  /** Table-reference input — see {@link f.tableRef}; pass the table handle or bare name. */
+  tableRef: f.tableRef,
+  /**
+   * Enum input. `values` may be empty, mirroring {@link f.enum} — the two
+   * surfaces describe the same engine type, and one accepting what the other
+   * rejects is how they start disagreeing about what a workspace can hold.
+   */
+  enum(values, options = {}) {
+    return { type: "enum", options: { ...options, values: [...values] } };
+  },
+  /**
+   * Object input (stored `obj`) with typed, named children. `children` is a
+   * field map built from the same `f.*` catalog used for columns, e.g.
+   * `input.object({ name: f.text(), age: f.int() })`.
+   */
+  object(children, options = {}) {
+    return {
+      type: "obj",
+      options: { ...options, children: toNestedFields(children) }
+    };
+  },
+  /**
+   * List (array) input — wraps an element constructor, mirroring `Array<T>`:
+   * `input.list(input.text())`, `input.list(input.object({ id: f.int() }))`.
+   * The element's own options (e.g. its `methods`) are kept; list-level `options`
+   * (`required`, `nullable`, `description`, …) apply to the list field and win
+   * on conflict. The element's value type is preserved as the array element.
+   */
+  list(element, options = {}) {
+    if (!element?.type) {
+      throw new Error("input.list: pass an element constructor, e.g. input.list(input.text()).");
+    }
+    return {
+      type: element.type,
+      options: { ...element.options, ...options, array: true }
+    };
+  }
+};
+function encodeInput(name, descriptor2) {
+  if (isTaggedValue(descriptor2)) {
+    throw new Error(
+      `input "${name}": got a value ref (inp("${descriptor2.value}"), tag "${descriptor2.tag}") where an input descriptor is required. An "input:" map wants a descriptor factory like input.text()/input.int()/input.enum([...]) \u2014 not the value ref inp(...). Reach for inp("${name}") only to READ this input inside a where/stack/value slot.`
+    );
+  }
+  return encodeField(name, descriptor2.type, descriptor2.options, INPUT_CONTEXT);
+}
+
+// src/values/obj.ts
+var IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function serializeValue(v2, path) {
+  return serializeAtom(v2, path) + serializeFilters(v2, path);
+}
+function serializeFilters(v2, path) {
+  let out2 = "";
+  for (const f2 of v2.filters) {
+    if (f2.disabled) {
+      throw new Error(
+        `obj(): the value at \`${path}\` carries a DISABLED \`${f2.name}\` filter. An object literal is stored as one expression string, which has no spelling for a disabled filter \u2014 drop it, or build the value in a prior step (e.g. \`s.set_var\`) and reference it with \`ref\`.`
+      );
+    }
+    const args = f2.arg.map((a, i) => {
+      if (a.filters.length > 0) {
+        throw new Error(
+          `obj(): the \`${f2.name}\` filter at \`${path}\` has an argument (#${i}) that carries its own filter chain. In an expression a trailing \`|\` binds to the whole value, not to one argument, so this cannot be written without changing what it means. Compute the argument in a prior step and reference it with \`ref\`.`
+        );
+      }
+      return serializeAtom(a, `${path}|${f2.name}[${i}]`);
+    });
+    out2 += `|${f2.name}${args.length > 0 ? `:${args.join(":")}` : ""}`;
+  }
+  return out2;
+}
+function serializeAtom(v2, path) {
+  switch (v2.tag) {
+    case "const":
+      return JSON.stringify(v2.value);
+    // double-quoted + escaped, valid XanoScript string
+    case "const:int":
+    case "const:decimal":
+      return v2.value;
+    // already the numeric literal (e.g. "123", "1.5")
+    case "const:bool":
+      return v2.value === "true" ? "true" : "false";
+    case "const:null":
+      return "null";
+    case "input":
+      return `$input.${v2.value}`;
+    case "var":
+      return `$var.${v2.value}`;
+    case "auth":
+      return v2.value ? `$auth.${v2.value}` : "$auth";
+    case "col":
+      return `$db.${v2.value}`;
+    // A workspace env var and a built-in request var are the SAME tag; the
+    // built-ins just carry a `$`-prefixed name. Both spell `$env.` + the name,
+    // so `sys.remoteIp()` renders `$env.$remote_ip` and `env("STRIPE_KEY")`
+    // renders `$env.STRIPE_KEY`.
+    case "setting":
+      return `$env.${v2.value}`;
+    // The engine's native current-time constant. Only ever holds `"now"` — the
+    // same narrowing the decoder makes — so anything else falls through to the
+    // rejection rather than being rendered as a `now` it is not.
+    case "const:epochms":
+      if (v2.value === "now") return "now";
+      break;
+  }
+  throw new Error(
+    `obj(): value tag "${v2.tag}" at \`${path}\` isn't supported in a dynamic object literal yet. Supported: inp(), ref(), auth(), col(), env()/setting()/sys.*, c.now(), and c.text/int/decimal/bool/null \u2014 each optionally carrying a filter chain.`
+  );
+}
+function serializeMember(m, path) {
+  if (typeof m === "string") return JSON.stringify(m);
+  if (typeof m === "number") return String(m);
+  if (typeof m === "boolean") return m ? "true" : "false";
+  if (isTaggedValue(m)) return serializeValue(m, path);
+  if (Array.isArray(m)) {
+    return `[${m.map((el, i) => serializeMember(el, `${path}[${i}]`)).join(", ")}]`;
+  }
+  if (m !== null && typeof m === "object") return serializeRecord(m, path);
+  throw new Error(
+    `obj(): \`${path}\` must be a Value (inp/ref/auth/col/c.*), a scalar literal (string/number/boolean), a nested object, or an array (got ${typeof m}).`
+  );
+}
+function serializeRecord(rec, path) {
+  const parts = Object.entries(rec).map(([key, member]) => {
+    if (!IDENT.test(key)) {
+      throw new Error(
+        `obj(): key "${key}"${path ? ` at \`${path}\`` : ""} must be a bare identifier ([A-Za-z_][A-Za-z0-9_]*) \u2014 XanoScript object keys aren't quoted.`
+      );
+    }
+    return `${key}: ${serializeMember(member, path ? `${path}.${key}` : key)}`;
+  });
+  return parts.length === 0 ? "{}" : `{ ${parts.join(", ")} }`;
+}
+function obj(fields) {
+  return {
+    value: serializeRecord(fields, ""),
+    tag: "const:expr2",
+    filters: []
+  };
+}
+
+// src/values/generated/filters.generated.ts
+var v = (x) => {
+  if (typeof x === "string") return c.text(x);
+  if (typeof x === "number") return Number.isInteger(x) ? c.int(x) : c.decimal(x);
+  if (typeof x === "boolean") return c.bool(x);
+  return x;
+};
+var slotted = (name, argNames, required, capped = true) => (...args) => {
+  const surface = LAMBDA_CODE_FILTERS[name]?.surface;
+  const body = (x) => surface === void 0 ? x : toLambdaValue(x, surface, `fl.${name}`);
+  const first = args[0];
+  const isNamed = args.length === 1 && typeof first === "object" && first !== null && !Array.isArray(first) && !isTaggedValue(first);
+  if (!isNamed) {
+    const supplied = args.map(body);
+    const got = supplied.filter((a) => a !== void 0).length;
+    assertArity(name, argNames, required, got);
+    if (capped) assertMaxArity(name, argNames, got);
+    return filter(name, ...supplied.map(v));
+  }
+  const named = Object.fromEntries(
+    Object.entries(first).map(([k, x]) => [k, body(x)])
+  );
+  const unknownArg = Object.keys(named).find((k) => !argNames.includes(k));
+  if (unknownArg !== void 0) {
+    throw new Error(
+      `fl.${name} has no argument \`${unknownArg}\` \u2014 it takes ${argNames.length === 0 ? "none" : argNames.join(", ")}. A name the filter does not declare is dropped rather than sent, so this would read as an omission instead of a typo. (issue #47)`
+    );
+  }
+  const last = argNames.reduce((acc, n, i) => named[n] !== void 0 ? i : acc, -1);
+  const hole = argNames.slice(0, last).findIndex((n) => named[n] === void 0);
+  if (hole !== -1) {
+    throw new Error(
+      `fl.${name}: \`${argNames[hole]}\` is omitted but \`${argNames[last]}\` is supplied. Filter arguments are positional even in this form \u2014 the engine reads them by slot, so one in the middle cannot be skipped. Supply \`${argNames[hole]}\` too. (issue #221)`
+    );
+  }
+  assertArity(name, argNames, required, last + 1);
+  return filter(name, ...argNames.map((n) => v(named[n])));
+};
+var assertArity = (name, argNames, required, got) => {
+  if (got >= required) return;
+  throw new Error(
+    `fl.${name} needs ${required} argument(s) \u2014 ${argNames.slice(0, required).join(", ")} \u2014 but got ${got}. Filter arguments are positional and the engine refuses a short call, so a missing one cannot be inferred \u2014 not even where the filter's own documentation calls it optional. Some filters accept omission from the END and some require every argument regardless; which is which is probed, not declared. (issues #221, #246)`
+  );
+};
+var assertMaxArity = (name, argNames, got) => {
+  if (got <= argNames.length) return;
+  throw new Error(
+    `fl.${name} takes ${argNames.length} argument(s) \u2014 ${argNames.join(", ")} \u2014 but got ${got}. The extra one is not sent anywhere useful: it rides into the filter's arg list, where the engine either ignores it or fails opaquely at runtime. Drop it, or \u2014 if this filter really does accept more than the catalog declares \u2014 write it untyped as \`filter("${name}", \u2026)\`. (issue #47)`
+  );
+};
+var FILTER_NAMES = ["abs", "acos", "acosh", "add", "addslashes", "append", "array_diff", "array_diff_assoc", "array_entries", "array_fill", "array_fill_keys", "array_intersect", "array_intersect_assoc", "array_keys", "array_merge", "array_merge_recursive", "array_pop", "array_push", "array_remove", "array_shift", "array_shuffle", "array_slice", "array_unshift", "array_values", "asin", "asinh", "atan", "atanh", "avg", "base64_decode", "base64_decode_urlsafe", "base64_encode", "base64_encode_urlsafe", "base_convert", "bin2hex", "bindec", "bitwise_and", "bitwise_not", "bitwise_or", "bitwise_xor", "capitalize", "ceil", "concat", "contains", "convert_encoding", "cos", "count", "create_object", "create_object_from_entries", "crypto_jwe_decode", "crypto_jwe_encode", "crypto_jws_decode", "crypto_jws_encode", "csv_create", "csv_decode", "csv_encode", "csv_parse", "decbin", "dechex", "decoct", "decrypt", "deg2rad", "detect_encoding", "div", "empty", "encrypt", "ends_with", "epochms_add_ms", "epochms_add_secs", "epochms_date", "epochms_from_format", "epochms_transform", "eq", "escape", "even", "every", "exp", "filter", "filter_empty", "filter_empty_array", "filter_empty_object", "filter_empty_text", "filter_false", "filter_null", "filter_zero", "find", "findIndex", "first", "first_notempty", "first_notnull", "flatten", "floor", "from_utf8", "fsort", "get", "gt", "gte", "has", "hex2bin", "hexdec", "hmac_md5", "hmac_sha1", "hmac_sha256", "hmac_sha384", "hmac_sha512", "icontains", "iends_with", "in", "index_by", "is_array", "is_bool", "is_decimal", "is_int", "is_object", "is_text", "is_uuid", "istarts_with", "join", "json_decode", "json_encode", "jwe_decode", "jwe_encode", "lambda", "last", "list_encodings", "ln", "log", "log10", "lower", "lt", "lte", "ltrim", "map", "max", "md5", "min", "mod", "mul", "ne", "not", "null", "num_max", "num_min", "number_format", "octdec", "odd", "pick", "pow", "prepend", "product", "querystring_parse", "rad2deg", "range", "reduce", "regex_match", "regex_match_all", "regex_quote", "regex_replace", "regex_test", "reverse", "round", "rtrim", "safe_array", "secureid_decode", "secureid_encode", "set", "set_conditional", "set_ifnotempty", "set_ifnotnull", "sha1", "sha256", "sha384", "sha512", "sin", "some", "sort", "split", "sprintf", "sql_alias", "sql_esc", "sqrt", "starts_with", "string_replace", "strip_accents", "strip_tags", "stripos", "strlen", "strpos", "sub", "substr", "sum", "tan", "text_escape", "text_unescape", "to_bool", "to_decimal", "to_epoch_day", "to_epoch_hour", "to_epoch_minute", "to_epoch_ms", "to_epoch_sec", "to_epochms", "to_expr", "to_int", "to_text", "to_utf8", "transform", "trim", "uid", "unique", "unpick", "unset", "upper", "url_addarg", "url_decode", "url_decode_rfc3986", "url_delarg", "url_encode", "url_encode_rfc3986", "url_getarg", "url_hasarg", "url_parse", "uuid4", "xml_decode", "yaml_decode", "yaml_encode"];
+var FILTER_SPECS = { "deg2rad": { "result": "decimal", "group": "math", "description": "Convert degrees to radians" }, "rad2deg": { "result": "decimal", "group": "math", "description": "Convert radians to degrees" }, "number_format": { "args": [{ "name": "decimals", "type": "int" }, { "name": "decimal_separator", "type": "text" }, { "name": "thousands_separator", "type": "text" }], "result": "string", "group": "math", "description": "Format a number with flexible support over decimal places, thousands separator, and decimal separator." }, "sin": { "result": "decimal", "group": "math", "description": "Calculates the sine of the supplied value in radians" }, "asin": { "result": "decimal", "group": "math", "description": "Calculates the arc sine of the supplied value in radians" }, "asinh": { "result": "decimal", "group": "math", "description": "Calculates the inverse hyperbolic sine of the supplied value in radians" }, "cos": { "result": "decimal", "group": "math", "description": "Calculates the cosine of the supplied value in radians" }, "acos": { "result": "decimal", "group": "math", "description": "Calculates the arc cosine of the supplied value in radians" }, "acosh": { "result": "decimal", "group": "math", "description": "Calculates the inverse hyperbolic cosine of the supplied value in radians" }, "tan": { "result": "decimal", "group": "math", "description": "Calculates the tangent of the supplied value in radians" }, "atan": { "result": "decimal", "group": "math", "description": "Calculates the arc tangent of the supplied value in radians" }, "atanh": { "result": "decimal", "group": "math", "description": "Calculates the inverse hyperbolic tangent of the supplied value in radians" }, "floor": { "result": "int", "group": "math", "description": "Round a decimal down to its integer equivalent" }, "ceil": { "result": "int", "group": "math", "description": "Round a decimal up to its integer equivalent" }, "round": { "args": [{ "name": "precision", "type": "int", "optional": true }], "result": "decimal", "group": "math", "description": "Round a decimal with optional precision" }, "first": { "result": "<T>", "group": "array", "description": "Get the first entry of an array" }, "last": { "result": "<T>", "group": "array", "description": "Get the last entry of an array" }, "count": { "result": "int", "group": "array", "description": "Return the number of items in an object/array" }, "range": { "args": [{ "name": "start", "type": "int" }, { "name": "stop", "type": "int" }], "result": "int[]", "group": "array", "description": "Returns array of values between the specified start/stop." }, "reverse": { "result": "<T>[]", "group": "array", "description": "Returns values of an array in reverse order" }, "unique": { "args": [{ "name": "path", "type": "text", "optional": true }], "result": "<T>[]", "group": "array", "description": "Returns unique values of an array" }, "safe_array": { "result": "<T>[]", "group": "array", "description": "Always returns an array. Uses the existing value if it is an array or creates an array of one element." }, "flatten": { "result": "<T>[]", "group": "array", "description": "Flattens a multidimensional array into a single level array of values." }, "filter_empty": { "args": [{ "name": "path", "type": "text", "optional": true }], "result": "<T>[]", "group": "array", "description": 'Returns a new array with only entries that are not empty ("", null, 0, "0", false, [], {})' }, "filter_empty_text": { "args": [{ "name": "path", "type": "text", "optional": true }], "result": "<T>[]", "group": "array", "description": 'Returns a new array with only entries that are not empty ("", null, 0, "0", false, [], {})' }, "filter_null": { "args": [{ "name": "path", "type": "text", "optional": true }], "result": "<T>[]", "group": "array", "description": "Returns a new array with only entries that are not null" }, "filter_empty_array": { "args": [{ "name": "path", "type": "text", "optional": true }], "result": "<T>[]", "group": "array", "description": "Returns a new array with only entries that are not an empty array `[]`" }, "filter_empty_object": { "args": [{ "name": "path", "type": "text", "optional": true }], "result": "<T>[]", "group": "array", "description": "Returns a new array with only entries that are not an empty object `{}`" }, "filter_zero": { "args": [{ "name": "path", "type": "text", "optional": true }], "result": "<T>[]", "group": "array", "description": "Returns a new array with only entries that are not zero" }, "filter_false": { "args": [{ "name": "path", "type": "text", "optional": true }], "result": "<T>[]", "group": "array", "description": "Returns a new array with only entries that are not false" }, "sort": { "description": "Sort an array of elements with an optional path inside the element", "variadic": true }, "index_by": { "args": [{ "name": "path", "type": "text" }], "result": "{ [key: string]: <T>[] }", "group": "array", "description": "Groups the piped array into an OBJECT keyed by each item's path \u2014 every value is an ARRAY of the items sharing that key, even when only one item does. So a lookup reads `idx[key][0]`, not `idx[key]`; the singular spelling yields null rather than erroring. Items whose path is missing or non-scalar are dropped." }, "append": { "args": [{ "name": "value", "type": "<T>" }, { "name": "path", "type": "text" }], "result": "<T>[]", "group": "array", "description": "Push an element on to the end of an array within an object and return the updated object" }, "prepend": { "args": [{ "name": "value", "type": "<T>" }, { "name": "path", "type": "text" }], "result": "<T>[]", "group": "array", "description": "Push an element on to the beginning of an array within an object and return the updated object" }, "abs": { "result": "decimal", "group": "math", "description": "Returns the absolute value" }, "sqrt": { "result": "decimal", "group": "math", "description": "Returns the square root of the value" }, "exp": { "result": "decimal", "group": "math", "description": 'Returns the exponent of mathematical expression "e"' }, "log": { "args": [{ "name": "base", "type": "<T>" }], "result": "decimal", "group": "math", "description": "Returns the logarithm with a custom base" }, "log10": { "result": "decimal", "group": "math", "description": "Returns the Base-10 logarithm" }, "ln": { "result": "decimal", "group": "math", "description": "Returns the natural logarithm" }, "pow": { "args": [{ "name": "exp", "type": "<T>" }], "result": "decimal", "group": "math", "description": "Returns the value raised to the power of exp." }, "min": { "result": "decimal", "group": "math", "description": "Returns the min of the values of the array" }, "max": { "result": "decimal", "group": "math", "description": "Returns the max of the values of the array" }, "sum": { "result": "decimal", "group": "math", "description": "Returns the sum of the values of the array" }, "avg": { "result": "decimal", "group": "math", "description": "Returns the average of the values of the array" }, "product": { "result": "decimal", "group": "math", "description": "Returns the product of the values of the array" }, "odd": { "result": "bool", "group": "comparison", "description": "Returns whether or not the value is odd" }, "even": { "result": "bool", "group": "comparison", "description": "Returns whether or not the value is even" }, "in": { "args": [{ "name": "search", "type": "<T>" }], "result": "bool", "group": "comparison", "description": "Returns whether or not the value is in the array" }, "add": { "args": [{ "name": "value", "type": "decimal" }], "result": "decimal", "group": "math", "description": "Add 2 values together and return the answer" }, "bitwise_and": { "args": [{ "name": "value", "type": "int" }], "result": "int", "group": "math", "description": "Bitwise AND 2 values together and return the answer" }, "bitwise_or": { "args": [{ "name": "value", "type": "int" }], "result": "int", "group": "math", "description": "Bitwise OR 2 values together and return the answer" }, "bitwise_xor": { "args": [{ "name": "value", "type": "int" }], "result": "int", "group": "math", "description": "Bitwise XOR 2 values together and return the answer" }, "not": { "result": "bool", "group": "comparison", "description": "Returns the opposite of the existing value evaluated as a boolean" }, "bitwise_not": { "result": "bool", "group": "comparison", "description": "Returns the existing value with its bits flipped" }, "is_object": { "result": "bool", "group": "comparison", "description": "Returns whether or not the value is an object." }, "is_array": { "result": "bool", "group": "comparison", "description": "Returns whether or not the value is a numerical indexed array." }, "is_int": { "result": "bool", "group": "comparison", "description": "Returns whether or not the value is an integer." }, "is_decimal": { "result": "bool", "group": "comparison", "description": "Returns whether or not the value is a decimal value." }, "is_bool": { "result": "bool", "group": "comparison", "description": "Returns whether or not the value is a boolean." }, "is_text": { "result": "bool", "group": "comparison", "description": "Returns whether or not the value is text." }, "addslashes": { "result": "text", "group": "text", "description": "Adds a backslash to the following characters: single quote, double quote, backslash, and null character." }, "escape": { "result": "text", "group": "text", "description": "Converts special characters into their escaped variants. Ex: for tabs and" }, "list_encodings": { "result": "text[]", "group": "text", "description": "List support character encodings" }, "detect_encoding": { "args": [{ "name": "encodings", "type": "text", "optional": true }], "result": "text", "group": "text", "description": "Detect the character encoding of the supplied text" }, "to_utf8": { "result": "text", "group": "text", "description": "Convert the supplied text from its binary form (ISO-8859-1) to UTF-8." }, "from_utf8": { "result": "text", "group": "text", "description": "Convert the supplied text from UTF-8 to its binary form (ISO-8859-1)." }, "convert_encoding": { "args": [{ "name": "to", "type": "text" }, { "name": "from", "type": "text" }], "result": "text", "group": "text", "description": "Convert the character encoding of the supplied text" }, "trim": { "args": [{ "name": "mask", "type": "text", "optional": true }], "result": "text", "group": "text", "description": "Trim whitespace or other characters from both sides and return the result" }, "ltrim": { "args": [{ "name": "mask", "type": "text", "optional": true }], "result": "text", "group": "text", "description": "Trim whitespace or other characters from the left side and return the result" }, "rtrim": { "args": [{ "name": "mask", "type": "text", "optional": true }], "result": "text", "group": "text", "description": "Trim whitespace or other characters from the right return the result" }, "capitalize": { "result": "text", "group": "text", "description": "Converts the first letter of each word to a capital letter" }, "substr": { "args": [{ "name": "start", "type": "int" }, { "name": "length", "type": "int" }], "result": "text", "group": "text", "description": "Extracts a section of text" }, "split": { "args": [{ "name": "separator", "type": "text" }], "result": "text[]", "group": "text", "description": "Splits text into an array of text and returns the result" }, "join": { "args": [{ "name": "separator", "type": "text" }], "result": "text", "group": "array", "description": "Joins an array into a text string via the separator and returns the result" }, "strlen": { "result": "int", "group": "text", "description": "Returns the number of characters" }, "starts_with": { "args": [{ "name": "search", "type": "text" }], "result": "bool", "group": "text", "description": "Returns whether or not the expression is present at the beginning Direction: the piped value is the subject text; the argument is the substring searched for." }, "istarts_with": { "args": [{ "name": "search", "type": "text" }], "result": "bool", "group": "text", "description": "Returns whether or not the case-insensitive expression is present at the beginning Direction: the piped value is the subject text; the argument is the substring searched for." }, "ends_with": { "args": [{ "name": "search", "type": "text" }], "result": "bool", "group": "text", "description": "Returns whether or not the expression is present at the end Direction: the piped value is the subject text; the argument is the substring searched for." }, "iends_with": { "args": [{ "name": "search", "type": "text" }], "result": "bool", "group": "text", "description": "Returns whether or not the case-insensitive expression is present at the end Direction: the piped value is the subject text; the argument is the substring searched for." }, "contains": { "args": [{ "name": "search", "type": "text" }], "result": "bool", "group": "text", "description": "Returns whether or not the expression is found Direction: the piped value is the subject text; the argument is the substring searched for." }, "icontains": { "args": [{ "name": "search", "type": "text" }], "result": "bool", "group": "text", "description": "Returns whether or not the case-insensitive expression is found Direction: the piped value is the subject text; the argument is the substring searched for." }, "set": { "args": [{ "name": "path", "type": "text" }, { "name": "value", "type": "any" }], "result": "any", "group": "manipulation", "description": "Sets a value at the path within the object and returns the updated object" }, "set_conditional": { "args": [{ "name": "path", "type": "text" }, { "name": "value", "type": "any" }, { "name": "conditional", "type": "any" }], "result": "any", "group": "manipulation", "description": "Sets a value at the path within the object and returns the updated object, if the conditional expression is true" }, "set_ifnotempty": { "args": [{ "name": "path", "type": "text" }, { "name": "value", "type": "any" }], "result": "any", "group": "manipulation", "description": 'Sets a value (if it is not empty: "", null, 0, "0", false, [], {}) at the path within the object and returns the updated object' }, "set_ifnotnull": { "args": [{ "name": "path", "type": "text" }, { "name": "value", "type": "any" }], "result": "any", "group": "manipulation", "description": "Sets a value (if it is not null) at the path within the object and returns the updated object" }, "first_notnull": { "args": [{ "name": "value", "type": "any" }], "result": "any", "group": "manipulation", "description": "Returns the first value that is not null" }, "first_notempty": { "args": [{ "name": "value", "type": "any" }], "result": "any", "group": "manipulation", "description": 'Returns the first value that is not empty - i.e. not ("", null, 0, "0", false, [], {})' }, "unset": { "args": [{ "name": "path", "type": "text" }], "result": "any", "group": "manipulation", "description": "Removes a value at the path within the object and returns the updated object" }, "transform": { "args": [{ "name": "expression", "type": "text" }], "result": "any", "group": "manipulation", "description": 'Evaluates a Xano Expression Engine expression over the piped value. NOT a JavaScript body \u2014 there is no `return`, and the piped value binds POSITIONALLY as `$0` (or `$$`), NOT as `$this` (which resolves to null here, yielding a wrong answer with no error). `$var`, `$input`, `$env` and `$auth` also resolve, and filters may be piped inside the expression: `$0 * 2`, `$0|sort|join:","`, `{ id: $0.id, total: $0.qty * $0.price }`. PARENTHESIZE a pipe used inside an object/array literal \u2014 `{ s: ($0|sort|join:",") }` \u2014 or the filter argument\'s comma is read as the key separator, returning null and silently dropping every later key. For JavaScript use fl.lambda, whose body does bind `$this`.' }, "get": { "args": [{ "name": "path", "type": "text" }, { "name": "default", "type": "json", "optional": true }], "result": "any", "group": "manipulation", "description": "Returns the value of an object at the specified path" }, "has": { "args": [{ "name": "path", "type": "text" }], "result": "bool", "group": "manipulation", "description": "Returns the existence of whether or not something is present in the object at the specified path" }, "to_expr": { "result": "any", "group": "transform", "description": "Treats the PIPED TEXT as Xano Expression Engine source, evaluates it, and returns the result. Takes no argument. `$var`, `$input`, `$env` and `$auth` resolve inside it; there is no operand binding (`$0` is null) because the operand IS the source. For an expression OVER a value, use fl.transform." }, "to_text": { "result": "text", "group": "transform", "description": "Converts integer, decimal, or bool types to text and returns the result" }, "to_int": { "result": "int", "group": "transform", "description": "Converts text, decimal, or bool types to an integer and returns the result" }, "to_decimal": { "result": "decimal", "group": "transform", "description": "Converts text, integer, or bool types to a decimal and returns the result" }, "to_bool": { "result": "bool", "group": "transform", "description": "Converts text, integer, or decimal types to a bool and returns the result" }, "create_object": { "args": [{ "name": "values", "type": "<T>[]" }], "result": "any", "group": "transform", "description": "Creates an object based on a list of keys and a list of values" }, "create_object_from_entries": { "result": "any", "group": "transform", "description": "Creates an object based on an array of key/value pairs. (i.e. same result as the entries filter)" }, "json_decode": { "result": "any", "group": "transform", "description": "Decodes the value represented as json and returns the result" }, "json_encode": { "result": "text", "group": "transform", "description": "Encodes the value and returns the result as json text" }, "xml_decode": { "result": "any", "group": "transform", "description": "Decodes XML and returns the result" }, "csv_parse": { "args": [{ "name": "separator", "type": "text" }, { "name": "enclosure", "type": "text" }, { "name": "escape", "type": "text" }], "result": "any", "group": "transform", "description": "Parse the contents of a CSV file and convert it into an array of objects." }, "csv_decode": { "args": [{ "name": "separator", "type": "text" }, { "name": "enclosure", "type": "text" }, { "name": "escape", "type": "text" }], "result": "any", "group": "transform", "description": "Decodes the value represented in the CSV format and returns the result" }, "csv_encode": { "args": [{ "name": "separator", "type": "text" }, { "name": "enclosure", "type": "text" }, { "name": "escape", "type": "text" }], "result": "text", "group": "transform", "description": "Encodes the value and returns the result in CSV format Writes NO header row \u2014 values only. Each row contributes its own values in THAT row's key order, with no normalization across rows, so rows whose keys differ in order or count silently misalign columns rather than erroring. Non-scalar cells (nested objects/arrays) are JSON-encoded into the cell, and `false` writes as empty. If the piped array's elements are scalars rather than objects, the whole array is treated as ONE row and you get a single line. For a header, use `csv_create`." }, "csv_create": { "args": [{ "name": "rows", "type": "text[]" }, { "name": "separator", "type": "text" }, { "name": "enclosure", "type": "text" }, { "name": "escape", "type": "text" }], "result": "text", "group": "transform", "description": "Creates a CSV format data stream from a list of column names and their corresponding data rows. Direction: the piped value is the list of COLUMN NAMES (written as the header line); the `rows` argument carries the data rows. This is the header-writing counterpart to `csv_encode`, which emits values only." }, "url_decode": { "result": "text", "group": "transform", "description": "Decodes the value represented as a url encoded value" }, "url_decode_rfc3986": { "result": "text", "group": "transform", "description": "Decodes the value represented as a url encoded value using the RFC 3986 specification" }, "url_encode": { "result": "text", "group": "transform", "description": "Encodes the value and returns the result as a url encoded value" }, "url_encode_rfc3986": { "result": "text", "group": "transform", "description": "Encodes the value and returns the result as a url encoded value using the RFC 3986 specification" }, "url_addarg": { "args": [{ "name": "key", "type": "text" }, { "name": "value", "type": "text" }, { "name": "encoding_rfc3986", "type": "bool", "optional": true }], "result": "text", "group": "text", "description": "Parses a URL and returns an updated version with an encoded version of the supplied argument" }, "url_delarg": { "args": [{ "name": "key", "type": "text" }], "result": "text", "group": "text", "description": "Parses a URL and returns an updated version with the supplied argument removed" }, "url_hasarg": { "args": [{ "name": "key", "type": "text" }], "result": "text", "group": "text", "description": "Returns the existence of a argument in the URL" }, "url_getarg": { "args": [{ "name": "key", "type": "text" }, { "name": "default", "type": "text", "optional": true }], "result": "text", "group": "text", "description": "Gets the argument's value from a URL" }, "url_parse": { "result": "json", "group": "text", "description": "Parses a URL into its individual components." }, "querystring_parse": { "result": "json", "group": "text", "description": "Parses a query string from a URL into its individual key-value pairs." }, "yaml_decode": { "result": "obj", "group": "transform", "description": "Decodes the value represented as yaml and returns the result" }, "yaml_encode": { "result": "text", "group": "transform", "description": "Encodes the value and returns the result as yaml text" }, "hex2bin": { "result": "text", "group": "transform", "description": "Converts a hex value into its binary equivalent" }, "bin2hex": { "result": "text", "group": "transform", "description": "Converts a binary value into its hex equivalent" }, "dechex": { "result": "text", "group": "transform", "description": "Converts a decimal value into its hex equivalent" }, "hexdec": { "result": "text", "group": "transform", "description": "Converts a hex value into its decimal equivalent" }, "decbin": { "result": "text", "group": "transform", "description": "Converts a decimal value into its binary string (i.e. 01010) equivalent" }, "bindec": { "result": "text", "group": "transform", "description": "Converts a binary string (i.e. 01010) into its decimal equivalent" }, "decoct": { "result": "text", "group": "transform", "description": "Converts a decimal value into its octal equivalent" }, "octdec": { "result": "text", "group": "transform", "description": "Converts an octal value into its decimal equivalent" }, "base_convert": { "args": [{ "name": "from_base", "type": "any" }, { "name": "to_base", "type": "any" }], "result": "text", "group": "transform", "description": "Converts a value between two bases" }, "base64_decode": { "result": "text", "group": "transform", "description": "Decodes the value represented as base64 text and returns the result" }, "base64_encode": { "result": "text", "group": "transform", "description": "Encodes the value and returns the result as base64 text" }, "base64_decode_urlsafe": { "result": "text", "group": "transform", "description": "Decodes the value represented as base64 urlsafe text and returns the result" }, "base64_encode_urlsafe": { "result": "text", "group": "transform", "description": "Encodes the value and returns the result as base64 urlsafe text" }, "encrypt": { "args": [{ "name": "algorithm", "type": "enum" }, { "name": "key", "type": "text" }, { "name": "iv", "type": "text" }], "result": "text", "group": "security", "description": "Encrypts the value and returns the result in raw binary form." }, "decrypt": { "args": [{ "name": "algorithm", "type": "enum" }, { "name": "key", "type": "text" }, { "name": "iv", "type": "text" }], "result": "text", "group": "security", "description": "Decrypts the value and returns the result." }, "jwe_encode": { "description": "Encodes the value and return the result as a JWE token", "args": [{ "name": "arg1", "type": "any" }] }, "jwe_decode": { "description": "Decodes the JWE token and return the result", "args": [{ "name": "arg1", "type": "any" }] }, "concat": { "args": [{ "name": "value", "type": "any" }], "result": "text", "group": "text", "description": "Concatenates two values together" }, "sprintf": { "result": "text", "group": "text", "description": "formats text with variable substitution", "variadic": true }, "secureid_encode": { "args": [{ "name": "salt", "type": "text" }], "result": "text", "group": "security", "description": "Returns an encrypted version of the id" }, "secureid_decode": { "args": [{ "name": "salt", "type": "text" }], "result": "int", "group": "security", "description": "Returns the id of the original encode" }, "md5": { "args": [{ "name": "raw", "type": "bool", "optional": true }], "result": "text", "group": "security", "description": "Returns a MD5 signature representation of the value" }, "sha1": { "args": [{ "name": "raw", "type": "bool", "optional": true }], "result": "text", "group": "security", "description": "Returns a SHA1 signature representation of the value" }, "sha256": { "args": [{ "name": "raw", "type": "bool", "optional": true }], "result": "text", "group": "security", "description": "Returns a SHA256 signature representation of the value" }, "sha384": { "args": [{ "name": "raw", "type": "bool", "optional": true }], "result": "text", "group": "security", "description": "Returns a SHA384 signature representation of the value" }, "sha512": { "args": [{ "name": "raw", "type": "bool", "optional": true }], "result": "text", "group": "security", "description": "Returns a SHA512 signature representation of the value" }, "hmac_md5": { "args": [{ "name": "key", "type": "text" }, { "name": "raw", "type": "bool", "optional": true }], "result": "text", "group": "security", "description": "Returns a MD5 signature representation of the value using a shared secret via the HMAC method" }, "hmac_sha1": { "args": [{ "name": "key", "type": "text" }, { "name": "raw", "type": "bool", "optional": true }], "result": "text", "group": "security", "description": "Returns a SHA1 signature representation of the value using a shared secret via the HMAC method" }, "hmac_sha256": { "args": [{ "name": "key", "type": "text" }, { "name": "raw", "type": "bool", "optional": true }], "result": "text", "group": "security", "description": "Returns a SHA256 signature representation of the value using a shared secret via the HMAC method" }, "hmac_sha384": { "args": [{ "name": "key", "type": "text" }, { "name": "raw", "type": "bool", "optional": true }], "result": "text", "group": "security", "description": "Returns a SHA384 signature representation of the value using a shared secret via the HMAC method" }, "hmac_sha512": { "args": [{ "name": "key", "type": "text" }, { "name": "raw", "type": "bool", "optional": true }], "result": "text", "group": "security", "description": "Returns a SHA512 signature representation of the value using a shared secret via the HMAC method" }, "regex_quote": { "args": [{ "name": "delimiter", "type": "text", "optional": true }], "result": "text", "group": "text", "description": "Update the supplied text value to be properly escaped for regular expressions." }, "regex_replace": { "args": [{ "name": "replacement", "type": "text" }, { "name": "subject", "type": "text" }], "result": "text", "group": "text", "description": "Perform a regular expression search and replace on the supplied subject text. Direction: the piped value is the regex PATTERN; the `subject` argument is the text tested against it \u2014 reversed vs starts_with/contains. Build the pattern with c.regex(...) (delimiter-wrapped); a bare c.text(...) is rejected." }, "map": { "args": [{ "name": "code", "type": "text" }, { "name": "timeout", "type": "int", "optional": true }], "result": "any[]", "group": "array", "description": "Creates a new array with the results of calling a provided function on every element in the calling array." }, "filter": { "args": [{ "name": "code", "type": "text" }, { "name": "timeout", "type": "int", "optional": true }], "result": "any[]", "group": "array", "description": "Filters the elements of an array based on the code block returning true to keep the element or false to skip it." }, "some": { "args": [{ "name": "code", "type": "text" }, { "name": "timeout", "type": "int", "optional": true }], "result": "any[]", "group": "array", "description": "Checks if at least one element in the array passes the test implemented by the provided function." }, "every": { "args": [{ "name": "code", "type": "text" }, { "name": "timeout", "type": "int", "optional": true }], "result": "any[]", "group": "array", "description": "Checks if all elements in the array pass the test implemented by the provided function." }, "find": { "args": [{ "name": "code", "type": "text" }, { "name": "timeout", "type": "int", "optional": true }], "result": "any[]", "group": "array", "description": "Finds if all elements in the array pass the test implemented by the provided function." }, "findIndex": { "args": [{ "name": "code", "type": "text" }, { "name": "timeout", "type": "int", "optional": true }], "result": "any[]", "group": "array", "description": "Finds the index of the first element in the array that passes the test implemented by the provided function." }, "reduce": { "args": [{ "name": "initial_value", "type": "int" }, { "name": "code", "type": "text" }, { "name": "timeout", "type": "int", "optional": true }], "result": "any[]", "group": "array", "description": "Reduces the array to a single value using the code block to combine each element of the array." }, "pick": { "args": [{ "name": "keys", "type": "text" }], "result": "<T>", "group": "array", "description": "Pick keys from the object to create a new object of just those keys." }, "unpick": { "args": [{ "name": "keys", "type": "text" }], "result": "<T>", "group": "array", "description": "Remove keys from the object to create a new object of the remaining keys." }, "text_unescape": { "result": "text", "group": "text", "description": "Convert escaped sequences into their raw form. Ex: \\n becomes a newline, \\t becomes a tab." }, "text_escape": { "result": "text", "group": "text", "description": "Converts control characters into their escaped sequences. Ex: newlines as \\n, tabs as \\t" }, "sql_esc": { "result": "text", "group": "text", "description": "Wraps text in single quotes and escapes any single quotes within the text to prevent SQL injection attacks. This is useful for safely inserting user input into values within SQL queries." }, "sql_alias": { "result": "text", "group": "text", "description": "Wraps text in double quotes and escapes any double quotes within the text to prevent SQL injection attacks. This is useful for safely inserting user input into table names or aliases within SQL queries." }, "is_uuid": { "result": "bool", "group": "comparison", "description": "Returns whether or not the value is a valid UUID." }, "lambda": { "args": [{ "name": "code", "type": "text" }, { "name": "timeout", "type": "int", "optional": true }], "result": "any", "group": "transform", "description": "Business logic using JavaScript." }, "lower": { "result": "text", "group": "text", "description": "Converts all characters to lower case and returns the result" }, "upper": { "result": "text", "group": "text", "description": "Converts all characters to upper case and returns the result" }, "sub": { "args": [{ "name": "value", "type": "decimal" }], "result": "decimal", "group": "math", "description": "Subtracts 2 values together and returns the answer" }, "mul": { "args": [{ "name": "value", "type": "decimal" }], "result": "decimal", "group": "math", "description": "Multiplies 2 values together and returns the answer" }, "div": { "args": [{ "name": "value", "type": "decimal" }], "result": "decimal", "group": "math", "description": "Divides 2 values together and returns the answer" }, "fsort": { "args": [{ "name": "path", "type": "text", "optional": true }, { "name": "type", "type": "enum", "optional": true, "enum": ["text", "itext", "natural", "inatural", "number"] }, { "name": "asc", "type": "bool", "optional": true }], "result": "<T>[]", "group": "array", "description": 'Sort an array of elements with an optional path inside the element Only `type: "number"` compares NUMERICALLY. "text"/"itext" are case-sensitive/insensitive string compares, "natural"/"inatural" are the human-readable "a2 < a10" orderings, and the default is "itext". An unrecognized spelling silently falls through to "itext" rather than erroring, so a numeric sort MUST spell "number" \u2014 anything else returns the right elements in the wrong order. `path` drills into each element.' }, "array_shuffle": { "result": "<T>[]", "group": "array", "description": "Shuffles the order of the entries in the array." }, "array_diff": { "args": [{ "name": "value", "type": "<T>[]" }], "result": "<T>[]", "group": "array", "description": "Return the entries from the first array that are not in the second" }, "array_diff_assoc": { "args": [{ "name": "value", "type": "<T>[]" }], "result": "<T>[]", "group": "array", "description": "Return the entries from the first array that are not in the second" }, "array_intersect": { "args": [{ "name": "value", "type": "<T>[]" }], "result": "<T>[]", "group": "array", "description": "Return the entries from the first array that are also present in" }, "array_intersect_assoc": { "args": [{ "name": "value", "type": "<T>[]" }], "result": "<T>[]", "group": "array", "description": "Return the entries from the first array that are also present in" }, "array_merge": { "args": [{ "name": "value", "type": "<T>[]" }], "result": "<T>[]", "group": "array", "description": "Merge the first level of elements of both arrays together and" }, "array_merge_recursive": { "args": [{ "name": "value", "type": "<T>[]" }], "result": "<T>[]", "group": "array", "description": "Merge the elements from all levels of both arrays together and" }, "array_push": { "args": [{ "name": "value", "type": "<T>" }], "result": "<T>[]", "group": "array", "description": "Push an element on to the end of an array and return the new array" }, "array_pop": { "result": "<T>", "group": "array", "description": "Pops the last element of the array off and returns it" }, "array_unshift": { "args": [{ "name": "value", "type": "<T>" }], "result": "<T>[]", "group": "array", "description": "Push an element to the beginning of an array and return the new array" }, "array_shift": { "result": "<T>", "group": "array", "description": "Shifts the first element of the array off and returns it" }, "array_remove": { "args": [{ "name": "value", "type": "<T>" }, { "name": "path", "type": "text" }, { "name": "strict", "type": "bool", "optional": true }], "result": "<T>[]", "group": "array", "description": "Remove any elements from the array that match the supplied value" }, "num_min": { "args": [{ "name": "value", "type": "any" }], "result": "decimal", "group": "math", "description": "Returns the min both values" }, "num_max": { "args": [{ "name": "value", "type": "any" }], "result": "decimal", "group": "math", "description": "Returns the max both values" }, "eq": { "args": [{ "name": "value", "type": "<T>" }], "result": "bool", "group": "comparison", "description": "Returns a boolean if both values are equal" }, "ne": { "args": [{ "name": "value", "type": "<T>" }], "result": "bool", "group": "comparison", "description": "Returns a boolean if both values are not equal" }, "gt": { "args": [{ "name": "value", "type": "<T>" }], "result": "bool", "group": "comparison", "description": "Returns a boolean if the left value is greater than the right value" }, "gte": { "args": [{ "name": "value", "type": "<T>" }], "result": "bool", "group": "comparison", "description": "Returns a boolean if the left value is greater than or equal to the" }, "lt": { "args": [{ "name": "value", "type": "<T>" }], "result": "bool", "group": "comparison", "description": "Returns a boolean if the left value is less than the right value" }, "lte": { "args": [{ "name": "value", "type": "<T>" }], "result": "bool", "group": "comparison", "description": "Returns a boolean if the left value is less than or equal to the right value" }, "mod": { "args": [{ "name": "value", "type": "int" }], "result": "int", "group": "math", "description": "Modulus 2 values together and return the answer" }, "empty": { "result": "bool", "group": "comparison", "description": 'Returns whether or not the value is empty ("", null, 0, "0", false, [], {})' }, "array_slice": { "args": [{ "name": "offset", "type": "int" }, { "name": "length", "type": "int", "optional": true }], "result": "<T>[]", "group": "array", "description": "Extract a section from an array." }, "strip_tags": { "args": [{ "name": "exclude", "type": "text", "optional": true }], "result": "text", "group": "text", "description": "Removes HTML tags from a string" }, "strip_accents": { "result": "text", "group": "text", "description": "Removes accents from characters" }, "strpos": { "args": [{ "name": "search", "type": "text" }], "result": "int", "group": "text", "description": "Returns the index of the case-sensitive expression or false if it" }, "stripos": { "args": [{ "name": "search", "type": "text" }], "result": "int", "group": "text", "description": "Returns the index of the case-insensitive expression or false if it" }, "array_fill": { "args": [{ "name": "start", "type": "int" }, { "name": "count", "type": "int" }], "result": "any[]", "group": "manipulation", "description": "Create an array of a certain size with a default value." }, "array_fill_keys": { "args": [{ "name": "keys", "type": "any[]" }], "result": "any[]", "group": "manipulation", "description": "Create an array of keys with a default value." }, "array_keys": { "result": "text[]", "group": "array", "description": "Get the property keys of an object/array as a numerically indexed array." }, "array_values": { "result": "any[]", "group": "array", "description": "Get the property values of an object/array as a numerically indexed array" }, "array_entries": { "result": "any[]", "group": "array", "description": "Get the property entries of an object/array as a numerically" }, "to_epochms": { "args": [{ "name": "timezone", "type": "text", "optional": true }], "result": "epochms", "group": "transform", "description": "Converts a text expression (now, next friday, Jan 1 2000) to" }, "to_epoch_ms": { "args": [{ "name": "timezone", "type": "text", "optional": true }], "result": "int", "group": "transform", "description": "Converts a text expression (now, next friday, Jan 1 2000) to the" }, "to_epoch_sec": { "args": [{ "name": "timezone", "type": "text", "optional": true }], "result": "int", "group": "transform", "description": "Converts a text expression (now, next friday, Jan 1 2000) to the" }, "to_epoch_minute": { "args": [{ "name": "timezone", "type": "text", "optional": true }], "result": "int", "group": "transform", "description": "Converts a text expression (now, next friday, Jan 1 2000) to the" }, "to_epoch_hour": { "args": [{ "name": "timezone", "type": "text", "optional": true }], "result": "int", "group": "transform", "description": "Converts a text expression (now, next friday, Jan 1 2000) to the" }, "to_epoch_day": { "args": [{ "name": "timezone", "type": "text", "optional": true }], "result": "int", "group": "transform", "description": "Converts a text expression (now, next friday, Jan 1 2000) to the" }, "crypto_jws_encode": { "args": [{ "name": "headers", "type": "json" }, { "name": "key", "type": "json" }, { "name": "algorithm", "type": "enum" }, { "name": "ttl", "type": "int", "optional": true }], "result": "text", "group": "security", "description": "Encodes the value and return the result as a JWS token" }, "crypto_jws_decode": { "args": [{ "name": "check_claims", "type": "json" }, { "name": "key", "type": "json" }, { "name": "algorithm", "type": "enum" }, { "name": "timeDrift", "type": "int", "optional": true }], "result": "json", "group": "security", "description": "Decodes the JWS token and return the result" }, "crypto_jwe_encode": { "args": [{ "name": "headers", "type": "json" }, { "name": "key", "type": "json" }, { "name": "key_algorithm", "type": "enum" }, { "name": "content_algorithm", "type": "enum" }, { "name": "ttl", "type": "int", "optional": true }], "result": "text", "group": "security", "description": "Encodes the value and return the result as a JWE token" }, "crypto_jwe_decode": { "args": [{ "name": "check_claims", "type": "json" }, { "name": "key", "type": "json" }, { "name": "key_algorithm", "type": "enum" }, { "name": "content_algorithm", "type": "enum" }, { "name": "timeDrift", "type": "int", "optional": true }], "result": "json", "group": "security", "description": "Decodes the JWE token and return the result" }, "string_replace": { "args": [{ "name": "search", "type": "text" }, { "name": "replacement", "type": "text" }], "result": "text", "group": "text", "description": "Replace a text phrase with another" }, "uid": { "result": "int", "group": "security", "description": "Returns a unique 64bit unsigned int value seeded off the value" }, "uuid4": { "result": "text", "group": "security", "description": "Returns a universally unique identifier" }, "epochms_from_format": { "args": [{ "name": "format", "type": "text" }, { "name": "timezone", "type": "text", "optional": true }], "result": "text", "group": "timestamp", "description": "Parse a timestamp from a flexible format." }, "epochms_date": { "args": [{ "name": "format", "type": "text" }, { "name": "timezone", "type": "text", "optional": true }], "result": "text", "group": "timestamp", "description": "Converts a timestamp into a human readable formatted date based on" }, "epochms_transform": { "args": [{ "name": "format", "type": "text" }, { "name": "timezone", "type": "text", "optional": true }], "result": "text", "group": "timestamp", "description": "Takes a timestamp and applies a relative transformation to it. Ex." }, "epochms_add_secs": { "args": [{ "name": "seconds", "type": "int" }], "result": "epochms", "group": "timestamp", "description": "Add seconds to a timestamp. (negative values are ok)" }, "epochms_add_ms": { "args": [{ "name": "milliseconds", "type": "int" }], "result": "epochms", "group": "timestamp", "description": "Add milliseconds to a timestamp. (negative values are ok)" }, "regex_test": { "args": [{ "name": "subject", "type": "text" }], "result": "bool", "group": "text", "description": "Tests if a regular expression matches the supplied subject text. Direction: the piped value is the regex PATTERN; the `subject` argument is the text tested against it \u2014 reversed vs starts_with/contains. Build the pattern with c.regex(...) (delimiter-wrapped); a bare c.text(...) is rejected." }, "regex_match": { "args": [{ "name": "subject", "type": "text" }], "result": "text[]", "group": "text", "description": "Return the first set of matches performed by a regular expression Direction: the piped value is the regex PATTERN; the `subject` argument is the text tested against it \u2014 reversed vs starts_with/contains. Build the pattern with c.regex(...) (delimiter-wrapped); a bare c.text(...) is rejected." }, "regex_match_all": { "args": [{ "name": "subject", "type": "text" }], "result": "text[]", "group": "text", "description": "Return all matches performed by a regular expression on the Direction: the piped value is the regex PATTERN; the `subject` argument is the text tested against it \u2014 reversed vs starts_with/contains. Build the pattern with c.regex(...) (delimiter-wrapped); a bare c.text(...) is rejected." }, "null": { "result": "null", "group": "misc", "description": "Returns a null value." } };
+var FILTER_REQUIRED_ARGS = { "add": 1, "append": 2, "array_diff": 1, "array_diff_assoc": 1, "array_fill": 2, "array_fill_keys": 1, "array_intersect": 1, "array_intersect_assoc": 1, "array_merge": 1, "array_merge_recursive": 1, "array_push": 1, "array_remove": 2, "array_slice": 1, "array_unshift": 1, "base_convert": 2, "bitwise_and": 1, "bitwise_or": 1, "bitwise_xor": 1, "concat": 1, "contains": 1, "convert_encoding": 2, "create_object": 1, "crypto_jwe_decode": 4, "crypto_jwe_encode": 4, "crypto_jws_decode": 3, "crypto_jws_encode": 3, "csv_create": 4, "csv_decode": 3, "csv_encode": 3, "csv_parse": 3, "decrypt": 3, "div": 1, "encrypt": 3, "ends_with": 1, "epochms_add_ms": 1, "epochms_add_secs": 1, "epochms_date": 1, "epochms_from_format": 1, "epochms_transform": 1, "eq": 1, "every": 1, "filter": 1, "find": 1, "findIndex": 1, "first_notempty": 1, "first_notnull": 1, "get": 1, "gt": 1, "gte": 1, "has": 1, "hmac_md5": 1, "hmac_sha1": 1, "hmac_sha256": 1, "hmac_sha384": 1, "hmac_sha512": 1, "icontains": 1, "iends_with": 1, "in": 1, "index_by": 1, "istarts_with": 1, "join": 1, "jwe_decode": 1, "jwe_encode": 1, "lambda": 1, "log": 1, "lt": 1, "lte": 1, "map": 1, "mod": 1, "mul": 1, "ne": 1, "num_max": 1, "num_min": 1, "number_format": 3, "pick": 1, "pow": 1, "prepend": 2, "range": 2, "reduce": 2, "regex_match": 1, "regex_match_all": 1, "regex_replace": 2, "regex_test": 1, "secureid_decode": 1, "secureid_encode": 1, "set": 2, "set_conditional": 3, "set_ifnotempty": 2, "set_ifnotnull": 2, "some": 1, "split": 1, "starts_with": 1, "string_replace": 2, "stripos": 1, "strpos": 1, "sub": 1, "substr": 2, "transform": 1, "unpick": 1, "unset": 1, "url_addarg": 2, "url_delarg": 1, "url_getarg": 1, "url_hasarg": 1 };
+var fl = {
+  "abs": (
+    /** Returns the absolute value (group: math, result: decimal) */
+    () => filter("abs")
+  ),
+  "acos": (
+    /** Calculates the arc cosine of the supplied value in radians (group: math, result: decimal) */
+    () => filter("acos")
+  ),
+  "acosh": (
+    /** Calculates the inverse hyperbolic cosine of the supplied value in radians (group: math, result: decimal) */
+    () => filter("acosh")
+  ),
+  "add": (
+    /** Add 2 values together and return the answer (group: math, result: decimal) */
+    slotted("add", ["value"], 1)
+  ),
+  "addslashes": (
+    /** Adds a backslash to the following characters: single quote, double quote, backslash, and null character. (group: text, result: text) */
+    () => filter("addslashes")
+  ),
+  "append": (
+    /** Push an element on to the end of an array within an object and return the updated object (group: array, result: <T>[]) */
+    slotted("append", ["value", "path"], 2)
+  ),
+  "array_diff": (
+    /** Return the entries from the first array that are not in the second (group: array, result: <T>[]) */
+    slotted("array_diff", ["value"], 1)
+  ),
+  "array_diff_assoc": (
+    /** Return the entries from the first array that are not in the second (group: array, result: <T>[]) */
+    slotted("array_diff_assoc", ["value"], 1)
+  ),
+  "array_entries": (
+    /** Get the property entries of an object/array as a numerically (group: array, result: any[]) */
+    () => filter("array_entries")
+  ),
+  "array_fill": (
+    /** Create an array of a certain size with a default value. (group: manipulation, result: any[]) */
+    slotted("array_fill", ["start", "count"], 2)
+  ),
+  "array_fill_keys": (
+    /** Create an array of keys with a default value. (group: manipulation, result: any[]) */
+    slotted("array_fill_keys", ["keys"], 1)
+  ),
+  "array_intersect": (
+    /** Return the entries from the first array that are also present in (group: array, result: <T>[]) */
+    slotted("array_intersect", ["value"], 1)
+  ),
+  "array_intersect_assoc": (
+    /** Return the entries from the first array that are also present in (group: array, result: <T>[]) */
+    slotted("array_intersect_assoc", ["value"], 1)
+  ),
+  "array_keys": (
+    /** Get the property keys of an object/array as a numerically indexed array. (group: array, result: text[]) */
+    () => filter("array_keys")
+  ),
+  "array_merge": (
+    /** Merge the first level of elements of both arrays together and (group: array, result: <T>[]) */
+    slotted("array_merge", ["value"], 1, false)
+  ),
+  "array_merge_recursive": (
+    /** Merge the elements from all levels of both arrays together and (group: array, result: <T>[]) */
+    slotted("array_merge_recursive", ["value"], 1, false)
+  ),
+  "array_pop": (
+    /** Pops the last element of the array off and returns it (group: array, result: <T>) */
+    () => filter("array_pop")
+  ),
+  "array_push": (
+    /** Push an element on to the end of an array and return the new array (group: array, result: <T>[]) */
+    slotted("array_push", ["value"], 1)
+  ),
+  "array_remove": (
+    /** Remove any elements from the array that match the supplied value (group: array, result: <T>[]) */
+    slotted("array_remove", ["value", "path", "strict"], 2)
+  ),
+  "array_shift": (
+    /** Shifts the first element of the array off and returns it (group: array, result: <T>) */
+    () => filter("array_shift")
+  ),
+  "array_shuffle": (
+    /** Shuffles the order of the entries in the array. (group: array, result: <T>[]) */
+    () => filter("array_shuffle")
+  ),
+  "array_slice": (
+    /** Extract a section from an array. (group: array, result: <T>[]) */
+    slotted("array_slice", ["offset", "length"], 1)
+  ),
+  "array_unshift": (
+    /** Push an element to the beginning of an array and return the new array (group: array, result: <T>[]) */
+    slotted("array_unshift", ["value"], 1)
+  ),
+  "array_values": (
+    /** Get the property values of an object/array as a numerically indexed array (group: array, result: any[]) */
+    () => filter("array_values")
+  ),
+  "asin": (
+    /** Calculates the arc sine of the supplied value in radians (group: math, result: decimal) */
+    () => filter("asin")
+  ),
+  "asinh": (
+    /** Calculates the inverse hyperbolic sine of the supplied value in radians (group: math, result: decimal) */
+    () => filter("asinh")
+  ),
+  "atan": (
+    /** Calculates the arc tangent of the supplied value in radians (group: math, result: decimal) */
+    () => filter("atan")
+  ),
+  "atanh": (
+    /** Calculates the inverse hyperbolic tangent of the supplied value in radians (group: math, result: decimal) */
+    () => filter("atanh")
+  ),
+  "avg": (
+    /** Returns the average of the values of the array (group: math, result: decimal) */
+    () => filter("avg")
+  ),
+  "base64_decode": (
+    /** Decodes the value represented as base64 text and returns the result (group: transform, result: text) */
+    () => filter("base64_decode")
+  ),
+  "base64_decode_urlsafe": (
+    /** Decodes the value represented as base64 urlsafe text and returns the result (group: transform, result: text) */
+    () => filter("base64_decode_urlsafe")
+  ),
+  "base64_encode": (
+    /** Encodes the value and returns the result as base64 text (group: transform, result: text) */
+    () => filter("base64_encode")
+  ),
+  "base64_encode_urlsafe": (
+    /** Encodes the value and returns the result as base64 urlsafe text (group: transform, result: text) */
+    () => filter("base64_encode_urlsafe")
+  ),
+  "base_convert": (
+    /** Converts a value between two bases (group: transform, result: text) */
+    slotted("base_convert", ["from_base", "to_base"], 2)
+  ),
+  "bin2hex": (
+    /** Converts a binary value into its hex equivalent (group: transform, result: text) */
+    () => filter("bin2hex")
+  ),
+  "bindec": (
+    /** Converts a binary string (i.e. 01010) into its decimal equivalent (group: transform, result: text) */
+    () => filter("bindec")
+  ),
+  "bitwise_and": (
+    /** Bitwise AND 2 values together and return the answer (group: math, result: int) */
+    slotted("bitwise_and", ["value"], 1)
+  ),
+  "bitwise_not": (
+    /** Returns the existing value with its bits flipped (group: comparison, result: bool) */
+    () => filter("bitwise_not")
+  ),
+  "bitwise_or": (
+    /** Bitwise OR 2 values together and return the answer (group: math, result: int) */
+    slotted("bitwise_or", ["value"], 1)
+  ),
+  "bitwise_xor": (
+    /** Bitwise XOR 2 values together and return the answer (group: math, result: int) */
+    slotted("bitwise_xor", ["value"], 1)
+  ),
+  "capitalize": (
+    /** Converts the first letter of each word to a capital letter (group: text, result: text) */
+    () => filter("capitalize")
+  ),
+  "ceil": (
+    /** Round a decimal up to its integer equivalent (group: math, result: int) */
+    () => filter("ceil")
+  ),
+  "concat": (
+    /** Concatenates two values together (group: text, result: text) */
+    slotted("concat", ["value"], 1, false)
+  ),
+  "contains": (
+    /** Returns whether or not the expression is found Direction: the piped value is the subject text; the argument is the substring searched for. (group: text, result: bool) */
+    slotted("contains", ["search"], 1)
+  ),
+  "convert_encoding": (
+    /** Convert the character encoding of the supplied text (group: text, result: text) */
+    slotted("convert_encoding", ["to", "from"], 2)
+  ),
+  "cos": (
+    /** Calculates the cosine of the supplied value in radians (group: math, result: decimal) */
+    () => filter("cos")
+  ),
+  "count": (
+    /** Return the number of items in an object/array (group: array, result: int) */
+    () => filter("count")
+  ),
+  "create_object": (
+    /** Creates an object based on a list of keys and a list of values (group: transform, result: any) */
+    slotted("create_object", ["values"], 1)
+  ),
+  "create_object_from_entries": (
+    /** Creates an object based on an array of key/value pairs. (i.e. same result as the entries filter) (group: transform, result: any) */
+    () => filter("create_object_from_entries")
+  ),
+  "crypto_jwe_decode": (
+    /** Decodes the JWE token and return the result (group: security, result: json) */
+    slotted("crypto_jwe_decode", ["check_claims", "key", "key_algorithm", "content_algorithm", "timeDrift"], 4)
+  ),
+  "crypto_jwe_encode": (
+    /** Encodes the value and return the result as a JWE token (group: security, result: text) */
+    slotted("crypto_jwe_encode", ["headers", "key", "key_algorithm", "content_algorithm", "ttl"], 4)
+  ),
+  "crypto_jws_decode": (
+    /** Decodes the JWS token and return the result (group: security, result: json) */
+    slotted("crypto_jws_decode", ["check_claims", "key", "algorithm", "timeDrift"], 3)
+  ),
+  "crypto_jws_encode": (
+    /** Encodes the value and return the result as a JWS token (group: security, result: text) */
+    slotted("crypto_jws_encode", ["headers", "key", "algorithm", "ttl"], 3)
+  ),
+  "csv_create": (
+    /** Creates a CSV format data stream from a list of column names and their corresponding data rows. Direction: the piped value is the list of COLUMN NAMES (written as the header line); the `rows` argument carries the data rows. This is the header-writing counterpart to `csv_encode`, which emits values only. (group: transform, result: text) */
+    slotted("csv_create", ["rows", "separator", "enclosure", "escape"], 4)
+  ),
+  "csv_decode": (
+    /** Decodes the value represented in the CSV format and returns the result (group: transform, result: any) */
+    slotted("csv_decode", ["separator", "enclosure", "escape"], 3)
+  ),
+  "csv_encode": (
+    /** Encodes the value and returns the result in CSV format Writes NO header row — values only. Each row contributes its own values in THAT row's key order, with no normalization across rows, so rows whose keys differ in order or count silently misalign columns rather than erroring. Non-scalar cells (nested objects/arrays) are JSON-encoded into the cell, and `false` writes as empty. If the piped array's elements are scalars rather than objects, the whole array is treated as ONE row and you get a single line. For a header, use `csv_create`. (group: transform, result: text) */
+    slotted("csv_encode", ["separator", "enclosure", "escape"], 3)
+  ),
+  "csv_parse": (
+    /** Parse the contents of a CSV file and convert it into an array of objects. (group: transform, result: any) */
+    slotted("csv_parse", ["separator", "enclosure", "escape"], 3)
+  ),
+  "decbin": (
+    /** Converts a decimal value into its binary string (i.e. 01010) equivalent (group: transform, result: text) */
+    () => filter("decbin")
+  ),
+  "dechex": (
+    /** Converts a decimal value into its hex equivalent (group: transform, result: text) */
+    () => filter("dechex")
+  ),
+  "decoct": (
+    /** Converts a decimal value into its octal equivalent (group: transform, result: text) */
+    () => filter("decoct")
+  ),
+  "decrypt": (
+    /** Decrypts the value and returns the result. (group: security, result: text) */
+    slotted("decrypt", ["algorithm", "key", "iv"], 3)
+  ),
+  "deg2rad": (
+    /** Convert degrees to radians (group: math, result: decimal) */
+    () => filter("deg2rad")
+  ),
+  "detect_encoding": (
+    /** Detect the character encoding of the supplied text (group: text, result: text) */
+    slotted("detect_encoding", ["encodings"], 0)
+  ),
+  "div": (
+    /** Divides 2 values together and returns the answer (group: math, result: decimal) */
+    slotted("div", ["value"], 1)
+  ),
+  "empty": (
+    /** Returns whether or not the value is empty ("", null, 0, "0", false, [], {}) (group: comparison, result: bool) */
+    () => filter("empty")
+  ),
+  "encrypt": (
+    /** Encrypts the value and returns the result in raw binary form. (group: security, result: text) */
+    slotted("encrypt", ["algorithm", "key", "iv"], 3)
+  ),
+  "ends_with": (
+    /** Returns whether or not the expression is present at the end Direction: the piped value is the subject text; the argument is the substring searched for. (group: text, result: bool) */
+    slotted("ends_with", ["search"], 1)
+  ),
+  "epochms_add_ms": (
+    /** Add milliseconds to a timestamp. (negative values are ok) (group: timestamp, result: epochms) */
+    slotted("epochms_add_ms", ["milliseconds"], 1)
+  ),
+  "epochms_add_secs": (
+    /** Add seconds to a timestamp. (negative values are ok) (group: timestamp, result: epochms) */
+    slotted("epochms_add_secs", ["seconds"], 1)
+  ),
+  "epochms_date": (
+    /** Converts a timestamp into a human readable formatted date based on (group: timestamp, result: text) */
+    slotted("epochms_date", ["format", "timezone"], 1)
+  ),
+  "epochms_from_format": (
+    /** Parse a timestamp from a flexible format. (group: timestamp, result: text) */
+    slotted("epochms_from_format", ["format", "timezone"], 1)
+  ),
+  "epochms_transform": (
+    /** Takes a timestamp and applies a relative transformation to it. Ex. (group: timestamp, result: text) */
+    slotted("epochms_transform", ["format", "timezone"], 1)
+  ),
+  "eq": (
+    /** Returns a boolean if both values are equal (group: comparison, result: bool) */
+    slotted("eq", ["value"], 1)
+  ),
+  "escape": (
+    /** Converts special characters into their escaped variants. Ex: for tabs and (group: text, result: text) */
+    () => filter("escape")
+  ),
+  "even": (
+    /** Returns whether or not the value is even (group: comparison, result: bool) */
+    () => filter("even")
+  ),
+  "every": (
+    /** Checks if all elements in the array pass the test implemented by the provided function. (group: array, result: any[]) */
+    slotted("every", ["code", "timeout"], 1)
+  ),
+  "exp": (
+    /** Returns the exponent of mathematical expression "e" (group: math, result: decimal) */
+    () => filter("exp")
+  ),
+  "filter": (
+    /** Filters the elements of an array based on the code block returning true to keep the element or false to skip it. (group: array, result: any[]) */
+    slotted("filter", ["code", "timeout"], 1)
+  ),
+  "filter_empty": (
+    /** Returns a new array with only entries that are not empty ("", null, 0, "0", false, [], {}) (group: array, result: <T>[]) */
+    slotted("filter_empty", ["path"], 0)
+  ),
+  "filter_empty_array": (
+    /** Returns a new array with only entries that are not an empty array `[]` (group: array, result: <T>[]) */
+    slotted("filter_empty_array", ["path"], 0)
+  ),
+  "filter_empty_object": (
+    /** Returns a new array with only entries that are not an empty object `{}` (group: array, result: <T>[]) */
+    slotted("filter_empty_object", ["path"], 0)
+  ),
+  "filter_empty_text": (
+    /** Returns a new array with only entries that are not empty ("", null, 0, "0", false, [], {}) (group: array, result: <T>[]) */
+    slotted("filter_empty_text", ["path"], 0)
+  ),
+  "filter_false": (
+    /** Returns a new array with only entries that are not false (group: array, result: <T>[]) */
+    slotted("filter_false", ["path"], 0)
+  ),
+  "filter_null": (
+    /** Returns a new array with only entries that are not null (group: array, result: <T>[]) */
+    slotted("filter_null", ["path"], 0)
+  ),
+  "filter_zero": (
+    /** Returns a new array with only entries that are not zero (group: array, result: <T>[]) */
+    slotted("filter_zero", ["path"], 0)
+  ),
+  "find": (
+    /** Finds if all elements in the array pass the test implemented by the provided function. (group: array, result: any[]) */
+    slotted("find", ["code", "timeout"], 1)
+  ),
+  "findIndex": (
+    /** Finds the index of the first element in the array that passes the test implemented by the provided function. (group: array, result: any[]) */
+    slotted("findIndex", ["code", "timeout"], 1)
+  ),
+  "first": (
+    /** Get the first entry of an array (group: array, result: <T>) */
+    () => filter("first")
+  ),
+  "first_notempty": (
+    /** Returns the first value that is not empty - i.e. not ("", null, 0, "0", false, [], {}) (group: manipulation, result: any) */
+    slotted("first_notempty", ["value"], 1)
+  ),
+  "first_notnull": (
+    /** Returns the first value that is not null (group: manipulation, result: any) */
+    slotted("first_notnull", ["value"], 1)
+  ),
+  "flatten": (
+    /** Flattens a multidimensional array into a single level array of values. (group: array, result: <T>[]) */
+    () => filter("flatten")
+  ),
+  "floor": (
+    /** Round a decimal down to its integer equivalent (group: math, result: int) */
+    () => filter("floor")
+  ),
+  "from_utf8": (
+    /** Convert the supplied text from UTF-8 to its binary form (ISO-8859-1). (group: text, result: text) */
+    () => filter("from_utf8")
+  ),
+  "fsort": (
+    /** Sort an array of elements with an optional path inside the element Only `type: "number"` compares NUMERICALLY. "text"/"itext" are case-sensitive/insensitive string compares, "natural"/"inatural" are the human-readable "a2 < a10" orderings, and the default is "itext". An unrecognized spelling silently falls through to "itext" rather than erroring, so a numeric sort MUST spell "number" — anything else returns the right elements in the wrong order. `path` drills into each element. (group: array, result: <T>[]) */
+    slotted("fsort", ["path", "type", "asc"], 0)
+  ),
+  "get": (
+    /** Returns the value of an object at the specified path (group: manipulation, result: any) */
+    slotted("get", ["path", "default_"], 1, false)
+  ),
+  "gt": (
+    /** Returns a boolean if the left value is greater than the right value (group: comparison, result: bool) */
+    slotted("gt", ["value"], 1)
+  ),
+  "gte": (
+    /** Returns a boolean if the left value is greater than or equal to the (group: comparison, result: bool) */
+    slotted("gte", ["value"], 1)
+  ),
+  "has": (
+    /** Returns the existence of whether or not something is present in the object at the specified path (group: manipulation, result: bool) */
+    slotted("has", ["path"], 1)
+  ),
+  "hex2bin": (
+    /** Converts a hex value into its binary equivalent (group: transform, result: text) */
+    () => filter("hex2bin")
+  ),
+  "hexdec": (
+    /** Converts a hex value into its decimal equivalent (group: transform, result: text) */
+    () => filter("hexdec")
+  ),
+  "hmac_md5": (
+    /** Returns a MD5 signature representation of the value using a shared secret via the HMAC method (group: security, result: text) */
+    slotted("hmac_md5", ["key", "raw"], 1)
+  ),
+  "hmac_sha1": (
+    /** Returns a SHA1 signature representation of the value using a shared secret via the HMAC method (group: security, result: text) */
+    slotted("hmac_sha1", ["key", "raw"], 1)
+  ),
+  "hmac_sha256": (
+    /** Returns a SHA256 signature representation of the value using a shared secret via the HMAC method (group: security, result: text) */
+    slotted("hmac_sha256", ["key", "raw"], 1)
+  ),
+  "hmac_sha384": (
+    /** Returns a SHA384 signature representation of the value using a shared secret via the HMAC method (group: security, result: text) */
+    slotted("hmac_sha384", ["key", "raw"], 1)
+  ),
+  "hmac_sha512": (
+    /** Returns a SHA512 signature representation of the value using a shared secret via the HMAC method (group: security, result: text) */
+    slotted("hmac_sha512", ["key", "raw"], 1)
+  ),
+  "icontains": (
+    /** Returns whether or not the case-insensitive expression is found Direction: the piped value is the subject text; the argument is the substring searched for. (group: text, result: bool) */
+    slotted("icontains", ["search"], 1)
+  ),
+  "iends_with": (
+    /** Returns whether or not the case-insensitive expression is present at the end Direction: the piped value is the subject text; the argument is the substring searched for. (group: text, result: bool) */
+    slotted("iends_with", ["search"], 1)
+  ),
+  "in": (
+    /** Returns whether or not the value is in the array (group: comparison, result: bool) */
+    slotted("in", ["search"], 1)
+  ),
+  "index_by": (
+    /** Groups the piped array into an OBJECT keyed by each item's path — every value is an ARRAY of the items sharing that key, even when only one item does. So a lookup reads `idx[key][0]`, not `idx[key]`; the singular spelling yields null rather than erroring. Items whose path is missing or non-scalar are dropped. (group: array, result: { [key: string]: <T>[] }) */
+    slotted("index_by", ["path"], 1, false)
+  ),
+  "is_array": (
+    /** Returns whether or not the value is a numerical indexed array. (group: comparison, result: bool) */
+    () => filter("is_array")
+  ),
+  "is_bool": (
+    /** Returns whether or not the value is a boolean. (group: comparison, result: bool) */
+    () => filter("is_bool")
+  ),
+  "is_decimal": (
+    /** Returns whether or not the value is a decimal value. (group: comparison, result: bool) */
+    () => filter("is_decimal")
+  ),
+  "is_int": (
+    /** Returns whether or not the value is an integer. (group: comparison, result: bool) */
+    () => filter("is_int")
+  ),
+  "is_object": (
+    /** Returns whether or not the value is an object. (group: comparison, result: bool) */
+    () => filter("is_object")
+  ),
+  "is_text": (
+    /** Returns whether or not the value is text. (group: comparison, result: bool) */
+    () => filter("is_text")
+  ),
+  "is_uuid": (
+    /** Returns whether or not the value is a valid UUID. (group: comparison, result: bool) */
+    () => filter("is_uuid")
+  ),
+  "istarts_with": (
+    /** Returns whether or not the case-insensitive expression is present at the beginning Direction: the piped value is the subject text; the argument is the substring searched for. (group: text, result: bool) */
+    slotted("istarts_with", ["search"], 1)
+  ),
+  "join": (
+    /** Joins an array into a text string via the separator and returns the result (group: array, result: text) */
+    slotted("join", ["separator"], 1)
+  ),
+  "json_decode": (
+    /** Decodes the value represented as json and returns the result (group: transform, result: any) */
+    () => filter("json_decode")
+  ),
+  "json_encode": (
+    /** Encodes the value and returns the result as json text (group: transform, result: text) */
+    () => filter("json_encode")
+  ),
+  "jwe_decode": (
+    /** Decodes the JWE token and return the result */
+    slotted("jwe_decode", ["arg1"], 1, false)
+  ),
+  "jwe_encode": (
+    /** Encodes the value and return the result as a JWE token */
+    slotted("jwe_encode", ["arg1"], 1, false)
+  ),
+  "lambda": (
+    /** Business logic using JavaScript. (group: transform, result: any) */
+    slotted("lambda", ["code", "timeout"], 1)
+  ),
+  "last": (
+    /** Get the last entry of an array (group: array, result: <T>) */
+    () => filter("last")
+  ),
+  "list_encodings": (
+    /** List support character encodings (group: text, result: text[]) */
+    () => filter("list_encodings")
+  ),
+  "ln": (
+    /** Returns the natural logarithm (group: math, result: decimal) */
+    () => filter("ln")
+  ),
+  "log": (
+    /** Returns the logarithm with a custom base (group: math, result: decimal) */
+    slotted("log", ["base"], 1)
+  ),
+  "log10": (
+    /** Returns the Base-10 logarithm (group: math, result: decimal) */
+    () => filter("log10")
+  ),
+  "lower": (
+    /** Converts all characters to lower case and returns the result (group: text, result: text) */
+    () => filter("lower")
+  ),
+  "lt": (
+    /** Returns a boolean if the left value is less than the right value (group: comparison, result: bool) */
+    slotted("lt", ["value"], 1)
+  ),
+  "lte": (
+    /** Returns a boolean if the left value is less than or equal to the right value (group: comparison, result: bool) */
+    slotted("lte", ["value"], 1)
+  ),
+  "ltrim": (
+    /** Trim whitespace or other characters from the left side and return the result (group: text, result: text) */
+    slotted("ltrim", ["mask"], 0)
+  ),
+  "map": (
+    /** Creates a new array with the results of calling a provided function on every element in the calling array. (group: array, result: any[]) */
+    slotted("map", ["code", "timeout"], 1)
+  ),
+  "max": (
+    /** Returns the max of the values of the array (group: math, result: decimal) */
+    () => filter("max")
+  ),
+  "md5": (
+    /** Returns a MD5 signature representation of the value (group: security, result: text) */
+    slotted("md5", ["raw"], 0)
+  ),
+  "min": (
+    /** Returns the min of the values of the array (group: math, result: decimal) */
+    () => filter("min")
+  ),
+  "mod": (
+    /** Modulus 2 values together and return the answer (group: math, result: int) */
+    slotted("mod", ["value"], 1)
+  ),
+  "mul": (
+    /** Multiplies 2 values together and returns the answer (group: math, result: decimal) */
+    slotted("mul", ["value"], 1)
+  ),
+  "ne": (
+    /** Returns a boolean if both values are not equal (group: comparison, result: bool) */
+    slotted("ne", ["value"], 1)
+  ),
+  "not": (
+    /** Returns the opposite of the existing value evaluated as a boolean (group: comparison, result: bool) */
+    () => filter("not")
+  ),
+  "null": (
+    /** Returns a null value. (group: misc, result: null) */
+    () => filter("null")
+  ),
+  "num_max": (
+    /** Returns the max both values (group: math, result: decimal) */
+    slotted("num_max", ["value"], 1)
+  ),
+  "num_min": (
+    /** Returns the min both values (group: math, result: decimal) */
+    slotted("num_min", ["value"], 1)
+  ),
+  "number_format": (
+    /** Format a number with flexible support over decimal places, thousands separator, and decimal separator. (group: math, result: string) */
+    slotted("number_format", ["decimals", "decimal_separator", "thousands_separator"], 3)
+  ),
+  "octdec": (
+    /** Converts an octal value into its decimal equivalent (group: transform, result: text) */
+    () => filter("octdec")
+  ),
+  "odd": (
+    /** Returns whether or not the value is odd (group: comparison, result: bool) */
+    () => filter("odd")
+  ),
+  "pick": (
+    /** Pick keys from the object to create a new object of just those keys. (group: array, result: <T>) */
+    slotted("pick", ["keys"], 1)
+  ),
+  "pow": (
+    /** Returns the value raised to the power of exp. (group: math, result: decimal) */
+    slotted("pow", ["exp"], 1)
+  ),
+  "prepend": (
+    /** Push an element on to the beginning of an array within an object and return the updated object (group: array, result: <T>[]) */
+    slotted("prepend", ["value", "path"], 2)
+  ),
+  "product": (
+    /** Returns the product of the values of the array (group: math, result: decimal) */
+    () => filter("product")
+  ),
+  "querystring_parse": (
+    /** Parses a query string from a URL into its individual key-value pairs. (group: text, result: json) */
+    () => filter("querystring_parse")
+  ),
+  "rad2deg": (
+    /** Convert radians to degrees (group: math, result: decimal) */
+    () => filter("rad2deg")
+  ),
+  "range": (
+    /** Returns array of values between the specified start/stop. (group: array, result: int[]) */
+    slotted("range", ["start", "stop"], 2)
+  ),
+  "reduce": (
+    /** Reduces the array to a single value using the code block to combine each element of the array. (group: array, result: any[]) */
+    slotted("reduce", ["initial_value", "code", "timeout"], 2)
+  ),
+  "regex_match": (
+    /** Return the first set of matches performed by a regular expression Direction: the piped value is the regex PATTERN; the `subject` argument is the text tested against it — reversed vs starts_with/contains. Build the pattern with c.regex(...) (delimiter-wrapped); a bare c.text(...) is rejected. (group: text, result: text[]) */
+    slotted("regex_match", ["subject"], 1)
+  ),
+  "regex_match_all": (
+    /** Return all matches performed by a regular expression on the Direction: the piped value is the regex PATTERN; the `subject` argument is the text tested against it — reversed vs starts_with/contains. Build the pattern with c.regex(...) (delimiter-wrapped); a bare c.text(...) is rejected. (group: text, result: text[]) */
+    slotted("regex_match_all", ["subject"], 1)
+  ),
+  "regex_quote": (
+    /** Update the supplied text value to be properly escaped for regular expressions. (group: text, result: text) */
+    slotted("regex_quote", ["delimiter"], 0)
+  ),
+  "regex_replace": (
+    /** Perform a regular expression search and replace on the supplied subject text. Direction: the piped value is the regex PATTERN; the `subject` argument is the text tested against it — reversed vs starts_with/contains. Build the pattern with c.regex(...) (delimiter-wrapped); a bare c.text(...) is rejected. (group: text, result: text) */
+    slotted("regex_replace", ["replacement", "subject"], 2)
+  ),
+  "regex_test": (
+    /** Tests if a regular expression matches the supplied subject text. Direction: the piped value is the regex PATTERN; the `subject` argument is the text tested against it — reversed vs starts_with/contains. Build the pattern with c.regex(...) (delimiter-wrapped); a bare c.text(...) is rejected. (group: text, result: bool) */
+    slotted("regex_test", ["subject"], 1)
+  ),
+  "reverse": (
+    /** Returns values of an array in reverse order (group: array, result: <T>[]) */
+    () => filter("reverse")
+  ),
+  "round": (
+    /** Round a decimal with optional precision (group: math, result: decimal) */
+    slotted("round", ["precision"], 0)
+  ),
+  "rtrim": (
+    /** Trim whitespace or other characters from the right return the result (group: text, result: text) */
+    slotted("rtrim", ["mask"], 0)
+  ),
+  "safe_array": (
+    /** Always returns an array. Uses the existing value if it is an array or creates an array of one element. (group: array, result: <T>[]) */
+    () => filter("safe_array")
+  ),
+  "secureid_decode": (
+    /** Returns the id of the original encode (group: security, result: int) */
+    slotted("secureid_decode", ["salt"], 1)
+  ),
+  "secureid_encode": (
+    /** Returns an encrypted version of the id (group: security, result: text) */
+    slotted("secureid_encode", ["salt"], 1)
+  ),
+  "set": (
+    /** Sets a value at the path within the object and returns the updated object (group: manipulation, result: any) */
+    slotted("set", ["path", "value"], 2)
+  ),
+  "set_conditional": (
+    /** Sets a value at the path within the object and returns the updated object, if the conditional expression is true (group: manipulation, result: any) */
+    slotted("set_conditional", ["path", "value", "conditional"], 3)
+  ),
+  "set_ifnotempty": (
+    /** Sets a value (if it is not empty: "", null, 0, "0", false, [], {}) at the path within the object and returns the updated object (group: manipulation, result: any) */
+    slotted("set_ifnotempty", ["path", "value"], 2)
+  ),
+  "set_ifnotnull": (
+    /** Sets a value (if it is not null) at the path within the object and returns the updated object (group: manipulation, result: any) */
+    slotted("set_ifnotnull", ["path", "value"], 2)
+  ),
+  "sha1": (
+    /** Returns a SHA1 signature representation of the value (group: security, result: text) */
+    slotted("sha1", ["raw"], 0)
+  ),
+  "sha256": (
+    /** Returns a SHA256 signature representation of the value (group: security, result: text) */
+    slotted("sha256", ["raw"], 0)
+  ),
+  "sha384": (
+    /** Returns a SHA384 signature representation of the value (group: security, result: text) */
+    slotted("sha384", ["raw"], 0)
+  ),
+  "sha512": (
+    /** Returns a SHA512 signature representation of the value (group: security, result: text) */
+    slotted("sha512", ["raw"], 0)
+  ),
+  "sin": (
+    /** Calculates the sine of the supplied value in radians (group: math, result: decimal) */
+    () => filter("sin")
+  ),
+  "some": (
+    /** Checks if at least one element in the array passes the test implemented by the provided function. (group: array, result: any[]) */
+    slotted("some", ["code", "timeout"], 1)
+  ),
+  "sort": (
+    /** Sort an array of elements with an optional path inside the element */
+    (...args) => filter("sort", ...args.map(v))
+  ),
+  "split": (
+    /** Splits text into an array of text and returns the result (group: text, result: text[]) */
+    slotted("split", ["separator"], 1)
+  ),
+  "sprintf": (
+    /** formats text with variable substitution (group: text, result: text) */
+    (...args) => filter("sprintf", ...args.map(v))
+  ),
+  "sql_alias": (
+    /** Wraps text in double quotes and escapes any double quotes within the text to prevent SQL injection attacks. This is useful for safely inserting user input into table names or aliases within SQL queries. (group: text, result: text) */
+    () => filter("sql_alias")
+  ),
+  "sql_esc": (
+    /** Wraps text in single quotes and escapes any single quotes within the text to prevent SQL injection attacks. This is useful for safely inserting user input into values within SQL queries. (group: text, result: text) */
+    () => filter("sql_esc")
+  ),
+  "sqrt": (
+    /** Returns the square root of the value (group: math, result: decimal) */
+    () => filter("sqrt")
+  ),
+  "starts_with": (
+    /** Returns whether or not the expression is present at the beginning Direction: the piped value is the subject text; the argument is the substring searched for. (group: text, result: bool) */
+    slotted("starts_with", ["search"], 1)
+  ),
+  "string_replace": (
+    /** Replace a text phrase with another (group: text, result: text) */
+    slotted("string_replace", ["search", "replacement"], 2)
+  ),
+  "strip_accents": (
+    /** Removes accents from characters (group: text, result: text) */
+    () => filter("strip_accents")
+  ),
+  "strip_tags": (
+    /** Removes HTML tags from a string (group: text, result: text) */
+    slotted("strip_tags", ["exclude"], 0)
+  ),
+  "stripos": (
+    /** Returns the index of the case-insensitive expression or false if it (group: text, result: int) */
+    slotted("stripos", ["search"], 1)
+  ),
+  "strlen": (
+    /** Returns the number of characters (group: text, result: int) */
+    () => filter("strlen")
+  ),
+  "strpos": (
+    /** Returns the index of the case-sensitive expression or false if it (group: text, result: int) */
+    slotted("strpos", ["search"], 1)
+  ),
+  "sub": (
+    /** Subtracts 2 values together and returns the answer (group: math, result: decimal) */
+    slotted("sub", ["value"], 1)
+  ),
+  "substr": (
+    /** Extracts a section of text (group: text, result: text) */
+    slotted("substr", ["start", "length"], 2)
+  ),
+  "sum": (
+    /** Returns the sum of the values of the array (group: math, result: decimal) */
+    () => filter("sum")
+  ),
+  "tan": (
+    /** Calculates the tangent of the supplied value in radians (group: math, result: decimal) */
+    () => filter("tan")
+  ),
+  "text_escape": (
+    /** Converts control characters into their escaped sequences. Ex: newlines as \n, tabs as \t (group: text, result: text) */
+    () => filter("text_escape")
+  ),
+  "text_unescape": (
+    /** Convert escaped sequences into their raw form. Ex: \n becomes a newline, \t becomes a tab. (group: text, result: text) */
+    () => filter("text_unescape")
+  ),
+  "to_bool": (
+    /** Converts text, integer, or decimal types to a bool and returns the result (group: transform, result: bool) */
+    () => filter("to_bool")
+  ),
+  "to_decimal": (
+    /** Converts text, integer, or bool types to a decimal and returns the result (group: transform, result: decimal) */
+    () => filter("to_decimal")
+  ),
+  "to_epoch_day": (
+    /** Converts a text expression (now, next friday, Jan 1 2000) to the (group: transform, result: int) */
+    slotted("to_epoch_day", ["timezone"], 0)
+  ),
+  "to_epoch_hour": (
+    /** Converts a text expression (now, next friday, Jan 1 2000) to the (group: transform, result: int) */
+    slotted("to_epoch_hour", ["timezone"], 0)
+  ),
+  "to_epoch_minute": (
+    /** Converts a text expression (now, next friday, Jan 1 2000) to the (group: transform, result: int) */
+    slotted("to_epoch_minute", ["timezone"], 0)
+  ),
+  "to_epoch_ms": (
+    /** Converts a text expression (now, next friday, Jan 1 2000) to the (group: transform, result: int) */
+    slotted("to_epoch_ms", ["timezone"], 0)
+  ),
+  "to_epoch_sec": (
+    /** Converts a text expression (now, next friday, Jan 1 2000) to the (group: transform, result: int) */
+    slotted("to_epoch_sec", ["timezone"], 0)
+  ),
+  "to_epochms": (
+    /** Converts a text expression (now, next friday, Jan 1 2000) to (group: transform, result: epochms) */
+    slotted("to_epochms", ["timezone"], 0)
+  ),
+  "to_expr": (
+    /** Treats the PIPED TEXT as Xano Expression Engine source, evaluates it, and returns the result. Takes no argument. `$var`, `$input`, `$env` and `$auth` resolve inside it; there is no operand binding (`$0` is null) because the operand IS the source. For an expression OVER a value, use fl.transform. (group: transform, result: any) */
+    () => filter("to_expr")
+  ),
+  "to_int": (
+    /** Converts text, decimal, or bool types to an integer and returns the result (group: transform, result: int) */
+    () => filter("to_int")
+  ),
+  "to_text": (
+    /** Converts integer, decimal, or bool types to text and returns the result (group: transform, result: text) */
+    () => filter("to_text")
+  ),
+  "to_utf8": (
+    /** Convert the supplied text from its binary form (ISO-8859-1) to UTF-8. (group: text, result: text) */
+    () => filter("to_utf8")
+  ),
+  "transform": (
+    /** Evaluates a Xano Expression Engine expression over the piped value. NOT a JavaScript body — there is no `return`, and the piped value binds POSITIONALLY as `$0` (or `$$`), NOT as `$this` (which resolves to null here, yielding a wrong answer with no error). `$var`, `$input`, `$env` and `$auth` also resolve, and filters may be piped inside the expression: `$0 * 2`, `$0|sort|join:","`, `{ id: $0.id, total: $0.qty * $0.price }`. PARENTHESIZE a pipe used inside an object/array literal — `{ s: ($0|sort|join:",") }` — or the filter argument's comma is read as the key separator, returning null and silently dropping every later key. For JavaScript use fl.lambda, whose body does bind `$this`. (group: manipulation, result: any) */
+    slotted("transform", ["expression"], 1)
+  ),
+  "trim": (
+    /** Trim whitespace or other characters from both sides and return the result (group: text, result: text) */
+    slotted("trim", ["mask"], 0)
+  ),
+  "uid": (
+    /** Returns a unique 64bit unsigned int value seeded off the value (group: security, result: int) */
+    () => filter("uid")
+  ),
+  "unique": (
+    /** Returns unique values of an array (group: array, result: <T>[]) */
+    slotted("unique", ["path"], 0)
+  ),
+  "unpick": (
+    /** Remove keys from the object to create a new object of the remaining keys. (group: array, result: <T>) */
+    slotted("unpick", ["keys"], 1)
+  ),
+  "unset": (
+    /** Removes a value at the path within the object and returns the updated object (group: manipulation, result: any) */
+    slotted("unset", ["path"], 1)
+  ),
+  "upper": (
+    /** Converts all characters to upper case and returns the result (group: text, result: text) */
+    () => filter("upper")
+  ),
+  "url_addarg": (
+    /** Parses a URL and returns an updated version with an encoded version of the supplied argument (group: text, result: text) */
+    slotted("url_addarg", ["key", "value", "encoding_rfc3986"], 2)
+  ),
+  "url_decode": (
+    /** Decodes the value represented as a url encoded value (group: transform, result: text) */
+    () => filter("url_decode")
+  ),
+  "url_decode_rfc3986": (
+    /** Decodes the value represented as a url encoded value using the RFC 3986 specification (group: transform, result: text) */
+    () => filter("url_decode_rfc3986")
+  ),
+  "url_delarg": (
+    /** Parses a URL and returns an updated version with the supplied argument removed (group: text, result: text) */
+    slotted("url_delarg", ["key"], 1)
+  ),
+  "url_encode": (
+    /** Encodes the value and returns the result as a url encoded value (group: transform, result: text) */
+    () => filter("url_encode")
+  ),
+  "url_encode_rfc3986": (
+    /** Encodes the value and returns the result as a url encoded value using the RFC 3986 specification (group: transform, result: text) */
+    () => filter("url_encode_rfc3986")
+  ),
+  "url_getarg": (
+    /** Gets the argument's value from a URL (group: text, result: text) */
+    slotted("url_getarg", ["key", "default_"], 1)
+  ),
+  "url_hasarg": (
+    /** Returns the existence of a argument in the URL (group: text, result: text) */
+    slotted("url_hasarg", ["key"], 1)
+  ),
+  "url_parse": (
+    /** Parses a URL into its individual components. (group: text, result: json) */
+    () => filter("url_parse")
+  ),
+  "uuid4": (
+    /** Returns a universally unique identifier (group: security, result: text) */
+    () => filter("uuid4")
+  ),
+  "xml_decode": (
+    /** Decodes XML and returns the result (group: transform, result: any) */
+    () => filter("xml_decode")
+  ),
+  "yaml_decode": (
+    /** Decodes the value represented as yaml and returns the result (group: transform, result: obj) */
+    () => filter("yaml_decode")
+  ),
+  "yaml_encode": (
+    /** Encodes the value and returns the result as yaml text (group: transform, result: text) */
+    () => filter("yaml_encode")
+  )
+};
+
+// src/statements/expression.ts
+var SUPPORTED_OPS = ["=", "!=", "===", "!==", ">", "<", ">=", "<="];
+var OP_ALIASES = { "==": "=" };
+function expr(left, op, right) {
+  const normalized = OP_ALIASES[op] ?? op;
+  if (!SUPPORTED_OPS.includes(normalized)) {
+    throw new Error(
+      `Unsupported conditional operator "${op}". Supported: ${SUPPORTED_OPS.join(", ")} (also ==, a synonym for =)`
+    );
+  }
+  return { left, op: normalized, right };
+}
+var SEARCH_OPS = /* @__PURE__ */ new Set([
+  "=",
+  "==",
+  "!=",
+  "===",
+  "!==",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "in",
+  "not in",
+  "like",
+  "not like",
+  "ilike",
+  "not ilike",
+  "~",
+  "!~",
+  "between",
+  "not between",
+  "@>",
+  "contains",
+  "not contains",
+  "includes",
+  "not includes",
+  "overlaps",
+  "not overlaps",
+  "search"
+]);
+function isSearchOp(op) {
+  return typeof op === "string" && SEARCH_OPS.has(op);
+}
+function cmp(left, op, right, opts) {
+  if (!SEARCH_OPS.has(op)) {
+    throw new Error(
+      `unsupported operator "${op}". Supported: ${[...SEARCH_OPS].join(", ")}.`
+    );
+  }
+  return { left, op, right, ignoreEmpty: opts?.ignoreEmpty };
+}
+function and(...children) {
+  return { or: false, children };
+}
+function or(...children) {
+  return { or: true, children };
+}
+function mixed(first, ...rest) {
+  if (rest.length === 0) {
+    throw new Error(
+      "mixed(): needs at least two terms \u2014 a single term has no join to mix. Pass the node on its own, or use and()/or() for a uniform container."
+    );
+  }
+  for (const term of rest) {
+    const keys = Object.keys(term).filter((k) => term[k] !== void 0);
+    if (keys.length !== 1 || keys[0] !== "and" && keys[0] !== "or") {
+      throw new Error(
+        `mixed(): every term after the first is exactly one of \`{ and: node }\` or \`{ or: node }\` \u2014 got ${JSON.stringify(keys)}.`
+      );
+    }
+  }
+  return { mixed: [first, ...rest] };
+}
+function isValue(w) {
+  return typeof w === "object" && w !== null && !Array.isArray(w) && "tag" in w && "value" in w;
+}
+function isGroup(w) {
+  return typeof w === "object" && w !== null && !Array.isArray(w) && "children" in w;
+}
+function isMixed(w) {
+  return typeof w === "object" && w !== null && !Array.isArray(w) && "mixed" in w;
+}
+function containerTerms(node) {
+  if (isMixed(node)) {
+    return node.mixed.map(
+      (term, i) => i === 0 ? { or: false, node: term } : { or: "or" in term, node: "or" in term ? term.or : term.and }
+    );
+  }
+  return node.children.map((child, i) => ({ or: node.or && i > 0, node: child }));
+}
+function isCmpNode(w) {
+  return typeof w === "object" && w !== null && !Array.isArray(w) && "op" in w && "left" in w;
+}
+function toOperand(v2) {
+  return { operand: v2.value, tag: v2.tag, filters: v2.filters };
+}
+function toStatementNode(node, or2) {
+  const right = toOperand(node.right);
+  if (node.ignoreEmpty) right.ignore_empty = true;
+  return {
+    type: "statement",
+    or: or2,
+    group: { expression: [] },
+    statement: { op: node.op, left: toOperand(node.left), right }
+  };
+}
+function encodeContainer(children, joinOr) {
+  return encodeTerms(children.map((child, i) => ({ or: joinOr && i > 0, node: child })));
+}
+function encodeTerms(terms) {
+  return terms.map(({ or: or2, node }) => {
+    if (isGroup(node) || isMixed(node)) {
+      const group = {
+        type: "group",
+        or: or2,
+        group: { expression: encodeTerms(containerTerms(node)) }
+      };
+      return group;
+    }
+    return toStatementNode(node, or2);
+  });
+}
+var MAX_EXPRESSION_DEPTH = 128;
+function assertExpressionDepth(nodes) {
+  const stack = nodes.map((node) => ({ node, depth: 1 }));
+  while (stack.length > 0) {
+    const { node, depth } = stack.pop();
+    if (!isGroup(node) && !isMixed(node)) continue;
+    if (depth > MAX_EXPRESSION_DEPTH) {
+      throw new Error(
+        `condition: expression containers are nested ${depth} levels deep, past the supported limit of ${MAX_EXPRESSION_DEPTH}. Nesting costs quadratic bytes \u2014 every level re-wraps everything below it \u2014 so a deep chain exports megabytes and eventually cannot be walked at all. This is almost always a rule set folded one term at a time (\`rules.reduce((acc, r) => and(acc, r))\`); pass the terms as SIBLINGS of one container instead (\`and(...rules)\` \u2014 flat, linear, unlimited in count), or balance the tree so its depth is logarithmic. Mixing joins? Group each run: \`and(or(...anyOf), ...allOf)\`.`
+      );
+    }
+    for (const term of containerTerms(node)) stack.push({ node: term.node, depth: depth + 1 });
+  }
+}
+function encodeExpression(input2) {
+  const nodes = Array.isArray(input2) ? input2 : [input2];
+  assertExpressionDepth(nodes);
+  const only = nodes.length === 1 ? nodes[0] : void 0;
+  if (only !== void 0 && isGroup(only) && only.or) {
+    return { expression: encodeContainer(only.children, true) };
+  }
+  if (only !== void 0 && isMixed(only)) {
+    return { expression: encodeTerms(containerTerms(only)) };
+  }
+  return { expression: encodeContainer(nodes, false) };
+}
+var RUNTIME_OPS = new Set(SUPPORTED_OPS);
+function isRuntimeConditionOp(op) {
+  return typeof op === "string" && (RUNTIME_OPS.has(op) || op in OP_ALIASES);
+}
+function assertRuntimeOps(node, surface) {
+  if (isGroup(node) || isMixed(node)) {
+    for (const term of containerTerms(node)) assertRuntimeOps(term.node, surface);
+    return;
+  }
+  const op = node.op;
+  if (isRuntimeConditionOp(op)) return;
+  throw new Error(
+    `${surface}: operator "${op}" is a database-search operator and cannot be evaluated in a condition \u2014 the request fails at runtime with \`Invalid op: ${op}\`. A condition evaluates ${SUPPORTED_OPS.join(", ")} (and \`==\`). Keep "${op}" for a db.query/bulk/addon \`where\`, a table view filter, or a database trigger \`search\`; in a condition, spell it out \u2014 e.g. membership as \`or(expr(x, "=", a), expr(x, "=", b))\`.`
+  );
+}
+function encodeRuntimeCondition(input2, surface) {
+  const nodes = Array.isArray(input2) ? input2 : [input2];
+  assertExpressionDepth(nodes);
+  for (const node of nodes) assertRuntimeOps(node, surface);
+  return encodeExpression(input2);
+}
+function encodeComparison(when) {
+  return encodeExpression(when);
+}
+
+// src/statements/conditional.ts
+var CONDITIONAL = "mvp:conditional";
+var CONDITIONAL_ELIF = "mvp:conditional_elif";
+function conditionalElif(args) {
+  const context = {
+    expr: encodeRuntimeCondition(args.when, "s.conditional elif `when`"),
+    if: { run: args.then.map(encodeStatement) }
+  };
+  return annotate({ name: CONDITIONAL_ELIF, context, input: [] }, args);
+}
+function conditional(args) {
+  const context = {
+    expr: encodeRuntimeCondition(args.when, "s.conditional `when`"),
+    if: { run: args.then.map(encodeStatement) },
+    elif: { run: (args.elif ?? []).map((e) => encodeStatement(conditionalElif(e))) },
+    else: { run: (args.else ?? []).map(encodeStatement) }
+  };
+  return annotate({ name: CONDITIONAL, context, input: [] }, args);
+}
+registerStatement(CONDITIONAL, conditional);
+registerStatement(CONDITIONAL_ELIF, conditionalElif);
+
+// src/kinds/test-mocks.ts
+function mockBearingItem(node) {
+  if (node === null || typeof node !== "object" || Array.isArray(node)) return null;
+  const rec = node;
+  if (typeof rec.name !== "string") return null;
+  const mocks = rec.mocks;
+  if (mocks === null || typeof mocks !== "object" || Array.isArray(mocks)) return null;
+  if (Object.keys(mocks).length === 0) return null;
+  return rec;
+}
+function resolveMockKeys(run, tests, ownerKind, ownerName) {
+  const byName = new Map(tests.map((t) => [t.name, t.id]));
+  const rewrite = (item) => {
+    const resolved = {};
+    for (const [testName, entry] of Object.entries(item.mocks)) {
+      const id = byName.get(testName);
+      if (id === void 0) {
+        if (/^[0-9a-f]{32}$/.test(testName)) {
+          resolved[testName] = entry;
+          continue;
+        }
+        throw new Error(
+          `${ownerKind} "${ownerName}": a statement mocks a test named "${testName}", which this object does not declare. ` + (tests.length === 0 ? `It declares no tests at all \u2014 add one to \`tests\`, or drop the mock. ` : `Declared tests: ${tests.map((t) => `"${t.name}"`).join(", ")}. `) + `A mock is stored against a test's id, so a name that matches nothing would deploy clean and then never apply.`
+        );
+      }
+      resolved[id] = entry;
+    }
+    item.mocks = resolved;
+  };
+  const pending = [run];
+  while (pending.length > 0) {
+    const node = pending.pop();
+    if (Array.isArray(node)) {
+      for (const child of node) pending.push(child);
+      continue;
+    }
+    if (node === null || typeof node !== "object") continue;
+    const item = mockBearingItem(node);
+    if (item) rewrite(item);
+    for (const [key, child] of Object.entries(node)) {
+      if (key === "mocks") continue;
+      pending.push(child);
+    }
+  }
+}
+function assertMockKeysResolved(xdo, kindName) {
+  const pending = [xdo];
+  while (pending.length > 0) {
+    const node = pending.pop();
+    if (Array.isArray(node)) {
+      for (const child of node) pending.push(child);
+      continue;
+    }
+    if (node === null || typeof node !== "object") continue;
+    const item = mockBearingItem(node);
+    if (item) {
+      for (const key of Object.keys(item.mocks)) {
+        if (/^[0-9a-f]{32}$/.test(key)) continue;
+        throw new Error(
+          `${kindName} "${String(node.name ?? "")}": a statement carries \`mock: { "${key}": \u2026 }\`, but a ${kindName} does not store unit tests \u2014 only a query, function, or middleware does. A mock is stored against a test's id, so this one would deploy clean and never apply. Move the step into a function that declares the test, or drop the mock.`
+        );
+      }
+    }
+    for (const [key, child] of Object.entries(node)) {
+      if (key === "mocks") continue;
+      pending.push(child);
+    }
+  }
+}
+
+// src/kinds/kind.ts
+var kindRegistry = /* @__PURE__ */ new Map();
+function registerKind(kind) {
+  kindRegistry.set(kind.name, kind);
+}
+function isRegisteredKind(name) {
+  return kindRegistry.has(name);
+}
+function getKind(name) {
+  const kind = kindRegistry.get(name);
+  if (!kind) {
+    throw new Error(
+      `Unknown object kind "${name}". Registered: ${[...kindRegistry.keys()].join(", ") || "(none)"}`
+    );
+  }
+  return kind;
+}
+function encodeObject(name, def) {
+  const xdo = getKind(name).encode(def);
+  assertMockKeysResolved(xdo, name);
+  return xdo;
+}
+function registeredKinds() {
+  return [...kindRegistry.values()];
+}
+
+// src/kinds/common.ts
+function emptyMiddleware() {
+  return { pre_customize: false, post_customize: false, pre: [], post: [] };
+}
+function encodeTags(tags) {
+  return (tags ?? []).map((tag) => ({ tag }));
+}
+var HISTORY_DEFAULT_OFF = /* @__PURE__ */ new Set(["function", "middleware", "trigger", "message"]);
+function defaultHistory(objType, override) {
+  return {
+    inherit: override?.inherit ?? true,
+    enabled: override?.enabled ?? !HISTORY_DEFAULT_OFF.has(objType),
+    limit: override?.limit ?? 100
+  };
+}
+
+// src/kinds/table.ts
+var SCALAR_FAMILY = {
+  bool: "bool",
+  int: "int",
+  epochms: "epochms",
+  decimal: "decimal",
+  text: "text",
+  uuid: "text",
+  email: "text",
+  password: "text",
+  enum: "enum"
+};
+function normalizeIndexType(type) {
+  return type === "unique" ? "btree|unique" : type;
+}
+var SEED_FILE = /* @__PURE__ */ Symbol.for("xanots.seed.file");
+function seedFile(path, base) {
+  return { [SEED_FILE]: { path, base: typeof base === "string" ? base : base.href } };
+}
+function isSeedFileSource(source) {
+  return typeof source === "object" && source !== null && SEED_FILE in source;
+}
+function toColumns(schema) {
+  if (Array.isArray(schema)) return schema;
+  return Object.entries(schema).map(([name, d]) => ({ name, type: d.type, ...d.options }));
+}
+function systemColumns(idType = "int") {
+  return [
+    // A uuid primary key persists NO `default` key — the engine stores it that
+    // way because the value is engine-generated. An `int` key and an ordinary
+    // (non-key) uuid column both carry `default: ""`, so this is specific to the
+    // uuid key. See {@link FieldOptions.noDefault}.
+    // `nullable` is pinned on both, not left to the per-type default: a uuid
+    // column is nullable by default (see NULLABLE_BY_DEFAULT), but a PRIMARY KEY
+    // never is, and every captured `id`/`created_at` stores `nullable: false`.
+    {
+      name: "id",
+      type: idType,
+      required: true,
+      nullable: false,
+      ...idType === "uuid" ? { noDefault: true } : {}
+    },
+    { name: "created_at", type: "epochms", default: "now", access: "private", nullable: false }
+  ];
+}
+function tableColumns(def) {
+  const cols = toColumns(def.schema);
+  if (def.system === false) return cols;
+  const present = new Set(cols.map((col2) => col2.name));
+  const missing = systemColumns(def.idType).filter((sc) => !present.has(sc.name));
+  return [...missing, ...cols];
+}
+function systemIndexes(useXdo = false) {
+  return [
+    { type: "primary", fields: [{ name: "id" }] },
+    ...useXdo ? [{ type: "gin", fields: [{ name: "xdo", op: "jsonb_path_op" }] }] : [],
+    { type: "btree", fields: [{ name: "created_at", op: "desc" }] }
+  ];
+}
+function indexSignature(def) {
+  return `${normalizeIndexType(def.type)}|${def.fields.map((field) => field.name).join(",")}`;
+}
+function tableIndexes(def) {
+  const declared = def.index ?? [];
+  if (def.system === false) return declared;
+  const present = new Set(declared.map(indexSignature));
+  const missing = systemIndexes(def.useXdo).filter((idx) => !present.has(indexSignature(idx)));
+  return [...missing, ...declared];
+}
+var SYSTEM_COLUMN_NAMES = systemColumns().map((col2) => col2.name);
+function elideSystemIndexes(index, useXdo) {
+  const system = systemIndexes(useXdo);
+  const encoded = (list) => JSON.stringify(list.map(encodeIndex));
+  const target = encoded(index);
+  for (const subset of subsetsLargestFirst(system.length)) {
+    const pending = /* @__PURE__ */ new Map();
+    for (const position of subset) {
+      const signature = indexSignature(system[position]);
+      pending.set(signature, (pending.get(signature) ?? 0) + 1);
+    }
+    const kept = index.filter((entry) => {
+      const remaining = pending.get(indexSignature(entry)) ?? 0;
+      if (remaining === 0) return true;
+      pending.set(indexSignature(entry), remaining - 1);
+      return false;
+    });
+    if (kept.length === index.length) continue;
+    if (encoded(tableIndexes({ index: kept, useXdo })) === target) return kept;
+  }
+  return null;
+}
+function subsetsLargestFirst(n) {
+  const all = [];
+  for (let mask = 1; mask < 1 << n; mask += 1) {
+    const members = [];
+    for (let bit = 0; bit < n; bit += 1) if (mask & 1 << bit) members.push(bit);
+    all.push(members);
+  }
+  return all.sort((a, b) => b.length - a.length || a[0] - b[0]);
+}
+function encodeIndex(def) {
+  return {
+    name: def.name ?? "",
+    lang: def.lang ?? "",
+    type: normalizeIndexType(def.type),
+    fields: def.fields.map((field) => ({ name: field.name, op: field.op ?? "" })),
+    market_item: { id: 0, version: 0, guid: "" }
+  };
+}
+function encodeView(def) {
+  return {
+    alias: def.alias ?? "",
+    hiddenCols: def.hide ?? [],
+    id: def.id,
+    name: def.name,
+    q: def.q ?? "",
+    expression: def.where ? encodeComparison(def.where).expression : [],
+    sort: (def.sort ?? []).map((s) => ({ name: s.name, order: s.order }))
+  };
+}
+function encodeColumn(def) {
+  const { name, type, ...options } = def;
+  return encodeField(name, type, options, COLUMN_CONTEXT);
+}
+function assertBmpColumnDefault(tableName, col2) {
+  if (col2.default === void 0) return;
+  for (const ch of String(col2.default)) {
+    const cp = ch.codePointAt(0);
+    if (cp > 65535) {
+      const u = `U+${cp.toString(16).toUpperCase().padStart(4, "0")}`;
+      throw new Error(
+        `table "${tableName}", column "${col2.name}": \`default\` contains a 4-byte character (${JSON.stringify(ch)}, ${u}). The engine mangles such characters into an invalid UTF-8 sequence in the column default, failing at deploy with Postgres 22021 (invalid byte sequence for encoding "UTF8"). Use a default within the Basic Multilingual Plane (accents, most CJK, and \u20AC are fine), or move the value onto an endpoint input (\`input.text({ default })\`), applied at runtime bind. (issue #45)`
+      );
+    }
+  }
+}
+function assertIndexColumns(def) {
+  const known = tableColumns(def).map((col2) => col2.name);
+  const set = /* @__PURE__ */ new Set([...known, "xdo"]);
+  for (const index of def.index ?? []) {
+    for (const field of index.fields) {
+      if (set.has(field.name)) continue;
+      const column = field.name.slice(0, field.name.indexOf("."));
+      if (column !== "" && set.has(column)) continue;
+      const signature = `${normalizeIndexType(index.type)}(${index.fields.map((f2) => f2.name).join(", ")})`;
+      throw new Error(
+        `table "${def.name}", index "${signature}": unknown column "${field.name}" (not in table schema). Known columns: ${known.join(", ")}. An index over a column that does not exist exports cleanly and fails at deploy with an engine error that names neither. (issue #187)`
+      );
+    }
+  }
+}
+function encodeTable(def) {
+  if (!def.name) throw new Error("table: `name` is required.");
+  for (const col2 of tableColumns(def)) assertBmpColumnDefault(def.name, col2);
+  assertIndexColumns(def);
+  return {
+    name: def.name,
+    description: def.description ?? "",
+    docs: def.docs ?? "",
+    auth: def.auth ?? false,
+    install: def.install ?? false,
+    schema: tableColumns(def).map(encodeColumn),
+    index: tableIndexes(def).map(encodeIndex),
+    autocomplete: (def.autocomplete ?? []).map((name) => ({ name })),
+    external: def.external ?? { source: "", id: "" },
+    views: (def.views ?? []).map(encodeView),
+    tag: encodeTags(def.tags),
+    // A table has no `as` — it returns nothing (it's a datastore, not a stack
+    // statement); confirmed 0/16 live `mvp_dbo` rows carry one. (Older golden
+    // export fixtures store `as:<name>`, a stale generation — see normalize.ts.)
+    // `sql_name` is the engine's physical table name; persisted as "" (the
+    // engine derives the real name) — confirmed against live `mvp_dbo`.
+    sql_name: "",
+    use_xdo: def.useXdo ?? false,
+    market_item: { id: 0, version: 0, guid: "" }
+  };
+}
+var tableKind = {
+  name: "table",
+  payloadKey: "dbo",
+  encode: encodeTable
+};
+registerKind(tableKind);
+function table(def) {
+  return def;
+}
+
+// src/responses/response.ts
+function warnUnboundReturn(kind, name, stack, response) {
+  if (response !== void 0) return;
+  if (!stack?.some((statement) => statement?.name === "mvp:return")) return;
+  emitDiagnostic({
+    severity: "warning",
+    code: "response.unbound-return",
+    message: `${kind} "${name}" ends with s.return(...) but has no \`response\` field. The value DOES come back at runtime \u2014 a top-level s.return short-circuits the stack and carries its own value out \u2014 but the stored response envelope is empty, so the shape is invisible to InferResponse, to a typed frontend, and to codegen. Declare it too: \`response: <value>\` (e.g. \`response: ref("...")\`). Where both exist, whichever executes wins \u2014 an early s.return that fires beats the declared response.`
+  });
+}
+function isValue2(x) {
+  return typeof x.tag === "string" && "value" in x && "filters" in x;
+}
+function encodeResponse(response) {
+  if (response === void 0) {
+    return [];
+  }
+  const carried = rawResponseItems(response);
+  if (carried !== void 0) return carried;
+  if (isValue2(response)) {
+    return [
+      { filters: response.filters, name: "", tag: response.tag, value: response.value, _xsid: "", disabled: false }
+    ];
+  }
+  return Object.entries(response).map(([name, member]) => {
+    const value = isValue2(member) ? member : obj(member);
+    return { filters: value.filters, name, tag: value.tag, value: value.value, _xsid: "", disabled: false };
+  });
+}
+
+// src/kinds/history.ts
+var CONTAINER_DEFAULT_ENABLED = {
+  query: true,
+  tool: true,
+  message: false
+};
+var WORKSPACE_HISTORY_TYPES = [
+  "query",
+  "function",
+  "task",
+  "tool",
+  "trigger",
+  "middleware",
+  "message"
+];
+function scalarToEnabledLimit(input2) {
+  if (input2 === false) return { enabled: false, limit: 100 };
+  if (input2 === true) return { enabled: true, limit: 100 };
+  if (input2 === "all") return { enabled: true, limit: -1 };
+  if (!Number.isInteger(input2) || input2 < 0) {
+    throw new Error(
+      `history: a numeric limit must be a non-negative integer (the capture depth), or use "all" for unlimited \u2014 got ${input2}`
+    );
+  }
+  return { enabled: true, limit: input2 };
+}
+function encodeHistory(objType, input2) {
+  if (input2 === void 0) return defaultHistory(objType);
+  const { enabled, limit } = scalarToEnabledLimit(input2);
+  return { inherit: false, enabled, limit };
+}
+function encodeContainerHistory(prefix, input2) {
+  const { inherit, enabled, limit } = input2 === void 0 ? { inherit: true, enabled: CONTAINER_DEFAULT_ENABLED[prefix], limit: 100 } : { inherit: false, ...scalarToEnabledLimit(input2) };
+  return {
+    inherit,
+    [`${prefix}_enabled`]: enabled,
+    [`${prefix}_limit`]: limit
+  };
+}
+function buildWorkspaceHistory(map) {
+  const out2 = {};
+  for (const t of WORKSPACE_HISTORY_TYPES) {
+    const input2 = map[t];
+    const { enabled, limit } = input2 === void 0 ? { enabled: defaultHistory(t).enabled, limit: 100 } : scalarToEnabledLimit(input2);
+    out2[`${t}_enabled`] = enabled;
+    out2[`${t}_limit`] = limit;
+  }
+  return out2;
+}
+
+// src/kinds/middleware-attach.ts
+function isRawEntry(entry) {
+  return typeof entry === "object" && entry !== null && entry[RAW_ENVELOPE] !== void 0;
+}
+function parseEntry(entry) {
+  if (typeof entry === "object" && "middleware" in entry) {
+    return { ref: entry.middleware, active: entry.active };
+  }
+  return { ref: entry };
+}
+function middlewareAttachStatement(args) {
+  return {
+    name: "mvp:middleware",
+    context: { middleware: { id: resolveRef("middleware", args.middleware) } },
+    ...args.active === false ? { disabled: true } : {}
+  };
+}
+registerStatement("mvp:middleware", middlewareAttachStatement);
+function encodeMiddlewareEntry(entry) {
+  if (isRawEntry(entry)) return encodeStatement(entry);
+  const { ref: ref2, active } = parseEntry(entry);
+  return encodeStatement(middlewareAttachStatement({ middleware: ref2, active }));
+}
+function middlewareEntryGuid(entry) {
+  const id = entry?.context?.middleware?.id;
+  return typeof id === "string" ? id : void 0;
+}
+function buildMiddlewareBlock(attach) {
+  if (!attach) return emptyMiddleware();
+  return {
+    pre_customize: attach.pre !== void 0,
+    post_customize: attach.post !== void 0,
+    pre: encodeMiddlewareList(attach.pre),
+    post: encodeMiddlewareList(attach.post)
+  };
+}
+function encodeMiddlewareList(entries) {
+  return (entries ?? []).map(encodeMiddlewareEntry);
+}
+function clear() {
+  return [];
+}
+function stackReferencesAuth(stack) {
+  return (stack ?? []).some(nodeReferencesAuth);
+}
+function nodeReferencesAuth(node) {
+  if (node === null || typeof node !== "object" && typeof node !== "function") return false;
+  if (isTaggedValue(node) && node.tag === "auth") return true;
+  if (Array.isArray(node)) return node.some(nodeReferencesAuth);
+  return Object.values(node).some(nodeReferencesAuth);
+}
+
+// src/refs/auth.ts
+function resolveAuthRef(hostLabel, host, auth2) {
+  if (auth2 === void 0 || auth2 === false || auth2 === null) return false;
+  if (auth2 === true) {
+    throw new Error(
+      `${hostLabel} "${host}": \`auth: true\` is no longer supported. Pass the auth table (e.g. \`auth: user\` for a \`table({ auth: true })\`) or its numeric id.`
+    );
+  }
+  if (typeof auth2 === "number") {
+    if (!Number.isInteger(auth2) || auth2 <= 0) {
+      throw new Error(
+        `${hostLabel} "${host}": numeric \`auth\` must be a positive integer \`dbo.id\` (got ${auth2}). Use \`false\` for no auth, or pass the auth table def/name.`
+      );
+    }
+    return auth2;
+  }
+  return resolveRef("dbo", auth2);
+}
+
+// src/statements/lean-input.ts
+function leanInput(name, v2) {
+  assertInputValue(name, v2);
+  return { name, tag: v2.tag, value: v2.value, filters: v2.filters };
+}
+function assertInputValue(name, v2) {
+  if (isInputValue(v2)) return;
+  throw new Error(
+    `input \`${name}\`: expected a tagged value (\`c.*\`/\`inp\`/\`ref\`/\`col\`/\u2026), got ${describe(v2)}. An input stores \`{tag,value,filters}\` copied off this argument, so a plain JS value emits an empty slot that deploys clean and then fails every request with "Unable to locate input: ". Wrap it \u2014 an array of rows is \`c.array([{ \u2026 }])\` (plain JSON inside, no nested \`c.*\`), a record is \`c.obj({ \u2026 })\`.`
+  );
+}
+function isInputValue(v2) {
+  return (typeof v2 === "object" || typeof v2 === "function") && v2 !== null && typeof v2.tag === "string" && "value" in v2 && Array.isArray(v2.filters);
+}
+function describe(v2) {
+  if (v2 === null) return "null";
+  if (v2 === void 0) return "undefined";
+  if (Array.isArray(v2)) return `a JS array (${v2.length} item${v2.length === 1 ? "" : "s"})`;
+  if (typeof v2 === "object") return "a plain object";
+  return `a ${typeof v2}`;
+}
+
+// src/kinds/datasource.ts
+function warnLiveDatasource(opts) {
+  if (opts.datasource.trim().toLowerCase() !== "live") return;
+  emitDiagnostic({
+    severity: "warning",
+    code: opts.code,
+    message: `${opts.subject} runs against the "live" datasource. Running a test CLONES its datasource first \u2014 against production-sized data this is slow enough to fail the run. Prefer \`datasource: ""\` (an empty datasource, the recommended default) or a small fixture datasource.`
+  });
+}
+
+// src/kinds/test.ts
+function testIdSeed(ownerKind, ownerName, testName) {
+  return `${ownerKind}/${ownerName}:${testName}`;
+}
+function encodeTest(def, ownerKind, ownerName) {
+  if (!def.name) throw new Error("test: `name` is required.");
+  const datasource = def.datasource ?? "";
+  warnLiveDatasource({
+    code: "test.live-datasource",
+    subject: `test "${def.name}"`,
+    datasource
+  });
+  const xdo = {
+    datasource,
+    description: def.description ?? "",
+    expect: def.expect ?? [],
+    id: def.id ?? deriveGuid("test", testIdSeed(ownerKind, ownerName, def.name)),
+    input: Object.entries(def.input ?? {}).map(([name, v2]) => leanInput(name, v2)),
+    name: def.name,
+    token: def.token ?? ""
+  };
+  return xdo;
+}
+function encodeTests(defs, ownerKind, ownerName) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const def of defs ?? []) {
+    if (seen.has(def.name)) {
+      throw new Error(
+        `${ownerKind} "${ownerName}": two tests are named "${def.name}". A test name is how a statement's \`mock\` names the test it belongs to, so names must be unique within an object. Rename one of them.`
+      );
+    }
+    seen.add(def.name);
+  }
+  return (defs ?? []).map((def) => encodeTest(def, ownerKind, ownerName));
+}
+function test(def) {
+  return def;
+}
+
+// src/kinds/stored-name.ts
+var NAME_MAX = 200;
+var EXTRA = {
+  route: "_-{}/",
+  plain: "_-"
+};
+var PATTERN = {
+  route: /^[A-Za-z0-9_\-{}/]+$/,
+  plain: /^[A-Za-z0-9_-]+$/
+};
+var DESCRIPTION = {
+  route: 'only letters, digits, "_", "-", "/", and the "{}" of a path param',
+  plain: 'only letters, digits, "_" and "-"'
+};
+function assertCanonical(context, canonical) {
+  if (canonical === void 0 || canonical === "") return;
+  if (canonical.length > NAME_MAX) {
+    throw new Error(
+      `${context}: the canonical is ${canonical.length} characters \u2014 the engine stores at most ${NAME_MAX}. Shorten it, or omit it and let \`xanots export <entry> --lock\` mint one.`
+    );
+  }
+  if (PATTERN.plain.test(canonical)) return;
+  const bad = [.../* @__PURE__ */ new Set([...canonical])].filter((ch) => !/[A-Za-z0-9_-]/.test(ch));
+  throw new Error(
+    `${context}: the canonical contains ${bad.map((ch) => JSON.stringify(ch)).join(", ")}, which cannot appear in a URL token. A canonical holds ${DESCRIPTION.plain} \u2014 it is the \`<canonical>\` of \`/api:<canonical>\` and of the MCP/realtime stream paths. Unlike a name, the engine does NOT reject or blank it: it stores the value verbatim, the deploy succeeds, and every client then 404s against an address the router cannot match. Omit \`canonical\` to let \`xanots export <entry> --lock\` mint one, or supply a token in charset.`
+  );
+}
+function assertStoredName(context, name, shape) {
+  if (name.length > NAME_MAX) {
+    throw new Error(
+      `${context}: the name is ${name.length} characters \u2014 the engine stores at most ${NAME_MAX}, and a longer one is dropped rather than truncated, leaving the object with an empty name. Shorten it.`
+    );
+  }
+  if (PATTERN[shape].test(name)) return;
+  const allowed = /* @__PURE__ */ new Set([...EXTRA[shape]]);
+  const bad = [.../* @__PURE__ */ new Set([...name])].filter(
+    (ch) => !/[A-Za-z0-9]/.test(ch) && !allowed.has(ch)
+  );
+  const list = bad.map((ch) => JSON.stringify(ch)).join(", ");
+  const hint = bad.includes(".") ? ` A "." is the one authors reach for: an endpoint that serves a file wants "export_zip" or "export/zip", not "export.zip" \u2014 the extension belongs in the response headers.` : "";
+  throw new Error(
+    `${context}: the name contains ${list}, which the engine cannot store. This name holds ${DESCRIPTION[shape]}.${hint} Xano does not reject the write \u2014 it saves the object with an EMPTY name, so it deploys clean and then 404s "Unable to locate request." on every request.`
+  );
+}
+
+// src/kinds/closed-set.ts
+function assertOneOf(context, field, value, allowed, note) {
+  if (value === void 0 || value === null) return;
+  if (typeof value === "string" && allowed.includes(value)) return;
+  const list = allowed.map((v2) => JSON.stringify(v2)).join(", ");
+  const cased = typeof value === "string" ? allowed.find((v2) => v2.toLowerCase() === value.toLowerCase()) : void 0;
+  const hint = cased ? ` Write it as ${JSON.stringify(cased)} \u2014 the casing is the whole difference.` : "";
+  throw new Error(
+    `${context}: \`${field}\` is ${JSON.stringify(value) ?? String(value)}, which is not one of ${list}.${hint} ${note}`
+  );
+}
+
+// src/kinds/query.ts
+var HTTP_VERBS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"];
+var QUERY_RESPONSE_TYPES = ["standard", "stream"];
+function encodeExample(example) {
+  const out2 = {};
+  if (example?.input !== void 0 && example.input !== null) out2.input = example.input;
+  if (example?.output !== void 0 && example.output !== null) out2.output = example.output;
+  return out2;
+}
+function defaultCache(override) {
+  return {
+    active: false,
+    ttl: 3600,
+    input: true,
+    auth: true,
+    datasource: true,
+    ip: false,
+    headers: [],
+    env: [],
+    ...override
+  };
+}
+function resolveAuth(name, auth2) {
+  return resolveAuthRef("query", name, auth2);
+}
+function assertQueryPathParams(def) {
+  const context = `query "${def.name}"`;
+  assertStoredName(context, def.name, "route");
+  const params = parsePathParams(context, def.name);
+  assertPathParamInputs(context, params, def.input);
+  return params;
+}
+function assertQueryClosedSets(def) {
+  const context = `query "${def.name}"`;
+  assertOneOf(
+    context,
+    "verb",
+    def.verb,
+    HTTP_VERBS,
+    'The engine does not reject an unrecognized verb \u2014 it stores NULL, and a null verb serves as GET. So the endpoint deploys clean, answers on the wrong method, and the method you meant 404s "Unable to locate request.", which reads as a routing or api-group problem.'
+  );
+  assertOneOf(
+    context,
+    "responseType",
+    def.responseType,
+    QUERY_RESPONSE_TYPES,
+    'The engine does not reject an unrecognized response_type \u2014 it stores NULL, which falls back to "standard". So a misspelled stream deploys clean and then quietly buffers the whole response instead of streaming it.'
+  );
+}
+function encodeQuery(def) {
+  if (!def.name) throw new Error("query: `name` is required.");
+  if (!def.verb) throw new Error("query: `verb` is required.");
+  assertQueryPathParams(def);
+  assertQueryClosedSets(def);
+  warnUnboundReturn("query", def.name, def.stack, def.response);
+  const xdo = {
+    name: def.name,
+    description: def.description ?? "",
+    docs: def.docs ?? "",
+    api_enabled: def.apiEnabled ?? true,
+    auth: resolveAuth(def.name, def.auth),
+    response_type: def.responseType ?? "standard",
+    verb: def.verb,
+    disabled: def.disabled ?? false,
+    // The engine binds a query to its api group by the group's guid (export
+    // maps id→guid, import remaps guid→local id). Deriving that guid from the
+    // group's name is stateless and stable across syncs. A numeric `apiGroupId`
+    // is an explicit escape hatch and wins when given.
+    app: {
+      id: def.apiGroupId ?? (def.apiGroup !== void 0 ? resolveRef("app", def.apiGroup) : 0)
+    },
+    cache: defaultCache(def.cache),
+    output: [],
+    middleware: buildMiddlewareBlock(def.middleware),
+    tag: encodeTags(def.tags),
+    history: encodeHistory("query", def.history),
+    input: Object.entries(def.input ?? {}).map(([name, d]) => encodeInput(name, d)),
+    result: encodeResponse(def.response),
+    run: (def.stack ?? []).map(encodeStatement),
+    test: encodeTests(def.tests, "query", def.name),
+    example: encodeExample(def.example),
+    market_item: { id: 0, version: 0, guid: "" }
+  };
+  resolveMockKeys(xdo.run, xdo.test, "query", def.name);
+  return xdo;
+}
+var queryKind = {
+  name: "query",
+  payloadKey: "query",
+  encode: encodeQuery
+};
+registerKind(queryKind);
+function resolveCanonical(def, override) {
+  if (override) return override;
+  const group = def.apiGroup;
+  if (group && typeof group === "object" && typeof group.canonical === "string" && group.canonical !== "") {
+    return group.canonical;
+  }
+  const groupName = typeof group === "string" ? group : group?.name;
+  if (groupName) {
+    const locked = getLockedCanonical(lockKey("app", groupName));
+    if (locked) return locked;
+  }
+  throw new Error(
+    `query "${def.name}": getPath() cannot resolve the api group's canonical URL token. Set an explicit \`apiGroup({ canonical })\`, or run \`xanots export <entry> --lock\` once (it mints a unique canonical and freezes it in xano.lock) and seed that lock before importing defs \u2014 the CLI does this automatically, and build scripts call seedLockOverrides(readLockFile(path)) first. As a last resort pass one directly: getPath({ canonical: "..." }). (Minting here is unsafe \u2014 canonicals must be unique per instance across all workspaces, so they are only generated at locked export.)`
+  );
+}
+function pathSegment(name) {
+  return name.replace(/^\/+/, "");
+}
+function queryImpl(def) {
+  const params = assertQueryPathParams(def);
+  assertQueryClosedSets(def);
+  const context = `query "${def.name}"`;
+  const path = pathSegment(def.name);
+  const getPath = (opts) => `/api:${resolveCanonical(def, opts?.canonical)}/${params.length ? fillPathParams(context, "getPath()", path, opts?.params, true) : path}`;
+  const search = (values) => toSearchParams(
+    params.length ? Object.fromEntries(Object.entries(values).filter(([key]) => !params.includes(key))) : values
+  );
+  return { ...def, getPath, toSearchParams: search };
+}
+function toSearchParams(input2) {
+  const params = new URLSearchParams();
+  const append = (key, item) => {
+    if (typeof item === "number" && !Number.isFinite(item)) {
+      throw new TypeError(`toSearchParams: param "${key}" is ${item} \u2014 not a finite value`);
+    }
+    if (typeof item !== "string" && typeof item !== "number" && typeof item !== "boolean") {
+      throw new TypeError(`toSearchParams: param "${key}" is not a scalar (got ${typeof item})`);
+    }
+    params.append(key, String(item));
+  };
+  for (const [key, value] of Object.entries(input2)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item === void 0 || item === null) continue;
+        append(key, item);
+      }
+    } else {
+      append(key, value);
+    }
+  }
+  return params;
+}
+var query = Object.assign(queryImpl, { toSearchParams });
+
+// src/workspace/export.ts
+var BUNDLE_APP = "xano";
+var BUNDLE_VERSION_JSON = "1.03";
+var PAYLOAD_ARRAY_KEYS = [
+  "dbo",
+  "addon",
+  "function",
+  "middleware",
+  "trigger",
+  "task",
+  "query",
+  "tool",
+  "toolset",
+  "app",
+  // Realtime, in dependency order: a channel resolves its server, and a message
+  // resolves both. They sit after `app` so every object they can reference
+  // (tables for auth, api groups) is already in place.
+  "realtime_server",
+  "channel",
+  "message",
+  // A container workload. Independent of every other object — nothing
+  // references it and it references nothing — so its position is arbitrary.
+  "microservice",
+  "vault",
+  "market_item",
+  "run_install",
+  "action_package_install",
+  "env",
+  "workflow_test",
+  "service",
+  "branch"
+];
+function phpEncodeString(str) {
+  let out2 = '"';
+  for (const ch of str) {
+    const code = ch.codePointAt(0);
+    switch (ch) {
+      case '"':
+        out2 += "\\u0022";
+        break;
+      // JSON_HEX_QUOT
+      case "\\":
+        out2 += "\\\\";
+        break;
+      case "<":
+        out2 += "\\u003C";
+        break;
+      // JSON_HEX_TAG
+      case ">":
+        out2 += "\\u003E";
+        break;
+      // JSON_HEX_TAG
+      case "&":
+        out2 += "\\u0026";
+        break;
+      // JSON_HEX_AMP
+      case "'":
+        out2 += "\\u0027";
+        break;
+      // JSON_HEX_APOS
+      case "\b":
+        out2 += "\\b";
+        break;
+      case "\f":
+        out2 += "\\f";
+        break;
+      case "\n":
+        out2 += "\\n";
+        break;
+      case "\r":
+        out2 += "\\r";
+        break;
+      case "	":
+        out2 += "\\t";
+        break;
+      default:
+        out2 += code < 32 ? "\\u" + code.toString(16).padStart(4, "0") : ch;
+    }
+  }
+  return out2 + '"';
+}
+function phpJsonEncode(value) {
+  const out2 = [];
+  const stack = [{ value }];
+  while (stack.length > 0) {
+    const frame = stack.pop();
+    if ("lit" in frame) {
+      out2.push(frame.lit);
+      continue;
+    }
+    const current = frame.value;
+    if (current === null || current === void 0) {
+      out2.push("null");
+      continue;
+    }
+    switch (typeof current) {
+      case "string":
+        out2.push(phpEncodeString(current));
+        continue;
+      case "number":
+        out2.push(Number.isFinite(current) ? JSON.stringify(current) : "0");
+        continue;
+      case "boolean":
+        out2.push(current ? "true" : "false");
+        continue;
+      case "object":
+        break;
+      default:
+        out2.push("null");
+        continue;
+    }
+    if (Array.isArray(current)) {
+      stack.push({ lit: "]" });
+      for (let i = current.length - 1; i >= 0; i--) {
+        stack.push({ value: current[i] });
+        if (i > 0) stack.push({ lit: "," });
+      }
+      stack.push({ lit: "[" });
+      continue;
+    }
+    const obj2 = current;
+    const keys = Object.keys(obj2).filter((key) => obj2[key] !== void 0);
+    stack.push({ lit: "}" });
+    for (let i = keys.length - 1; i >= 0; i--) {
+      const key = keys[i];
+      stack.push({ value: obj2[key] });
+      stack.push({ lit: phpEncodeString(key) + ":" });
+      if (i > 0) stack.push({ lit: "," });
+    }
+    stack.push({ lit: "{" });
+  }
+  return out2.join("");
+}
+function base64websafe(bytes) {
+  let bin = "";
+  for (const b of bytes) bin += String.fromCharCode(b);
+  return btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, ".");
+}
+function calcSignatureJson(exportObj) {
+  const sorted = {};
+  for (const key of Object.keys(exportObj).sort()) {
+    sorted[key] = exportObj[key];
+  }
+  return base64websafe(sha1Bytes(phpJsonEncode(sorted)));
+}
+function assertUniqueGuids(payload, lock) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const key of PAYLOAD_ARRAY_KEYS) {
+    const arr = payload[key];
+    if (!Array.isArray(arr)) continue;
+    for (const obj2 of arr) {
+      if (!obj2 || typeof obj2 !== "object") continue;
+      const guid = obj2.guid;
+      if (typeof guid !== "string") continue;
+      const name = obj2.name;
+      const label = `${key}/${typeof name === "string" ? name : "<unnamed>"}`;
+      const prev = seen.get(guid);
+      if (prev !== void 0) {
+        const pinnedBy = lock ? Object.entries(lock.objects).find(([, e]) => e.guid === guid)?.[0] : void 0;
+        const lockNote = pinnedBy ? ` This guid is pinned by lock entry "${pinnedBy}" \u2014 if that entry was moved by \`xanots lock rename\`, a new object now re-derives the old name's guid. Pin a distinct explicit \`guid\` on the new object, or update the lock entry.` : ` Object identity is derived from (type, name) \u2014 two objects of the same kind share a name. Rename one, or pin a distinct explicit \`guid\`.`;
+        throw new Error(`Duplicate object guid (${guid}) shared by "${prev}" and "${label}".` + lockNote);
+      }
+      seen.set(guid, label);
+    }
+  }
+}
+function buildContentEnvelope(rows) {
+  const unsigned = {
+    app: BUNDLE_APP,
+    version: BUNDLE_VERSION_JSON,
+    type: "content",
+    payload: rows
+  };
+  return { ...unsigned, sig: calcSignatureJson(unsigned) };
+}
+function buildBundle(args) {
+  const workspace = { ...args.workspace ?? {} };
+  const wsEnv = workspace.env;
+  const payload = { partial: false, workspace };
+  for (const key of PAYLOAD_ARRAY_KEYS) {
+    payload[key] = args.sections[key] ?? [];
+  }
+  if (Array.isArray(wsEnv) && wsEnv.length > 0) {
+    payload.env = wsEnv;
+    workspace.env = [];
+  }
+  assertUniqueGuids(payload, args.lock);
+  const unsigned = {
+    app: BUNDLE_APP,
+    version: BUNDLE_VERSION_JSON,
+    type: args.type ?? "workspace",
+    payload
+  };
+  return { ...unsigned, sig: calcSignatureJson(unsigned) };
+}
+
+// src/values/query-filters.ts
+var VECTOR_FILTERS = [
+  // The unqualified spelling, alongside the per-metric ones below. A real
+  // workspace uses it on a vector column and it was reported unresolvable
+  // (issue #137).
+  "vector_distance",
+  "vector_cos_distance",
+  "vector_cos_similarity",
+  "vector_inner_product",
+  "vector_negative_inner_product",
+  "vector_l1_distance",
+  "vector_l2_distance"
+];
+var QUERY_EXPRESSION_FILTERS = [
+  ...VECTOR_FILTERS,
+  // Geo predicates over a `f.geo.*` column.
+  "covers",
+  "distance",
+  "within",
+  // Full-text rank, over the search index a `search` operand matched against.
+  "search_rank",
+  "unaccent",
+  // SQL-side scalar helpers.
+  "array_length",
+  "at_timezone",
+  "between_filter",
+  "coalesce",
+  "length",
+  "time",
+  "to_timestamp",
+  // Timestamp arithmetic and extraction, computed in the database.
+  "epochms_add_day",
+  "epochms_add_hour",
+  "epochms_add_minute",
+  "epochms_add_month",
+  "epochms_add_sec",
+  "epochms_add_year",
+  "epochms_sub_day",
+  "epochms_sub_hour",
+  "epochms_sub_minute",
+  "epochms_sub_month",
+  "epochms_sub_sec",
+  "epochms_sub_year",
+  "epochms_day",
+  "epochms_dow",
+  "epochms_doy",
+  "epochms_epoch_day",
+  "epochms_epoch_hour",
+  "epochms_epoch_minute",
+  "epochms_epoch_sec",
+  "epochms_hour",
+  "epochms_minute",
+  "epochms_month",
+  "epochms_week",
+  "epochms_year",
+  // SQL-side AGGREGATES, computed by the database over a grouped result. They
+  // are correctly absent from the runtime catalog — the resolvability probe
+  // classifies them as phantoms because they genuinely do not resolve in a value
+  // pipeline — but they are exactly what a db-query aggregate expression is for,
+  // and every one of them works live. Missing here, they were reported as
+  // guaranteed runtime 500s on a working workspace (issue #137).
+  "count_distinct",
+  "median",
+  // The list aggregates: collect a column's values into an array, optionally
+  // ordered, optionally de-duplicated.
+  "to_list",
+  "to_list_asc",
+  "to_list_desc",
+  "to_distinct_list",
+  "to_distinct_list_asc",
+  "to_distinct_list_desc"
+];
+var isQueryExpressionFilter = (name) => QUERY_EXPRESSION_FILTERS.includes(name);
+
+// src/kinds/function.ts
+function encodeFunction(fn2) {
+  if (!fn2.name) {
+    throw new Error("function kind: `name` is required.");
+  }
+  warnUnboundReturn("function", fn2.name, fn2.stack, fn2.response);
+  const xdo = {
+    name: fn2.name,
+    description: fn2.description ?? "",
+    docs: fn2.docs ?? "",
+    workspace: { id: fn2.workspace ?? 0 },
+    branch: { id: 0 },
+    cache: defaultCache(fn2.cache),
+    history: encodeHistory("function", fn2.history),
+    middleware: buildMiddlewareBlock(fn2.middleware),
+    tag: encodeTags(fn2.tags),
+    input: Object.entries(fn2.input ?? {}).map(
+      ([name, descriptor2]) => encodeInput(name, descriptor2)
+    ),
+    result: encodeResponse(fn2.response),
+    run: (fn2.stack ?? []).map(encodeStatement),
+    test: encodeTests(fn2.tests, "function", fn2.name),
+    market_item: { id: 0, version: 0, guid: "" },
+    shared_workspace: { is_shared: false }
+  };
+  resolveMockKeys(xdo.run, xdo.test, "function", fn2.name);
+  return xdo;
+}
+var functionKind = {
+  name: "function",
+  payloadKey: "function",
+  encode: encodeFunction
+};
+registerKind(functionKind);
+
+// src/function/compile.ts
+function compile(fn2) {
+  return encodeFunction(fn2);
+}
+
+// src/emit/emit.ts
+function emit(def, opts = {}) {
+  const indent = opts.indent ?? 2;
+  if ("schema" in def && def.schema !== void 0) {
+    return JSON.stringify(encodeTable(def), null, indent);
+  }
+  if ("verb" in def && def.verb !== void 0) {
+    return JSON.stringify(encodeQuery(def), null, indent);
+  }
+  return JSON.stringify(compile(def), null, indent);
+}
+function serializeBundle(bundle, opts = {}) {
+  return JSON.stringify(bundle, null, opts.indent ?? 2);
+}
+function emitBundle(xano, opts = {}) {
+  return serializeBundle(xano.export({ strict: opts.strict }), opts);
+}
+
+// src/statements/decode-only.ts
+var DECODE_ONLY_STATEMENTS = /* @__PURE__ */ new Map([
+  [
+    "mvp:placeholder",
+    'an unconfigured statement slot the engine writes in place of a statement it could not resolve, so an export stays well-formed. There is no statement class behind it: importing a workspace that contains one fails outright with "Missing statement: mvp:placeholder". Replace it with the statement it stands in for before deploying \u2014 there is no destination where it runs'
+  ]
+]);
+
+export {
+  TAGS,
+  LAMBDA_BINDINGS,
+  LAMBDA_GLOBALS,
+  LAMBDA_MODULE_GLOBALS,
+  LAMBDA_CODE_FILTERS,
+  LAMBDA_STATEMENTS,
+  coerceLambdaFields,
+  assertLambdaStatement,
+  extractFunctionBody,
+  maskNonCode,
+  assertLambdaBody,
+  collectLambdaBodyProblems,
+  lambdaValue,
+  lam,
+  emitDiagnostic,
+  DiagnosticBag,
+  isTaggedValue,
+  barePatternRefusal,
+  c,
+  ref,
+  inp,
+  col,
+  auth,
+  resp,
+  caught,
+  isToolsetPath,
+  toolset,
+  env,
+  setting,
+  sys,
+  out,
+  filter,
+  withFilters,
+  toNestedFields,
+  f,
+  input,
+  encodeInput,
+  obj,
+  FILTER_NAMES,
+  FILTER_SPECS,
+  FILTER_REQUIRED_ARGS,
+  fl,
+  expr,
+  isSearchOp,
+  cmp,
+  and,
+  or,
+  mixed,
+  isValue,
+  isGroup,
+  isMixed,
+  isCmpNode,
+  encodeExpression,
+  isRuntimeConditionOp,
+  encodeRuntimeCondition,
+  conditional,
+  resolveMockKeys,
+  assertMockKeysResolved,
+  registerKind,
+  isRegisteredKind,
+  getKind,
+  encodeObject,
+  registeredKinds,
+  emptyMiddleware,
+  encodeTags,
+  SCALAR_FAMILY,
+  SEED_FILE,
+  seedFile,
+  isSeedFileSource,
+  tableColumns,
+  SYSTEM_COLUMN_NAMES,
+  elideSystemIndexes,
+  encodeIndex,
+  encodeView,
+  encodeColumn,
+  encodeTable,
+  tableKind,
+  table,
+  leanInput,
+  assertInputValue,
+  encodeResponse,
+  encodeHistory,
+  encodeContainerHistory,
+  buildWorkspaceHistory,
+  assertCanonical,
+  assertStoredName,
+  encodeMiddlewareEntry,
+  middlewareEntryGuid,
+  buildMiddlewareBlock,
+  encodeMiddlewareList,
+  clear,
+  stackReferencesAuth,
+  resolveAuthRef,
+  warnLiveDatasource,
+  encodeTests,
+  test,
+  assertOneOf,
+  encodeQuery,
+  queryKind,
+  pathSegment,
+  toSearchParams,
+  query,
+  PAYLOAD_ARRAY_KEYS,
+  phpJsonEncode,
+  calcSignatureJson,
+  buildContentEnvelope,
+  buildBundle,
+  DECODE_ONLY_STATEMENTS,
+  VECTOR_FILTERS,
+  QUERY_EXPRESSION_FILTERS,
+  isQueryExpressionFilter,
+  encodeFunction,
+  functionKind,
+  compile,
+  emit,
+  serializeBundle,
+  emitBundle
+};
+//# sourceMappingURL=chunk-EMCAWMHC.js.map