@xanots/sdk 0.0.1

package/dist/chunk-FJ6ZS5KB.js

@@ -0,0 +1,3607 @@
+import {
+  SCALAR_FAMILY,
+  and,
+  assertCanonical,
+  assertInputValue,
+  assertLambdaStatement,
+  assertStoredName,
+  barePatternRefusal,
+  buildWorkspaceHistory,
+  c,
+  coerceLambdaFields,
+  conditional,
+  encodeContainerHistory,
+  encodeExpression,
+  encodeHistory,
+  encodeInput,
+  encodeMiddlewareList,
+  encodeResponse,
+  encodeRuntimeCondition,
+  encodeTags,
+  f,
+  filter,
+  inp,
+  input,
+  isCmpNode,
+  isGroup,
+  isMixed,
+  isTaggedValue,
+  isValue,
+  leanInput,
+  obj,
+  ref,
+  registerKind,
+  tableColumns,
+  withFilters
+} from "./chunk-EMCAWMHC.js";
+import {
+  assertPathParamInputs,
+  fillPathParams,
+  parsePathParams
+} from "./chunk-WHOJWOSV.js";
+import {
+  annotate,
+  encodeStatement,
+  isRegisteredStatement,
+  registerStatement
+} from "./chunk-LH6Z6KFV.js";
+import {
+  deriveGuid,
+  realtimeChannelSeedName,
+  resolveRef
+} from "./chunk-4HT3BNZ7.js";
+
+// src/statements/set-var.ts
+var SET_VAR = "mvp:set_var";
+var UPDATE_VAR = "mvp:update_var";
+function setVar(as, value, a) {
+  return annotate(
+    {
+      name: SET_VAR,
+      as,
+      context: { value: value.value, tag: value.tag, filters: value.filters }
+    },
+    a
+  );
+}
+function updateVar(name, value, a) {
+  return annotate(
+    {
+      name: UPDATE_VAR,
+      context: { name, value: value.value, tag: value.tag, filters: value.filters },
+      output: { filters: [] }
+    },
+    a
+  );
+}
+registerStatement(SET_VAR, setVar);
+registerStatement(UPDATE_VAR, updateVar);
+
+// src/statements/special/db-search.ts
+var CONSTANT_WHERE_TAGS = /* @__PURE__ */ new Set([
+  "const:bool",
+  "const:int",
+  "const:decimal",
+  "const:null",
+  "const:epochms"
+]);
+function encodeSearch(where, additionalWhere) {
+  const nodes = [];
+  let raw;
+  for (const [field, w] of [["where", where], ["additionalWhere", additionalWhere]]) {
+    if (!w) continue;
+    if (Array.isArray(w)) nodes.push(...w);
+    else if (isGroup(w) || isMixed(w) || isCmpNode(w)) nodes.push(w);
+    else if (isValue(w)) {
+      if (CONSTANT_WHERE_TAGS.has(w.tag)) {
+        throw new Error(
+          `db search: \`${field}\` is the constant ${w.tag}:${JSON.stringify(w.value)}, which cannot be a search clause \u2014 a fixed literal states no condition, and the engine reads the resulting \`context.search\` as neither a predicate nor an absent one. To match EVERY row, omit \`${field}\` entirely (an empty search is how "no filter" is spelled). To filter, use expr(col("x"), "=", \u2026), cmp(...), or an and()/or() group. The raw Value form is the escape hatch for a clause built elsewhere \u2014 inp("clause"), ref("built_where"), or an expression value \u2014 not for a literal. (issue #51)`
+        );
+      }
+      raw = w;
+    } else {
+      throw new Error(
+        "db search: `where` must be an expr(...)/cmp(...) comparison, an and()/or() group, an array of those, or a tagged Value (inp/ref/col/c.*) \u2014 got an object that is neither. Check for a typo (e.g. `operator` instead of `op`)."
+      );
+    }
+  }
+  if (raw !== void 0 && nodes.length) {
+    throw new Error(
+      "db search: a raw Value `where` cannot be combined with expr()/cmp()/and()/or() clauses \u2014 use one form or the other."
+    );
+  }
+  if (nodes.length) return encodeExpression(nodes);
+  if (raw !== void 0) return raw;
+  return void 0;
+}
+function encodeSort(sort) {
+  return (sort ?? []).map((s2) => ({ sortBy: s2.sortBy, orderBy: s2.dir ?? "asc" }));
+}
+function encodeEval(evals) {
+  if (!evals?.length) return void 0;
+  return evals.map((e) => ({
+    as: e.as,
+    name: e.name,
+    filters: (e.filters ?? []).map((f2) => ({
+      name: f2.name,
+      arg: (f2.arg ?? []).map((v) => ({ value: v.value, tag: v.tag, filters: v.filters })),
+      ...f2.disabled ? { disabled: true } : {}
+    }))
+  }));
+}
+function qualifyAggregateEvals(evals, primaryAlias, kind) {
+  if (!evals?.length) return evals;
+  return evals.map((e) => {
+    const name = e.name.includes(".") ? e.name : `${primaryAlias}.${e.name}`;
+    if (!/^[^.]+\.[^.].*$/.test(name)) {
+      throw new Error(
+        `${kind === "query eval" ? "db.query eval" : `aggregate ${kind}`}: name "${e.name}" must be an alias-qualified column (e.g. "${primaryAlias || "<table>"}.${e.name}") \u2014 the engine rejects a bare column name there (\`Unsupported param format\`). Qualify it with the table alias, or the bind alias for a joined column.`
+      );
+    }
+    return { ...e, name };
+  });
+}
+
+// src/statements/special/control-flow.ts
+function asValue(arg) {
+  return "tag" in arg ? arg : arg.value;
+}
+function valueContext(arg) {
+  const value = asValue(arg);
+  return { value: value.value, tag: value.tag, filters: value.filters };
+}
+function returnValue(value, a) {
+  return annotate({ name: "mvp:return", context: valueContext(value) }, a);
+}
+function die(value, a) {
+  return annotate({ name: "mvp:die", context: valueContext(value) }, a);
+}
+function debugLog(value, a) {
+  return annotate({ name: "mvp:debug_log", context: valueContext(value) }, a);
+}
+function foreachBreak(a) {
+  return annotate({ name: "mvp:foreach_break", context: {} }, a);
+}
+function foreachContinue(a) {
+  return annotate({ name: "mvp:foreach_continue", context: {} }, a);
+}
+function foreachRemove(a) {
+  return annotate({ name: "mvp:foreach_remove", context: {} }, a);
+}
+registerStatement("mvp:return", returnValue);
+registerStatement("mvp:die", die);
+registerStatement("mvp:debug_log", debugLog);
+registerStatement("mvp:foreach_break", foreachBreak);
+registerStatement("mvp:foreach_continue", foreachContinue);
+registerStatement("mvp:foreach_remove", foreachRemove);
+
+// src/statements/special/loops.ts
+function valueFields(v) {
+  return { value: v.value, tag: v.tag, filters: v.filters };
+}
+function run(body) {
+  return body.map(encodeStatement);
+}
+function forLoop(args) {
+  return annotate({
+    name: "mvp:for",
+    context: { as: args.as, cnt: valueFields(args.count), run: run(args.body) },
+    input: []
+  }, args);
+}
+function foreachLoop(args) {
+  return annotate({
+    name: "mvp:foreach",
+    context: { as: args.as, list: valueFields(args.list), run: run(args.body) },
+    input: []
+  }, args);
+}
+function whileLoop(args) {
+  return annotate({
+    name: "mvp:while",
+    context: { expr: encodeRuntimeCondition(args.when, "s.while `when`"), run: run(args.body) },
+    input: []
+  }, args);
+}
+function group(body, a) {
+  return annotate({ name: "mvp:group", context: { run: run(body) }, input: [] }, a);
+}
+registerStatement("mvp:for", forLoop);
+registerStatement("mvp:foreach", foreachLoop);
+registerStatement("mvp:while", whileLoop);
+registerStatement("mvp:group", group);
+
+// src/statements/special/branch.ts
+function valueFields2(v) {
+  return { value: v.value, tag: v.tag, filters: v.filters };
+}
+function run2(body) {
+  return body.map(encodeStatement);
+}
+function switchCase(args) {
+  const context = { value: valueFields2(args.when) };
+  if (args.break !== void 0) {
+    context.break = args.break;
+  }
+  context.if = { run: run2(args.body) };
+  return annotate({ name: "mvp:switch_case", context, input: [] }, args);
+}
+function switchStatement(args) {
+  return annotate({
+    name: "mvp:switch",
+    context: {
+      value: valueFields2(args.on),
+      elif: { run: args.cases.map((c2) => encodeStatement(switchCase(c2))) },
+      else: { run: run2(args.default ?? []) }
+    },
+    input: []
+  }, args);
+}
+function tryCatch(args) {
+  return annotate({
+    name: "mvp:try_catch",
+    context: {
+      if: { run: run2(args.try) },
+      else: { run: run2(args.catch ?? []) },
+      then: { run: run2(args.finally ?? []) }
+    },
+    input: []
+  }, args);
+}
+registerStatement("mvp:switch", switchStatement);
+registerStatement("mvp:switch_case", switchCase);
+registerStatement("mvp:try_catch", tryCatch);
+
+// src/statements/special/coerce.ts
+function isValue2(w) {
+  return (typeof w === "object" || typeof w === "function") && w !== null && !Array.isArray(w) && "tag" in w && "value" in w;
+}
+var plain = (v) => {
+  if (typeof v !== "function") return v;
+  const { value, tag, filters } = v;
+  return { value, tag, filters };
+};
+var coerceText = (v) => v === void 0 ? void 0 : isValue2(v) ? plain(v) : c.text(v);
+var coerceInt = (v) => v === void 0 ? void 0 : isValue2(v) ? plain(v) : c.int(v);
+var coerceBool = (v) => v === void 0 ? void 0 : isValue2(v) ? plain(v) : c.bool(v);
+var coerceObj = (v) => {
+  if (v === void 0) return void 0;
+  if (isTaggedValue(v)) return plain(v);
+  if (Array.isArray(v)) return c.obj(v);
+  const literals = {};
+  const valueEntries = [];
+  for (const [key, val] of Object.entries(v)) {
+    if (isTaggedValue(val)) valueEntries.push([key, val]);
+    else literals[key] = val;
+  }
+  const base = c.obj(literals);
+  if (valueEntries.length === 0) return base;
+  return withFilters(
+    base,
+    ...valueEntries.map(([key, val]) => {
+      if (/[.[]/.test(key))
+        throw new Error(
+          `coerceObj: object key ${JSON.stringify(key)} carries a tagged value but contains "." or "[", which the engine's set filter reads as a nested path ("a.b" \u2192 {a:{b:\u2026}}) \u2014 the same key with a plain value would stay flat. Use a nested object, or a key without "." / "[".`
+        );
+      return filter("set", c.text(key), val);
+    })
+  );
+};
+var HEADER_NAME = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+var assertNoSplice = (line, what) => {
+  if (!/[\r\n]/.test(line)) return line;
+  throw new Error(
+    `headers: ${what} contains a newline, which would splice a second header into the request. Strip it, or send the content as the request body.`
+  );
+};
+var coerceHeaders = (v) => {
+  if (v === void 0) return void 0;
+  if (isTaggedValue(v)) return plain(v);
+  if (Array.isArray(v)) return c.array(v.map((line, i) => assertNoSplice(line, `line ${i}`)));
+  const entries = Object.entries(v);
+  const lines = [];
+  const computed = [];
+  for (const [name, val] of entries) {
+    if (!HEADER_NAME.test(name)) {
+      throw new Error(
+        `headers: ${JSON.stringify(name)} is not a valid header name. A header line is "Name: value", so a name carrying ":" , a space or a newline would splice a second header into the request. Use the token charset (letters, digits and !#$%&'*+-.^_\`|~).`
+      );
+    }
+    if (isValue2(val)) {
+      computed.push([name, plain(val)]);
+      continue;
+    }
+    lines.push(`${name}: ${assertNoSplice(val, `the value of ${JSON.stringify(name)}`)}`);
+  }
+  const base = c.array(lines);
+  if (computed.length === 0) return base;
+  return withFilters(
+    base,
+    ...computed.map(
+      ([name, val]) => filter("array_push", withFilters(c.text(`${name}: `), filter("concat", val)))
+    )
+  );
+};
+var coerceScalar = (v) => {
+  if (isValue2(v)) return plain(v);
+  if (typeof v === "number") return Number.isInteger(v) ? c.int(v) : c.decimal(v);
+  if (typeof v === "string") return c.text(v);
+  if (typeof v === "boolean") return c.bool(v);
+  return coerceObj(v);
+};
+function coerceHttpFields(a) {
+  return {
+    method: coerceText(a.method),
+    params: coerceObj(a.params),
+    headers: coerceHeaders(a.headers),
+    timeout: coerceInt(a.timeout),
+    follow_location: coerceBool(a.follow_location),
+    verify_host: coerceBool(a.verify_host),
+    verify_peer: coerceBool(a.verify_peer),
+    ca_certificate: coerceText(a.ca_certificate),
+    certificate: coerceText(a.certificate),
+    certificate_pass: coerceText(a.certificate_pass),
+    private_key: coerceText(a.private_key),
+    private_key_pass: coerceText(a.private_key_pass)
+  };
+}
+function textState(v) {
+  if (v === void 0) return "empty";
+  if (typeof v === "string") return v === "" ? "empty" : "nonempty";
+  if (isValue2(v) && v.tag === "const") return v.value === "" ? "empty" : "nonempty";
+  return "unknown";
+}
+function boolState(v, engineDefault) {
+  if (v === void 0) return engineDefault ? "true" : "false";
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (isValue2(v) && v.tag === "const:bool") return v.value === "true" ? "true" : "false";
+  return "unknown";
+}
+function assertSslConsistency(label, a) {
+  const cert = textState(a.certificate);
+  const key = textState(a.private_key);
+  if (cert === "nonempty" && key === "empty")
+    throw new Error(`${label}: \`certificate\` requires \`private_key\` \u2014 a client certificate needs its matching key.`);
+  if (key === "nonempty" && cert === "empty")
+    throw new Error(`${label}: \`private_key\` requires \`certificate\` \u2014 a client key needs its matching certificate.`);
+  const ca = textState(a.ca_certificate);
+  const verifyPeer = boolState(a.verify_peer, true);
+  if (ca === "nonempty" && verifyPeer === "false")
+    throw new Error(`${label}: \`ca_certificate\` requires \`verify_peer: true\` \u2014 the engine only consults a CA cert when peer verification is on.`);
+}
+var CELL_KINDS = {
+  bool: { wants: "a boolean", takes: (x) => typeof x === "boolean", tag: (x) => c.bool(x) },
+  int: { wants: "a number", takes: (x) => typeof x === "number", tag: (x) => c.int(x) },
+  decimal: { wants: "a number", takes: (x) => typeof x === "number", tag: (x) => c.decimal(x) },
+  text: { wants: "a string", takes: (x) => typeof x === "string", tag: (x) => c.text(x) },
+  enum: {
+    wants: "a string or a number",
+    takes: (x) => typeof x === "string" || typeof x === "number",
+    tag: (x) => typeof x === "number" ? c.int(x) : c.text(x)
+  }
+};
+var CELL_KIND = {
+  ...Object.fromEntries(
+    Object.entries(SCALAR_FAMILY).map(([type, family]) => [type, family === "epochms" ? "int" : family])
+  ),
+  date: "text"
+};
+function coerceCell(table, col, cell) {
+  if (cell === null) return c.null();
+  const where = `db row: column "${col.name}" of table "${typeof table === "string" ? table : table.name}"`;
+  const isList = col.array === true || col.style?.type === "list";
+  const kind = isList ? void 0 : CELL_KIND[col.type];
+  if (kind === void 0) {
+    throw new Error(
+      `${where} is declared "${col.type}"${isList ? " (a list)" : ""}, which has no bare-literal form. Author it as a tagged value (\`c.obj({\u2026})\`, \`c.array([\u2026])\`, \`c.text(\u2026)\`) or pass the entry through \`data:\` instead.`
+    );
+  }
+  const spec2 = CELL_KINDS[kind];
+  if (!spec2.takes(cell)) {
+    throw new Error(
+      `${where} is declared "${col.type}", so its cell must be ${spec2.wants} \u2014 got ${typeof cell} (${JSON.stringify(cell)}). Fix the literal, or write the value you meant explicitly as a tagged value if the column's declared type is wrong.`
+    );
+  }
+  if (kind === "int" && !Number.isInteger(cell)) {
+    throw new Error(
+      `${where} is declared "${col.type}", so its cell must be a whole number \u2014 got ${String(cell)}. Round it, or change the column to \`f.decimal()\`.`
+    );
+  }
+  return spec2.tag(cell);
+}
+
+// src/statements/special/async-runtime.ts
+function encodeAsyncRuntime(runtime) {
+  if (!runtime) return void 0;
+  if (runtime.mode !== "async-dedicated") return { mode: runtime.mode };
+  return {
+    mode: runtime.mode,
+    cpu: runtime.cpu ?? "",
+    memory: runtime.memory ?? "",
+    timeout: runtime.timeout === void 0 ? "" : String(runtime.timeout),
+    max_retry: runtime.maxRetry === void 0 ? "" : String(runtime.maxRetry)
+  };
+}
+
+// src/statements/special/calls.ts
+function vf(v) {
+  return { value: v.value, tag: v.tag, filters: v.filters };
+}
+function encodeCallInput(input2) {
+  if (!input2) return [];
+  return Object.entries(input2).map(([name, v]) => ({ name, ...vf(coerceScalar(v)) }));
+}
+function fnId(fn) {
+  return fn === null ? "" : resolveRef("function", fn);
+}
+function functionRun(args) {
+  return annotate({
+    name: "mvp:function",
+    context: { function: { id: fnId(args.fn) } },
+    as: args.as,
+    input: encodeCallInput(args.input),
+    runtime: encodeAsyncRuntime(args.runtime)
+  }, args);
+}
+function functionCall(args) {
+  return annotate({
+    name: "mvp:workspace_run_function",
+    context: { id: resolveRef("function", args.fn) },
+    as: args.as,
+    input: encodeCallInput(args.input)
+  }, args);
+}
+function apiCall(args) {
+  const context = { id: resolveRef("query", args.api) };
+  const headers = coerceHeaders(args.headers);
+  if (headers) context.headers = vf(headers);
+  if (args.auth) {
+    context.token = typeof args.auth.token === "string" ? args.auth.token : vf(args.auth.token);
+    if (args.auth.ignoreExpiration) context.token_ignore_expiration = true;
+  }
+  return annotate({
+    name: "mvp:workspace_run_endpoint",
+    context,
+    as: args.as,
+    input: encodeCallInput(args.input)
+  }, args);
+}
+function taskCall(args) {
+  return annotate({
+    name: "mvp:workspace_run_task",
+    context: { id: resolveRef("task", args.task) },
+    as: args.as,
+    input: []
+  }, args);
+}
+function toolCall(args) {
+  return annotate({
+    name: "mvp:workspace_run_tool",
+    context: { id: resolveRef("tool", args.tool) },
+    as: args.as,
+    input: encodeCallInput(args.input)
+  }, args);
+}
+function triggerCall(args) {
+  return annotate({
+    name: "mvp:workspace_run_trigger",
+    context: { id: resolveRef("trigger", args.trigger) },
+    as: args.as,
+    input: encodeCallInput(args.input)
+  }, args);
+}
+function middlewareCall(args) {
+  return annotate({
+    name: "mvp:workspace_run_middleware",
+    context: { id: resolveRef("middleware", args.middleware) },
+    as: args.as,
+    input: encodeCallInput(args.input)
+  }, args);
+}
+function addonCall(args) {
+  return annotate({
+    name: "mvp:workspace_run_addon",
+    context: { id: resolveRef("addon", args.addon) },
+    as: args.as,
+    input: encodeCallInput(args.input)
+  }, args);
+}
+function actionCall(args) {
+  return annotate({
+    name: "mvp:action",
+    context: { run_version: { id: resolveRef("function", args.action) } },
+    as: args.as,
+    input: encodeCallInput(args.input),
+    settings_registry: []
+  }, args);
+}
+function actionPackageCall(args) {
+  return annotate({
+    name: "mvp:action_package",
+    context: {
+      action: { trace_id: "" },
+      package: { slug: args.package ?? "" },
+      package_version: { id: "" }
+    },
+    as: args.as,
+    input: encodeCallInput(args.input),
+    settings_registry: []
+  }, args);
+}
+function workflowTestCall(args) {
+  return annotate({
+    name: "mvp:workspace_run_workflow_test",
+    context: {
+      datasource: args.datasource ?? "",
+      id: resolveRef("workflow_test", args.workflowTest)
+    },
+    as: args.as,
+    input: []
+  }, args);
+}
+registerStatement("mvp:function", functionRun);
+registerStatement("mvp:action", actionCall);
+registerStatement("mvp:action_package", actionPackageCall);
+registerStatement("mvp:workspace_run_workflow_test", workflowTestCall);
+registerStatement("mvp:workspace_run_function", functionCall);
+registerStatement("mvp:workspace_run_endpoint", apiCall);
+registerStatement("mvp:workspace_run_task", taskCall);
+registerStatement("mvp:workspace_run_tool", toolCall);
+registerStatement("mvp:workspace_run_trigger", triggerCall);
+registerStatement("mvp:workspace_run_middleware", middlewareCall);
+registerStatement("mvp:workspace_run_addon", addonCall);
+
+// src/statements/special/ai-cloud.ts
+function vf2(v) {
+  return { value: v.value, tag: v.tag, filters: v.filters };
+}
+function aiAgentRun(a) {
+  const input2 = [];
+  if (a.args !== void 0) {
+    const argsValue = isTaggedValue(a.args) ? a.args : obj(a.args);
+    input2.push({ name: "args", ...vf2(argsValue) });
+  }
+  if (a.allowToolExecution) input2.push({ name: "allow_tool_execution", ...vf2(a.allowToolExecution) });
+  if (a.version) input2.push({ name: "version", ...vf2(a.version) });
+  const stmt = {
+    name: "mvp:call_agent",
+    context: { toolset: { id: resolveRef("toolset", a.agent) } },
+    as: a.as ?? "",
+    input: input2
+  };
+  const runtime = encodeAsyncRuntime(a.runtime);
+  if (runtime) stmt.runtime = runtime;
+  return annotate(stmt, a);
+}
+function cloudJob(a) {
+  const input2 = [];
+  if (a.image) input2.push({ name: "image", ...vf2(a.image) });
+  if (a.command) input2.push({ name: "command", ...vf2(a.command) });
+  if (a.args) input2.push({ name: "args", ...vf2(a.args) });
+  if (a.secret) input2.push({ name: "secret", ...vf2(a.secret) });
+  if (a.template) input2.push({ name: "template", ...vf2(a.template) });
+  if (a.await) input2.push({ name: "await", ...vf2(a.await) });
+  return annotate({ name: "mvp:cloud_job", context: {}, as: a.as ?? "", input: input2 }, a);
+}
+function cloudJobAwait(a) {
+  return annotate({
+    name: "mvp:cloud_job_await",
+    context: {},
+    as: a.as ?? "",
+    input: [
+      { name: "ids", ...vf2(a.ids) },
+      { name: "timeout", ...vf2(a.timeout) }
+    ]
+  }, a);
+}
+function cloudJobStatus(a) {
+  return annotate({
+    name: "mvp:cloud_job_status",
+    context: {},
+    as: a.as ?? "",
+    input: [{ name: "id", ...vf2(a.id) }]
+  }, a);
+}
+registerStatement("mvp:call_agent", aiAgentRun);
+registerStatement("mvp:cloud_job", cloudJob);
+registerStatement("mvp:cloud_job_await", cloudJobAwait);
+registerStatement("mvp:cloud_job_status", cloudJobStatus);
+
+// src/values/ignored.ts
+var IGNORED = /* @__PURE__ */ Symbol.for("xanots.input.ignored");
+function ignored(value) {
+  const marked = { ...value };
+  Object.defineProperty(marked, IGNORED, { value: true, enumerable: false });
+  return marked;
+}
+function isIgnored(value) {
+  return typeof value === "object" && value !== null && value[IGNORED] === true;
+}
+
+// src/statements/schema-dsl/enum-guard.ts
+var CHECKABLE_TAGS = /* @__PURE__ */ new Set(["const"]);
+function renderSet(values) {
+  return values.map((v) => JSON.stringify(v)).join(" | ");
+}
+function reject(statement, field, got, values) {
+  throw new Error(
+    `Statement "${statement}": field "${field}" accepts only ${renderSet(values)} \u2014 got ${JSON.stringify(got)}. Pass one of those (as a bare literal or via c.text), or a dynamic value (inp/ref/env/\u2026) if it has to be computed at runtime.`
+  );
+}
+function resolveEnumValue(statement, field, values, provided) {
+  if (typeof provided === "string") {
+    if (!values.includes(provided)) reject(statement, field, provided, values);
+    return c.text(provided);
+  }
+  if (isTaggedValue(provided)) {
+    const checkable = CHECKABLE_TAGS.has(provided.tag) && provided.filters.length === 0 && // The unconfigured box — always allowed, see the header note.
+    provided.value !== "";
+    if (checkable && !values.includes(provided.value)) {
+      reject(statement, field, provided.value, values);
+    }
+  }
+  return provided;
+}
+
+// src/statements/schema-dsl/interpret.ts
+function valueFields3(v) {
+  return { value: v.value, tag: v.tag, filters: v.filters };
+}
+function nestedValueFields(v) {
+  const fields = { value: v.value, tag: v.tag };
+  if (Array.isArray(v.filters) && v.filters.length > 0) fields.filters = v.filters;
+  return fields;
+}
+function pickDefined(o) {
+  return Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
+}
+function setPath(obj2, path, value) {
+  const parts = path.split(".");
+  let cur = obj2;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i];
+    if (typeof cur[key] !== "object" || cur[key] === null) cur[key] = {};
+    cur = cur[key];
+  }
+  cur[parts[parts.length - 1]] = value;
+}
+function assertIgnorable(statement, field, provided) {
+  if (!isIgnored(provided)) return;
+  throw new Error(
+    `Statement "${statement}": \`ignored()\` on \`${field}\` cannot be stored \u2014 the skip flag lives on an \`input[]\` entry, and this field is written into \`context\`, which has no slot for it. It would be silently dropped and the value bound anyway. Drop the \`ignored()\` wrapper, or omit the field.`
+  );
+}
+function inputEntry(name, v, full) {
+  const entry2 = { ...leanInput(name, v) };
+  const ignore = isIgnored(v);
+  if (full) {
+    entry2.ignore = ignore;
+    entry2.expand = false;
+    entry2.children = [];
+  } else if (ignore) {
+    entry2.ignore = true;
+  }
+  return entry2;
+}
+function encodeFromSpec(spec2, authored) {
+  authored = coerceLambdaFields(spec2.name, authored);
+  assertLambdaStatement(spec2.name, authored);
+  const env = spec2.envelope;
+  const context = {};
+  const input2 = [];
+  let as;
+  for (const rule of spec2.rules) {
+    let provided = authored[rule.field];
+    if (provided === void 0) {
+      if (rule.default !== void 0 && rule.type === "string") {
+        provided = rule.default;
+      } else if (rule.optional || rule.default !== void 0) {
+        continue;
+      } else {
+        throw new Error(`Statement "${spec2.name}": required field "${rule.field}" is missing.`);
+      }
+    }
+    switch (rule.route.kind) {
+      case "as":
+        as = provided;
+        break;
+      case "context-plain":
+        assertIgnorable(spec2.name, rule.field, provided);
+        setPath(context, rule.route.path, provided);
+        break;
+      case "context-spread":
+        assertIgnorable(spec2.name, rule.field, provided);
+        Object.assign(context, valueFields3(provided));
+        break;
+      case "context-nest":
+        assertIgnorable(spec2.name, rule.field, provided);
+        setPath(
+          context,
+          rule.route.path,
+          typeof provided === "string" ? provided : nestedValueFields(provided)
+        );
+        break;
+      case "context-compare":
+        setPath(
+          context,
+          rule.route.path,
+          // Every statement carrying a `comparison` rule (`precondition`, the
+          // `array.*` predicates) has its condition evaluated by the runtime,
+          // so the operator set is the runtime one. See #260.
+          encodeRuntimeCondition(provided, `${spec2.name} "${rule.field}"`)
+        );
+        break;
+      case "input": {
+        const value = rule.enum ? resolveEnumValue(spec2.name, rule.field, rule.enum, provided) : provided;
+        input2.push(inputEntry(rule.route.name, value, env?.inputFull ?? false));
+        break;
+      }
+    }
+  }
+  const stmt = { name: spec2.name, context, input: input2 };
+  if (as !== void 0) stmt.as = as;
+  else if (env?.emitAs) stmt.as = "";
+  if (env?.description) stmt.description = "";
+  const authoredOut = authored.output;
+  const asFilters = authored.asFilters;
+  if (asFilters?.length && authoredOut?.filters !== void 0) {
+    throw new Error(
+      `Statement "${spec2.name}": \`asFilters\` and \`output.filters\` both set the same filter chain. Keep \`asFilters\` and drop \`output.filters\`.`
+    );
+  }
+  annotate(stmt, {
+    disabled: typeof authored.disabled === "boolean" ? authored.disabled : void 0,
+    description: typeof authored.description === "string" ? authored.description : void 0,
+    asFilters,
+    mock: authored.mock
+  });
+  if (env?.settingsRegistry) stmt.settings_registry = [];
+  if (spec2.output) {
+    const base = env?.richOutput ? { customize: false, filters: [], items: [] } : { filters: [] };
+    const fromAnnotate = stmt.output ?? {};
+    stmt.output = { ...base, ...fromAnnotate, ...authoredOut ? pickDefined(authoredOut) : {} };
+  }
+  if (env?.addon) stmt.addon = [];
+  return stmt;
+}
+function registerSpec(spec2) {
+  const factory = (authored) => encodeFromSpec(spec2, authored);
+  registerStatement(spec2.name, factory);
+  return factory;
+}
+
+// src/statements/generated/specs.generated.ts
+var GENERATED_SPECS = [
+  { "name": "mvp:algolia_request", "output": true, "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "application_id", "type": "value", "optional": false, "route": { "kind": "input", "name": "application_id" } }, { "field": "api_key", "type": "value", "optional": false, "route": { "kind": "input", "name": "api_key" } }, { "field": "url", "type": "value", "optional": false, "route": { "kind": "input", "name": "url" } }, { "field": "method", "type": "value", "optional": true, "enum": ["POST", "GET", "DELETE", "PUT"], "route": { "kind": "input", "name": "method" } }, { "field": "payload", "type": "value", "optional": false, "route": { "kind": "input", "name": "payload" } }], "envelope": { "inputFull": true, "description": true, "settingsRegistry": true, "addon": true, "richOutput": true } },
+  { "name": "mvp:amazon_opensearch_document", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "auth_type", "type": "value", "optional": true, "default": "IAM", "enum": ["IAM", "master"], "route": { "kind": "input", "name": "auth_type" } }, { "field": "key_id", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "key_id" } }, { "field": "access_key", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "access_key" } }, { "field": "region", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "region" } }, { "field": "base_url", "type": "value", "optional": false, "route": { "kind": "input", "name": "base_url" } }, { "field": "method", "type": "value", "optional": true, "default": "GET", "enum": ["GET", "POST", "PUT", "DELETE"], "route": { "kind": "input", "name": "method" } }, { "field": "index", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "index" } }, { "field": "doc_id", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "doc_id" } }, { "field": "doc", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "doc" } }] },
+  { "name": "mvp:amazon_opensearch_query", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "auth_type", "type": "value", "optional": true, "default": "IAM", "enum": ["IAM", "master"], "route": { "kind": "input", "name": "auth_type" } }, { "field": "key_id", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "key_id" } }, { "field": "access_key", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "access_key" } }, { "field": "region", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "region" } }, { "field": "base_url", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "base_url" } }, { "field": "index", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "index" } }, { "field": "payload", "type": "value", "optional": true, "default": "{}", "route": { "kind": "input", "name": "payload" } }, { "field": "size", "type": "value", "optional": true, "default": "null", "route": { "kind": "input", "name": "size" } }, { "field": "from", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "from" } }, { "field": "included_fields", "type": "value", "optional": true, "default": "[]", "route": { "kind": "input", "name": "included_fields" } }, { "field": "return_type", "type": "value", "optional": true, "default": "search", "enum": ["search", "count"], "route": { "kind": "input", "name": "return_type" } }, { "field": "expression", "type": "value", "optional": true, "default": "[]", "route": { "kind": "input", "name": "expression" } }, { "field": "sort", "type": "value", "optional": true, "default": "[]", "route": { "kind": "input", "name": "sort" } }] },
+  { "name": "mvp:amazon_opensearch_request", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "auth_type", "type": "value", "optional": true, "default": "IAM", "enum": ["IAM", "master"], "route": { "kind": "input", "name": "auth_type" } }, { "field": "key_id", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "key_id" } }, { "field": "access_key", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "access_key" } }, { "field": "region", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "region" } }, { "field": "method", "type": "value", "optional": true, "default": "GET", "enum": ["GET", "POST", "PUT", "DELETE", "HEAD", "OPTIONS", "PATCH"], "route": { "kind": "input", "name": "method" } }, { "field": "url", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "url" } }, { "field": "query", "type": "value", "optional": true, "default": "{}", "route": { "kind": "input", "name": "query" } }] },
+  { "name": "mvp:amazon_s3_create_var_from_file_resource", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "bucket", "type": "value", "optional": false, "route": { "kind": "input", "name": "bucket" } }, { "field": "region", "type": "value", "optional": false, "route": { "kind": "input", "name": "region" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }, { "field": "secret", "type": "value", "optional": false, "route": { "kind": "input", "name": "secret" } }, { "field": "file_key", "type": "value", "optional": false, "route": { "kind": "input", "name": "file_key" } }] },
+  { "name": "mvp:amazon_s3_delete_file", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "bucket", "type": "value", "optional": false, "route": { "kind": "input", "name": "bucket" } }, { "field": "region", "type": "value", "optional": false, "route": { "kind": "input", "name": "region" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }, { "field": "secret", "type": "value", "optional": false, "route": { "kind": "input", "name": "secret" } }, { "field": "file_key", "type": "value", "optional": false, "route": { "kind": "input", "name": "file_key" } }] },
+  { "name": "mvp:amazon_s3_get_file_metadata", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "bucket", "type": "value", "optional": false, "route": { "kind": "input", "name": "bucket" } }, { "field": "region", "type": "value", "optional": false, "route": { "kind": "input", "name": "region" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }, { "field": "secret", "type": "value", "optional": false, "route": { "kind": "input", "name": "secret" } }, { "field": "file_key", "type": "value", "optional": false, "route": { "kind": "input", "name": "file_key" } }] },
+  { "name": "mvp:amazon_s3_list_directory", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "bucket", "type": "value", "optional": false, "route": { "kind": "input", "name": "bucket" } }, { "field": "region", "type": "value", "optional": false, "route": { "kind": "input", "name": "region" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }, { "field": "secret", "type": "value", "optional": false, "route": { "kind": "input", "name": "secret" } }, { "field": "prefix", "type": "value", "optional": true, "route": { "kind": "input", "name": "prefix" } }, { "field": "next_page_token", "type": "value", "optional": true, "route": { "kind": "input", "name": "next_page_token" } }] },
+  { "name": "mvp:amazon_s3_signed_url", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "bucket", "type": "value", "optional": false, "route": { "kind": "input", "name": "bucket" } }, { "field": "region", "type": "value", "optional": false, "route": { "kind": "input", "name": "region" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }, { "field": "secret", "type": "value", "optional": false, "route": { "kind": "input", "name": "secret" } }, { "field": "file_key", "type": "value", "optional": false, "route": { "kind": "input", "name": "file_key" } }, { "field": "ttl", "type": "value", "optional": true, "default": "300", "route": { "kind": "input", "name": "ttl" } }] },
+  { "name": "mvp:amazon_s3_upload_file", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "bucket", "type": "value", "optional": false, "route": { "kind": "input", "name": "bucket" } }, { "field": "region", "type": "value", "optional": false, "route": { "kind": "input", "name": "region" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }, { "field": "secret", "type": "value", "optional": false, "route": { "kind": "input", "name": "secret" } }, { "field": "file_key", "type": "value", "optional": true, "route": { "kind": "input", "name": "file_key" } }, { "field": "file", "type": "value", "optional": false, "route": { "kind": "input", "name": "file" } }, { "field": "metadata", "type": "value", "optional": true, "route": { "kind": "input", "name": "metadata" } }, { "field": "object_lock_mode", "type": "value", "optional": true, "enum": ["compliance", "governance"], "route": { "kind": "input", "name": "object_lock_mode" } }, { "field": "object_lock_retain_until", "type": "value", "optional": true, "route": { "kind": "input", "name": "object_lock_retain_until" } }] },
+  { "name": "mvp:api_request", "output": true, "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "url", "type": "value", "optional": true, "route": { "kind": "input", "name": "url" } }, { "field": "method", "type": "value", "optional": true, "enum": ["GET", "POST", "PUT", "DELETE", "HEAD", "OPTIONS", "PATCH"], "route": { "kind": "input", "name": "method" } }, { "field": "params", "type": "value", "optional": true, "route": { "kind": "input", "name": "params" } }, { "field": "headers", "type": "value", "optional": true, "route": { "kind": "input", "name": "headers" } }, { "field": "timeout", "type": "value", "optional": true, "route": { "kind": "input", "name": "timeout" } }, { "field": "follow_location", "type": "value", "optional": true, "route": { "kind": "input", "name": "follow_location" } }, { "field": "verify_host", "type": "value", "optional": true, "route": { "kind": "input", "name": "verify_host" } }, { "field": "verify_peer", "type": "value", "optional": true, "route": { "kind": "input", "name": "verify_peer" } }, { "field": "ca_certificate", "type": "value", "optional": true, "route": { "kind": "input", "name": "ca_certificate" } }, { "field": "certificate", "type": "value", "optional": true, "route": { "kind": "input", "name": "certificate" } }, { "field": "certificate_pass", "type": "value", "optional": true, "route": { "kind": "input", "name": "certificate_pass" } }, { "field": "private_key", "type": "value", "optional": true, "route": { "kind": "input", "name": "private_key" } }, { "field": "private_key_pass", "type": "value", "optional": true, "route": { "kind": "input", "name": "private_key_pass" } }], "envelope": { "inputFull": true, "description": true, "settingsRegistry": true, "addon": true, "richOutput": true } },
+  { "name": "mvp:array_difference", "rules": [{ "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }, { "field": "expr", "type": "value", "optional": true, "default": "null", "route": { "kind": "context-nest", "path": "left" } }, { "field": "value", "type": "value", "optional": true, "default": "[]", "route": { "kind": "context-nest", "path": "right" } }, { "field": "by", "type": "value", "optional": true, "default": "null", "route": { "kind": "context-nest", "path": "transform_value" } }] },
+  { "name": "mvp:array_every", "output": true, "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "null", "route": { "kind": "context-nest", "path": "array" } }, { "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }, { "field": "if", "type": "comparison", "optional": true, "default": "null", "route": { "kind": "context-compare", "path": "expr" } }] },
+  { "name": "mvp:array_filter", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "null", "route": { "kind": "context-nest", "path": "array" } }, { "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }, { "field": "if", "type": "comparison", "optional": true, "default": "null", "route": { "kind": "context-compare", "path": "expr" } }] },
+  { "name": "mvp:array_filter_count", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "null", "route": { "kind": "context-nest", "path": "array" } }, { "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }, { "field": "if", "type": "comparison", "optional": true, "default": "null", "route": { "kind": "context-compare", "path": "expr" } }] },
+  { "name": "mvp:array_find", "output": true, "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "null", "route": { "kind": "context-nest", "path": "array" } }, { "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }, { "field": "if", "type": "comparison", "optional": true, "default": "null", "route": { "kind": "context-compare", "path": "expr" } }] },
+  { "name": "mvp:array_find_index", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "null", "route": { "kind": "context-nest", "path": "array" } }, { "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }, { "field": "if", "type": "comparison", "optional": true, "default": "null", "route": { "kind": "context-compare", "path": "expr" } }] },
+  { "name": "mvp:array_group_by", "rules": [{ "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }, { "field": "expr", "type": "value", "optional": true, "default": "null", "route": { "kind": "context-nest", "path": "collection" } }, { "field": "by", "type": "value", "optional": true, "default": "null", "route": { "kind": "context-nest", "path": "transform_value" } }] },
+  { "name": "mvp:array_has", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "null", "route": { "kind": "context-nest", "path": "array" } }, { "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }, { "field": "if", "type": "comparison", "optional": true, "default": "null", "route": { "kind": "context-compare", "path": "expr" } }] },
+  { "name": "mvp:array_intersection", "rules": [{ "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }, { "field": "expr", "type": "value", "optional": true, "default": "null", "route": { "kind": "context-nest", "path": "left" } }, { "field": "value", "type": "value", "optional": true, "default": "[]", "route": { "kind": "context-nest", "path": "right" } }, { "field": "by", "type": "value", "optional": true, "route": { "kind": "context-nest", "path": "transform_value" } }] },
+  { "name": "mvp:array_merge", "argNameIsVar": true, "output": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "value", "type": "value", "optional": true, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:array_partition", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "null", "route": { "kind": "context-nest", "path": "array" } }, { "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }, { "field": "if", "type": "comparison", "optional": true, "default": "null", "route": { "kind": "context-compare", "path": "expr" } }] },
+  { "name": "mvp:array_pop", "argNameIsVar": true, "output": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }] },
+  { "name": "mvp:array_push", "argNameIsVar": true, "output": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:array_shift", "argNameIsVar": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }] },
+  { "name": "mvp:array_unshift", "argNameIsVar": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:async_function_await", "rules": [{ "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }, { "field": "ids", "type": "value", "optional": true, "default": "[]", "route": { "kind": "input", "name": "ids" } }, { "field": "timeout", "type": "value", "optional": true, "default": "10", "route": { "kind": "input", "name": "timeout" } }] },
+  { "name": "mvp:azure_blob_storage_create_var_from_file_resource", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "account_name", "type": "value", "optional": false, "route": { "kind": "input", "name": "account_name" } }, { "field": "account_key", "type": "value", "optional": false, "route": { "kind": "input", "name": "account_key" } }, { "field": "container_name", "type": "value", "optional": false, "route": { "kind": "input", "name": "container_name" } }, { "field": "filePath", "type": "value", "optional": false, "route": { "kind": "input", "name": "filePath" } }] },
+  { "name": "mvp:azure_blob_storage_delete_file", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "account_name", "type": "value", "optional": false, "route": { "kind": "input", "name": "account_name" } }, { "field": "account_key", "type": "value", "optional": false, "route": { "kind": "input", "name": "account_key" } }, { "field": "container_name", "type": "value", "optional": false, "route": { "kind": "input", "name": "container_name" } }, { "field": "filePath", "type": "value", "optional": false, "route": { "kind": "input", "name": "filePath" } }] },
+  { "name": "mvp:azure_blob_storage_get_file_metadata", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "account_name", "type": "value", "optional": false, "route": { "kind": "input", "name": "account_name" } }, { "field": "account_key", "type": "value", "optional": false, "route": { "kind": "input", "name": "account_key" } }, { "field": "container_name", "type": "value", "optional": false, "route": { "kind": "input", "name": "container_name" } }, { "field": "filePath", "type": "value", "optional": false, "route": { "kind": "input", "name": "filePath" } }] },
+  { "name": "mvp:azure_blob_storage_list_directory", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "account_name", "type": "value", "optional": false, "route": { "kind": "input", "name": "account_name" } }, { "field": "account_key", "type": "value", "optional": false, "route": { "kind": "input", "name": "account_key" } }, { "field": "container_name", "type": "value", "optional": false, "route": { "kind": "input", "name": "container_name" } }, { "field": "path", "type": "value", "optional": true, "route": { "kind": "input", "name": "path" } }] },
+  { "name": "mvp:azure_blob_storage_signed_url", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "account_name", "type": "value", "optional": false, "route": { "kind": "input", "name": "account_name" } }, { "field": "account_key", "type": "value", "optional": false, "route": { "kind": "input", "name": "account_key" } }, { "field": "container_name", "type": "value", "optional": false, "route": { "kind": "input", "name": "container_name" } }, { "field": "path", "type": "value", "optional": false, "route": { "kind": "input", "name": "path" } }, { "field": "ttl", "type": "value", "optional": true, "route": { "kind": "input", "name": "ttl" } }] },
+  { "name": "mvp:azure_blob_storage_upload_file", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "account_name", "type": "value", "optional": false, "route": { "kind": "input", "name": "account_name" } }, { "field": "account_key", "type": "value", "optional": false, "route": { "kind": "input", "name": "account_key" } }, { "field": "container_name", "type": "value", "optional": false, "route": { "kind": "input", "name": "container_name" } }, { "field": "filePath", "type": "value", "optional": false, "route": { "kind": "input", "name": "filePath" } }, { "field": "file", "type": "value", "optional": false, "route": { "kind": "input", "name": "file" } }, { "field": "metadata", "type": "value", "optional": true, "route": { "kind": "input", "name": "metadata" } }] },
+  { "name": "mvp:bitwise_and", "argNameIsVar": true, "output": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:bitwise_or", "argNameIsVar": true, "output": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:bitwise_xor", "argNameIsVar": true, "output": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:calculate_geo_distance", "rules": [{ "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }, { "field": "latitude_1", "type": "value", "optional": true, "route": { "kind": "input", "name": "latitude_1" } }, { "field": "longitude_1", "type": "value", "optional": true, "route": { "kind": "input", "name": "longitude_1" } }, { "field": "latitude_2", "type": "value", "optional": true, "route": { "kind": "input", "name": "latitude_2" } }, { "field": "longitude_2", "type": "value", "optional": true, "route": { "kind": "input", "name": "longitude_2" } }] },
+  { "name": "mvp:check_pass", "output": true, "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "text_password", "type": "value", "optional": true, "route": { "kind": "input", "name": "text_password" } }, { "field": "hash_password", "type": "value", "optional": true, "route": { "kind": "input", "name": "hash_password" } }], "envelope": { "inputFull": true, "description": true, "settingsRegistry": true, "addon": true, "richOutput": true } },
+  { "name": "mvp:connect_webflow_api_request", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "path", "type": "value", "optional": true, "route": { "kind": "input", "name": "path" } }, { "field": "method", "type": "value", "optional": true, "route": { "kind": "input", "name": "method" } }, { "field": "params", "type": "value", "optional": true, "route": { "kind": "input", "name": "params" } }, { "field": "headers", "type": "value", "optional": true, "route": { "kind": "input", "name": "headers" } }, { "field": "timeout", "type": "value", "optional": true, "route": { "kind": "input", "name": "timeout" } }, { "field": "follow_location", "type": "value", "optional": true, "route": { "kind": "input", "name": "follow_location" } }, { "field": "verify_host", "type": "value", "optional": true, "route": { "kind": "input", "name": "verify_host" } }, { "field": "verify_peer", "type": "value", "optional": true, "route": { "kind": "input", "name": "verify_peer" } }, { "field": "ca_certificate", "type": "value", "optional": true, "route": { "kind": "input", "name": "ca_certificate" } }, { "field": "certificate", "type": "value", "optional": true, "route": { "kind": "input", "name": "certificate" } }, { "field": "certificate_pass", "type": "value", "optional": true, "route": { "kind": "input", "name": "certificate_pass" } }, { "field": "private_key", "type": "value", "optional": true, "route": { "kind": "input", "name": "private_key" } }, { "field": "private_key_pass", "type": "value", "optional": true, "route": { "kind": "input", "name": "private_key_pass" } }] },
+  { "name": "mvp:create_attachment", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }, { "field": "access", "type": "string", "optional": true, "default": "public", "route": { "kind": "context-plain", "path": "access" } }, { "field": "filename", "type": "value", "optional": true, "route": { "kind": "context-nest", "path": "filename" } }, { "field": "include_meta", "type": "boolean", "optional": true, "route": { "kind": "context-plain", "path": "include_meta" } }, { "field": "type", "type": "value", "optional": true, "route": { "kind": "input", "name": "type" } }] },
+  { "name": "mvp:create_audio", "output": true, "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }, { "field": "access", "type": "string", "optional": true, "default": "public", "route": { "kind": "context-plain", "path": "access" } }, { "field": "filename", "type": "value", "optional": true, "route": { "kind": "context-nest", "path": "filename" } }] },
+  { "name": "mvp:create_file_resource", "output": true, "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "filename", "type": "value", "optional": false, "route": { "kind": "input", "name": "filename" } }, { "field": "filedata", "type": "value", "optional": false, "route": { "kind": "input", "name": "filedata" } }], "envelope": { "inputFull": true, "description": true, "settingsRegistry": true, "addon": true, "richOutput": true } },
+  { "name": "mvp:create_image", "output": true, "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }, { "field": "access", "type": "string", "optional": true, "default": "public", "route": { "kind": "context-plain", "path": "access" } }, { "field": "filename", "type": "value", "optional": true, "route": { "kind": "context-nest", "path": "filename" } }] },
+  { "name": "mvp:create_var_from_file_resource", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:create_video", "output": true, "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }, { "field": "access", "type": "string", "optional": true, "default": "public", "route": { "kind": "context-plain", "path": "access" } }, { "field": "filename", "type": "value", "optional": true, "route": { "kind": "context-nest", "path": "filename" } }] },
+  { "name": "mvp:crypto_create_ec_key", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "curve", "type": "value", "optional": true, "enum": ["P-256", "P-384", "P-521"], "route": { "kind": "input", "name": "curve" } }, { "field": "format", "type": "value", "optional": true, "enum": ["object", "base64"], "route": { "kind": "input", "name": "format" } }] },
+  { "name": "mvp:crypto_create_octet_key", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "bits", "type": "value", "optional": true, "route": { "kind": "input", "name": "bits" } }, { "field": "format", "type": "value", "optional": true, "enum": ["object", "base64"], "route": { "kind": "input", "name": "format" } }] },
+  { "name": "mvp:crypto_create_rsa_key", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "bits", "type": "value", "optional": true, "route": { "kind": "input", "name": "bits" } }, { "field": "format", "type": "value", "optional": true, "enum": ["object", "base64"], "route": { "kind": "input", "name": "format" } }] },
+  { "name": "mvp:crypto_decrypt", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "data", "type": "value", "optional": true, "route": { "kind": "input", "name": "data" } }, { "field": "algorithm", "type": "value", "optional": true, "enum": ["aes-128-cbc", "aes-192-cbc", "aes-256-cbc", "aes-128-gcm", "aes-192-gcm", "aes-256-gcm"], "route": { "kind": "input", "name": "algorithm" } }, { "field": "key", "type": "value", "optional": true, "route": { "kind": "input", "name": "key" } }, { "field": "iv", "type": "value", "optional": true, "route": { "kind": "input", "name": "iv" } }] },
+  { "name": "mvp:crypto_encrypt", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "data", "type": "value", "optional": true, "route": { "kind": "input", "name": "data" } }, { "field": "algorithm", "type": "value", "optional": true, "enum": ["aes-128-cbc", "aes-192-cbc", "aes-256-cbc", "aes-128-gcm", "aes-192-gcm", "aes-256-gcm"], "route": { "kind": "input", "name": "algorithm" } }, { "field": "key", "type": "value", "optional": true, "route": { "kind": "input", "name": "key" } }, { "field": "iv", "type": "value", "optional": true, "route": { "kind": "input", "name": "iv" } }] },
+  { "name": "mvp:crypto_jwe_decode2", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "token", "type": "value", "optional": true, "route": { "kind": "input", "name": "token" } }, { "field": "key", "type": "value", "optional": true, "route": { "kind": "input", "name": "key" } }, { "field": "check_claims", "type": "value", "optional": true, "route": { "kind": "input", "name": "check_claims" } }, { "field": "key_algorithm", "type": "value", "optional": true, "enum": ["A128KW", "A192KW", "A256KW", "A128GCMKW", "A192GCMKW", "A256GCMKW", "ECDH-ES+A128KW", "ECDH-ES+A192KW", "ECDH-ES+A256KW"], "route": { "kind": "input", "name": "key_algorithm" } }, { "field": "content_algorithm", "type": "value", "optional": true, "enum": ["A128GCM", "A192GCM", "A256GCM", "A128CBC-HS256", "A192CBC-HS384", "A256CBC-HS512"], "route": { "kind": "input", "name": "content_algorithm" } }, { "field": "timeDrift", "type": "value", "optional": true, "route": { "kind": "input", "name": "timeDrift" } }] },
+  { "name": "mvp:crypto_jwe_encode3", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "headers", "type": "value", "optional": true, "route": { "kind": "input", "name": "headers" } }, { "field": "claims", "type": "value", "optional": true, "route": { "kind": "input", "name": "claims" } }, { "field": "key", "type": "value", "optional": true, "route": { "kind": "input", "name": "key" } }, { "field": "key_algorithm", "type": "value", "optional": true, "enum": ["A128KW", "A192KW", "A256KW", "A128GCMKW", "A192GCMKW", "A256GCMKW", "ECDH-ES+A128KW", "ECDH-ES+A192KW", "ECDH-ES+A256KW"], "route": { "kind": "input", "name": "key_algorithm" } }, { "field": "content_algorithm", "type": "value", "optional": true, "enum": ["A128GCM", "A192GCM", "A256GCM", "A128CBC-HS256", "A192CBC-HS384", "A256CBC-HS512"], "route": { "kind": "input", "name": "content_algorithm" } }, { "field": "ttl", "type": "value", "optional": true, "route": { "kind": "input", "name": "ttl" } }] },
+  { "name": "mvp:crypto_jws_decode2", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "token", "type": "value", "optional": true, "route": { "kind": "input", "name": "token" } }, { "field": "key", "type": "value", "optional": true, "route": { "kind": "input", "name": "key" } }, { "field": "check_claims", "type": "value", "optional": true, "route": { "kind": "input", "name": "check_claims" } }, { "field": "signature_algorithm", "type": "value", "optional": true, "enum": ["PS256", "PS384", "PS512", "RS256", "RS384", "RS512", "HS256", "HS384", "HS512", "ES256", "ES384", "ES512"], "route": { "kind": "input", "name": "signature_algorithm" } }, { "field": "timeDrift", "type": "value", "optional": true, "route": { "kind": "input", "name": "timeDrift" } }] },
+  { "name": "mvp:crypto_jws_encode2", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "headers", "type": "value", "optional": true, "route": { "kind": "input", "name": "headers" } }, { "field": "claims", "type": "value", "optional": true, "route": { "kind": "input", "name": "claims" } }, { "field": "key", "type": "value", "optional": true, "route": { "kind": "input", "name": "key" } }, { "field": "signature_algorithm", "type": "value", "optional": true, "enum": ["PS256", "PS384", "PS512", "RS256", "RS384", "RS512", "HS256", "HS384", "HS512", "ES256", "ES384", "ES512"], "route": { "kind": "input", "name": "signature_algorithm" } }, { "field": "ttl", "type": "value", "optional": true, "route": { "kind": "input", "name": "ttl" } }] },
+  { "name": "mvp:csv_stream", "output": true, "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }, { "field": "separator", "type": "value", "optional": true, "default": ",", "route": { "kind": "input", "name": "separator" } }, { "field": "enclosure", "type": "value", "optional": true, "default": '\\"', "route": { "kind": "input", "name": "enclosure" } }, { "field": "escape_char", "type": "value", "optional": true, "default": '\\"', "route": { "kind": "input", "name": "escape_char" } }], "envelope": { "inputFull": true } },
+  { "name": "mvp:datadog_log", "rules": [{ "field": "message", "type": "value", "optional": true, "route": { "kind": "input", "name": "message" } }, { "field": "status", "type": "value", "optional": true, "enum": ["debug", "info", "notice", "warn", "error", "critical", "alert", "emergency"], "route": { "kind": "input", "name": "status" } }, { "field": "attributes", "type": "value", "optional": true, "route": { "kind": "input", "name": "attributes" } }, { "field": "service", "type": "value", "optional": true, "route": { "kind": "input", "name": "service" } }, { "field": "source", "type": "value", "optional": true, "route": { "kind": "input", "name": "source" } }, { "field": "env", "type": "value", "optional": true, "route": { "kind": "input", "name": "env" } }, { "field": "hostname", "type": "value", "optional": true, "route": { "kind": "input", "name": "hostname" } }, { "field": "tags", "type": "value", "optional": true, "route": { "kind": "input", "name": "tags" } }, { "field": "timestamp", "type": "value", "optional": true, "route": { "kind": "input", "name": "timestamp" } }, { "field": "connection", "type": "value", "optional": true, "route": { "kind": "input", "name": "connection" } }] },
+  { "name": "mvp:datadog_log_bulk", "rules": [{ "field": "entries", "type": "value", "optional": false, "route": { "kind": "input", "name": "entries" } }, { "field": "connection", "type": "value", "optional": true, "route": { "kind": "input", "name": "connection" } }] },
+  { "name": "mvp:datadog_metric", "rules": [{ "field": "metric", "type": "value", "optional": true, "route": { "kind": "input", "name": "metric" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "input", "name": "value" } }, { "field": "type", "type": "value", "optional": true, "enum": ["count", "gauge", "rate", "histogram", "distribution"], "route": { "kind": "input", "name": "type" } }, { "field": "tags", "type": "value", "optional": true, "route": { "kind": "input", "name": "tags" } }, { "field": "service", "type": "value", "optional": true, "route": { "kind": "input", "name": "service" } }, { "field": "source", "type": "value", "optional": true, "route": { "kind": "input", "name": "source" } }, { "field": "env", "type": "value", "optional": true, "route": { "kind": "input", "name": "env" } }, { "field": "hostname", "type": "value", "optional": true, "route": { "kind": "input", "name": "hostname" } }, { "field": "timestamp", "type": "value", "optional": true, "route": { "kind": "input", "name": "timestamp" } }, { "field": "connection", "type": "value", "optional": true, "route": { "kind": "input", "name": "connection" } }] },
+  { "name": "mvp:datadog_metric_bulk", "rules": [{ "field": "entries", "type": "value", "optional": false, "route": { "kind": "input", "name": "entries" } }, { "field": "connection", "type": "value", "optional": true, "route": { "kind": "input", "name": "connection" } }] },
+  { "name": "mvp:debug_log", "rules": [{ "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:delete_file", "output": true, "rules": [{ "field": "pathname", "type": "value", "optional": false, "route": { "kind": "input", "name": "pathname" } }], "envelope": { "inputFull": true, "emitAs": true, "description": true, "settingsRegistry": true, "addon": true, "richOutput": true } },
+  { "name": "mvp:die", "rules": [{ "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:elasticsearch_document", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "auth_type", "type": "value", "optional": true, "default": "API Key", "enum": ["Basic", "Bearer", "API Key"], "route": { "kind": "input", "name": "auth_type" } }, { "field": "key_id", "type": "value", "optional": false, "route": { "kind": "input", "name": "key_id" } }, { "field": "access_key", "type": "value", "optional": false, "route": { "kind": "input", "name": "access_key" } }, { "field": "base_url", "type": "value", "optional": false, "route": { "kind": "input", "name": "base_url" } }, { "field": "index", "type": "value", "optional": false, "route": { "kind": "input", "name": "index" } }, { "field": "method", "type": "value", "optional": true, "default": "GET", "enum": ["GET", "POST", "PUT", "DELETE"], "route": { "kind": "input", "name": "method" } }, { "field": "doc_id", "type": "value", "optional": false, "route": { "kind": "input", "name": "doc_id" } }, { "field": "doc", "type": "value", "optional": false, "route": { "kind": "input", "name": "doc" } }] },
+  { "name": "mvp:elasticsearch_query", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "auth_type", "type": "value", "optional": true, "default": "API Key", "enum": ["Basic", "Bearer", "API Key"], "route": { "kind": "input", "name": "auth_type" } }, { "field": "key_id", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "key_id" } }, { "field": "access_key", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "access_key" } }, { "field": "base_url", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "base_url" } }, { "field": "index", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "index" } }, { "field": "payload", "type": "value", "optional": true, "default": "{}", "route": { "kind": "input", "name": "payload" } }, { "field": "size", "type": "value", "optional": true, "default": "null", "route": { "kind": "input", "name": "size" } }, { "field": "from", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "from" } }, { "field": "included_fields", "type": "value", "optional": true, "default": "[]", "route": { "kind": "input", "name": "included_fields" } }, { "field": "return_type", "type": "value", "optional": true, "default": "search", "enum": ["search", "count"], "route": { "kind": "input", "name": "return_type" } }, { "field": "expression", "type": "value", "optional": true, "default": "[]", "route": { "kind": "input", "name": "expression" } }, { "field": "sort", "type": "value", "optional": true, "default": "[]", "route": { "kind": "input", "name": "sort" } }] },
+  { "name": "mvp:elasticsearch_request", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "auth_type", "type": "value", "optional": true, "default": "API Key", "enum": ["Basic", "Bearer", "API Key"], "route": { "kind": "input", "name": "auth_type" } }, { "field": "key_id", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "key_id" } }, { "field": "access_key", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "access_key" } }, { "field": "method", "type": "value", "optional": true, "default": "POST", "enum": ["POST", "GET", "PUT", "DELETE", "PATCH"], "route": { "kind": "input", "name": "method" } }, { "field": "url", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "url" } }, { "field": "payload", "type": "value", "optional": true, "default": "{}", "route": { "kind": "input", "name": "payload" } }] },
+  { "name": "mvp:generate_pass", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "character_count", "type": "value", "optional": true, "route": { "kind": "input", "name": "character_count" } }, { "field": "require_lowercase", "type": "value", "optional": true, "route": { "kind": "input", "name": "require_lowercase" } }, { "field": "require_uppercase", "type": "value", "optional": true, "route": { "kind": "input", "name": "require_uppercase" } }, { "field": "require_digit", "type": "value", "optional": true, "route": { "kind": "input", "name": "require_digit" } }, { "field": "require_symbol", "type": "value", "optional": true, "route": { "kind": "input", "name": "require_symbol" } }, { "field": "symbol_whitelist", "type": "value", "optional": true, "route": { "kind": "input", "name": "symbol_whitelist" } }] },
+  { "name": "mvp:get_all_input", "rules": [{ "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }] },
+  { "name": "mvp:get_env", "rules": [{ "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }] },
+  { "name": "mvp:get_session", "rules": [{ "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }] },
+  { "name": "mvp:get_vars", "rules": [{ "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }] },
+  { "name": "mvp:google_cloud_storage_create_var_from_file_resource", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "service_account", "type": "value", "optional": false, "route": { "kind": "input", "name": "service_account" } }, { "field": "bucket", "type": "value", "optional": false, "route": { "kind": "input", "name": "bucket" } }, { "field": "filePath", "type": "value", "optional": false, "route": { "kind": "input", "name": "filePath" } }] },
+  { "name": "mvp:google_cloud_storage_delete_file", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "service_account", "type": "value", "optional": false, "route": { "kind": "input", "name": "service_account" } }, { "field": "bucket", "type": "value", "optional": false, "route": { "kind": "input", "name": "bucket" } }, { "field": "filePath", "type": "value", "optional": false, "route": { "kind": "input", "name": "filePath" } }] },
+  { "name": "mvp:google_cloud_storage_get_file_metadata", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "service_account", "type": "value", "optional": false, "route": { "kind": "input", "name": "service_account" } }, { "field": "bucket", "type": "value", "optional": false, "route": { "kind": "input", "name": "bucket" } }, { "field": "filePath", "type": "value", "optional": false, "route": { "kind": "input", "name": "filePath" } }] },
+  { "name": "mvp:google_cloud_storage_list_directory", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "service_account", "type": "value", "optional": false, "route": { "kind": "input", "name": "service_account" } }, { "field": "bucket", "type": "value", "optional": false, "route": { "kind": "input", "name": "bucket" } }, { "field": "path", "type": "value", "optional": false, "route": { "kind": "input", "name": "path" } }] },
+  { "name": "mvp:google_cloud_storage_signed_url", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "service_account", "type": "value", "optional": false, "route": { "kind": "input", "name": "service_account" } }, { "field": "bucket", "type": "value", "optional": false, "route": { "kind": "input", "name": "bucket" } }, { "field": "filePath", "type": "value", "optional": false, "route": { "kind": "input", "name": "filePath" } }, { "field": "method", "type": "value", "optional": true, "enum": ["GET", "POST"], "route": { "kind": "input", "name": "method" } }, { "field": "ttl", "type": "value", "optional": true, "route": { "kind": "input", "name": "ttl" } }] },
+  { "name": "mvp:google_cloud_storage_upload_file", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "service_account", "type": "value", "optional": false, "route": { "kind": "input", "name": "service_account" } }, { "field": "bucket", "type": "value", "optional": false, "route": { "kind": "input", "name": "bucket" } }, { "field": "filePath", "type": "value", "optional": false, "route": { "kind": "input", "name": "filePath" } }, { "field": "file", "type": "value", "optional": false, "route": { "kind": "input", "name": "file" } }, { "field": "metadata", "type": "value", "optional": true, "route": { "kind": "input", "name": "metadata" } }] },
+  { "name": "mvp:ipaddress_lookup", "rules": [{ "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "input", "name": "ip" } }] },
+  { "name": "mvp:jsonl_stream", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:lambda", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "code", "type": "value", "optional": true, "route": { "kind": "input", "name": "code" } }, { "field": "timeout", "type": "value", "optional": true, "route": { "kind": "input", "name": "timeout" } }] },
+  { "name": "mvp:math_add", "argNameIsVar": true, "output": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:math_div", "argNameIsVar": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:math_mod", "argNameIsVar": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:math_mul", "argNameIsVar": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:math_sub", "argNameIsVar": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:mcp_call_tool", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "url", "type": "value", "optional": true, "route": { "kind": "input", "name": "url" } }, { "field": "bearer_token", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "bearer_token" } }, { "field": "connection_type", "type": "value", "optional": true, "default": "sse", "enum": ["sse", "stream"], "route": { "kind": "input", "name": "connection_type" } }, { "field": "tool", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "tool_name" } }, { "field": "args", "type": "value", "optional": true, "route": { "kind": "input", "name": "args" } }] },
+  { "name": "mvp:mcp_list_tools", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "url", "type": "value", "optional": true, "route": { "kind": "input", "name": "url" } }, { "field": "bearer_token", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "bearer_token" } }, { "field": "connection_type", "type": "value", "optional": true, "default": "sse", "enum": ["sse", "stream"], "route": { "kind": "input", "name": "connection_type" } }] },
+  { "name": "mvp:mcp_server_details", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "url", "type": "value", "optional": true, "route": { "kind": "input", "name": "url" } }, { "field": "bearer_token", "type": "value", "optional": true, "default": "", "route": { "kind": "input", "name": "bearer_token" } }, { "field": "connection_type", "type": "value", "optional": true, "default": "sse", "enum": ["sse", "stream"], "route": { "kind": "input", "name": "connection_type" } }] },
+  { "name": "mvp:microservice_request", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "host", "type": "value", "optional": false, "route": { "kind": "input", "name": "host" } }, { "field": "path", "type": "value", "optional": false, "route": { "kind": "input", "name": "path" } }, { "field": "method", "type": "value", "optional": true, "enum": ["GET", "POST", "PUT", "DELETE", "HEAD", "OPTIONS", "PATCH"], "route": { "kind": "input", "name": "method" } }, { "field": "params", "type": "value", "optional": true, "route": { "kind": "input", "name": "params" } }, { "field": "headers", "type": "value", "optional": false, "route": { "kind": "input", "name": "headers" } }, { "field": "timeout", "type": "value", "optional": true, "route": { "kind": "input", "name": "timeout" } }, { "field": "follow_location", "type": "value", "optional": true, "route": { "kind": "input", "name": "follow_location" } }] },
+  { "name": "mvp:object_entries", "output": true, "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "object" } }] },
+  { "name": "mvp:object_keys", "output": true, "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "object" } }] },
+  { "name": "mvp:object_values", "output": true, "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "object" } }] },
+  { "name": "mvp:precondition", "rules": [{ "field": "expr", "type": "comparison", "optional": true, "default": "null", "route": { "kind": "context-compare", "path": "expr" } }, { "field": "error_type", "type": "string", "optional": true, "default": "standard", "route": { "kind": "context-plain", "path": "error_type" } }, { "field": "error", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "error" } }, { "field": "payload", "type": "value", "optional": true, "route": { "kind": "context-nest", "path": "payload" } }] },
+  { "name": "mvp:rand", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "min", "type": "value", "optional": true, "route": { "kind": "input", "name": "min" } }, { "field": "max", "type": "value", "optional": true, "route": { "kind": "input", "name": "max" } }] },
+  { "name": "mvp:random_bytes", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "length", "type": "value", "optional": true, "route": { "kind": "input", "name": "length" } }] },
+  { "name": "mvp:redis_countlist", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }] },
+  { "name": "mvp:redis_decr", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }, { "field": "by", "type": "value", "optional": true, "route": { "kind": "input", "name": "by" } }] },
+  { "name": "mvp:redis_del", "rules": [{ "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }] },
+  { "name": "mvp:redis_get", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }] },
+  { "name": "mvp:redis_has", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }] },
+  { "name": "mvp:redis_incr", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }, { "field": "by", "type": "value", "optional": true, "route": { "kind": "input", "name": "by" } }] },
+  { "name": "mvp:redis_keys", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "search", "type": "value", "optional": false, "route": { "kind": "input", "name": "search" } }] },
+  { "name": "mvp:redis_poplist", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }, { "field": "count", "type": "value", "optional": true, "route": { "kind": "input", "name": "count" } }] },
+  { "name": "mvp:redis_pushlist", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "input", "name": "value" } }] },
+  { "name": "mvp:redis_rangelist", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }, { "field": "start", "type": "value", "optional": true, "route": { "kind": "input", "name": "start" } }, { "field": "stop", "type": "value", "optional": true, "route": { "kind": "input", "name": "stop" } }] },
+  { "name": "mvp:redis_ratelimit", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }, { "field": "max", "type": "value", "optional": true, "route": { "kind": "input", "name": "max" } }, { "field": "ttl", "type": "value", "optional": true, "route": { "kind": "input", "name": "ttl" } }, { "field": "error", "type": "value", "optional": true, "route": { "kind": "input", "name": "error" } }] },
+  { "name": "mvp:redis_remove_list", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "input", "name": "value" } }, { "field": "count", "type": "value", "optional": true, "route": { "kind": "input", "name": "count" } }] },
+  { "name": "mvp:redis_set", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }, { "field": "data", "type": "value", "optional": false, "route": { "kind": "input", "name": "data" } }, { "field": "ttl", "type": "value", "optional": true, "route": { "kind": "input", "name": "ttl" } }, { "field": "create_only", "type": "value", "optional": true, "route": { "kind": "input", "name": "create_only" } }] },
+  { "name": "mvp:redis_shiftlist", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }, { "field": "count", "type": "value", "optional": true, "route": { "kind": "input", "name": "count" } }] },
+  { "name": "mvp:redis_unshiftlist", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "key", "type": "value", "optional": false, "route": { "kind": "input", "name": "key" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "input", "name": "value" } }] },
+  { "name": "mvp:send_email", "rules": [{ "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }, { "field": "service_provider", "type": "value", "optional": true, "enum": ["resend", "xano"], "route": { "kind": "input", "name": "service_provider" } }, { "field": "api_key", "type": "value", "optional": true, "route": { "kind": "input", "name": "api_key" } }, { "field": "subject", "type": "value", "optional": true, "route": { "kind": "input", "name": "subject" } }, { "field": "message", "type": "value", "optional": true, "route": { "kind": "input", "name": "message" } }, { "field": "to", "type": "value", "optional": true, "route": { "kind": "input", "name": "to" } }, { "field": "bcc", "type": "value", "optional": true, "route": { "kind": "input", "name": "bcc" } }, { "field": "cc", "type": "value", "optional": true, "route": { "kind": "input", "name": "cc" } }, { "field": "from", "type": "value", "optional": true, "route": { "kind": "input", "name": "from" } }, { "field": "reply_to", "type": "value", "optional": true, "route": { "kind": "input", "name": "reply_to" } }, { "field": "scheduled_at", "type": "value", "optional": true, "route": { "kind": "input", "name": "scheduled_at" } }] },
+  { "name": "mvp:set_data_source", "rules": [{ "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }, { "field": "workspace_id", "type": "value", "optional": true, "route": { "kind": "input", "name": "workspace_id" } }] },
+  { "name": "mvp:setheader", "rules": [{ "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }, { "field": "duplicates", "type": "string", "optional": true, "default": "replace", "route": { "kind": "context-plain", "path": "duplicates" } }] },
+  { "name": "mvp:sleep", "rules": [{ "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:streaming_api_request", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "url", "type": "value", "optional": true, "route": { "kind": "input", "name": "url" } }, { "field": "method", "type": "value", "optional": true, "route": { "kind": "input", "name": "method" } }, { "field": "params", "type": "value", "optional": true, "route": { "kind": "input", "name": "params" } }, { "field": "headers", "type": "value", "optional": true, "route": { "kind": "input", "name": "headers" } }, { "field": "timeout", "type": "value", "optional": true, "route": { "kind": "input", "name": "timeout" } }, { "field": "follow_location", "type": "value", "optional": true, "route": { "kind": "input", "name": "follow_location" } }, { "field": "verify_host", "type": "value", "optional": true, "route": { "kind": "input", "name": "verify_host" } }, { "field": "verify_peer", "type": "value", "optional": true, "route": { "kind": "input", "name": "verify_peer" } }, { "field": "ca_certificate", "type": "value", "optional": true, "route": { "kind": "input", "name": "ca_certificate" } }, { "field": "certificate", "type": "value", "optional": true, "route": { "kind": "input", "name": "certificate" } }, { "field": "certificate_pass", "type": "value", "optional": true, "route": { "kind": "input", "name": "certificate_pass" } }, { "field": "private_key", "type": "value", "optional": true, "route": { "kind": "input", "name": "private_key" } }, { "field": "private_key_pass", "type": "value", "optional": true, "route": { "kind": "input", "name": "private_key_pass" } }] },
+  { "name": "mvp:streaming_api_response", "rules": [{ "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:template_string", "rules": [{ "field": "as", "type": "string", "optional": true, "default": "", "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "input", "name": "template" } }] },
+  { "name": "mvp:test_expect_to_be_defined", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }] },
+  { "name": "mvp:test_expect_to_be_empty", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }] },
+  { "name": "mvp:test_expect_to_be_false", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }] },
+  { "name": "mvp:test_expect_to_be_greater_than", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }, { "field": "value", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value2" } }] },
+  { "name": "mvp:test_expect_to_be_in_the_future", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }] },
+  { "name": "mvp:test_expect_to_be_in_the_past", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }] },
+  { "name": "mvp:test_expect_to_be_less_than", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }, { "field": "value", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value2" } }] },
+  { "name": "mvp:test_expect_to_be_null", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }] },
+  { "name": "mvp:test_expect_to_be_true", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }] },
+  { "name": "mvp:test_expect_to_be_within", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }, { "field": "min", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value2" } }, { "field": "max", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value3" } }] },
+  { "name": "mvp:test_expect_to_contain", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }, { "field": "value", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value2" } }] },
+  { "name": "mvp:test_expect_to_end_with", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }, { "field": "value", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value2" } }] },
+  { "name": "mvp:test_expect_to_equal", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }, { "field": "value", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value2" } }] },
+  { "name": "mvp:test_expect_to_match", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }, { "field": "value", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value2" } }] },
+  { "name": "mvp:test_expect_to_not_be_defined", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }] },
+  { "name": "mvp:test_expect_to_not_be_null", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }] },
+  { "name": "mvp:test_expect_to_not_equal", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }, { "field": "value", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value2" } }] },
+  { "name": "mvp:test_expect_to_start_with", "rules": [{ "field": "expr", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value1" } }, { "field": "value", "type": "value", "optional": true, "default": "", "route": { "kind": "context-nest", "path": "value2" } }] },
+  { "name": "mvp:text_append", "argNameIsVar": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:text_contains", "argNameIsVar": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:text_ends_with", "argNameIsVar": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:text_icontains", "argNameIsVar": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:text_iends_with", "argNameIsVar": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:text_istarts_with", "argNameIsVar": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:text_ltrim", "argNameIsVar": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:text_prepend", "argNameIsVar": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:text_rtrim", "argNameIsVar": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:text_starts_with", "argNameIsVar": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:text_trim", "argNameIsVar": true, "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:throw_error", "rules": [{ "field": "name", "type": "string", "optional": true, "default": "", "route": { "kind": "context-plain", "path": "name" } }, { "field": "value", "type": "value", "optional": false, "route": { "kind": "context-spread" } }] },
+  { "name": "mvp:uuid4", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }] },
+  { "name": "mvp:vault_sign_url", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "pathname", "type": "value", "optional": false, "route": { "kind": "input", "name": "pathname" } }, { "field": "ttl", "type": "value", "optional": true, "route": { "kind": "input", "name": "ttl" } }] },
+  { "name": "mvp:zip_add_file_resource", "rules": [{ "field": "file", "type": "value", "optional": false, "route": { "kind": "context-nest", "path": "file" } }, { "field": "filename", "type": "value", "optional": false, "route": { "kind": "context-nest", "path": "filename" } }, { "field": "zip", "type": "value", "optional": false, "route": { "kind": "context-nest", "path": "zip" } }, { "field": "password", "type": "value", "optional": true, "route": { "kind": "context-nest", "path": "password" } }, { "field": "password_encryption", "type": "value", "optional": true, "route": { "kind": "context-nest", "path": "password_encryption" } }] },
+  { "name": "mvp:zip_create_file_resource", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "filename", "type": "value", "optional": false, "route": { "kind": "input", "name": "filename" } }, { "field": "password", "type": "value", "optional": true, "route": { "kind": "input", "name": "password" } }, { "field": "password_encryption", "type": "value", "optional": true, "enum": ["standard", "AES-128", "AES-192", "AES-256"], "route": { "kind": "input", "name": "password_encryption" } }] },
+  { "name": "mvp:zip_delete_file_resource", "rules": [{ "field": "filename", "type": "value", "optional": false, "route": { "kind": "context-nest", "path": "filename" } }, { "field": "zip", "type": "value", "optional": false, "route": { "kind": "context-nest", "path": "zip" } }, { "field": "password", "type": "value", "optional": true, "route": { "kind": "context-nest", "path": "password" } }] },
+  { "name": "mvp:zip_extract_file_resource", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "zip", "type": "value", "optional": false, "route": { "kind": "context-nest", "path": "zip" } }, { "field": "password", "type": "value", "optional": true, "route": { "kind": "context-nest", "path": "password" } }] },
+  { "name": "mvp:zip_view_contents", "rules": [{ "field": "as", "type": "string", "optional": true, "route": { "kind": "as" } }, { "field": "zip", "type": "value", "optional": false, "route": { "kind": "context-nest", "path": "zip" } }, { "field": "password", "type": "value", "optional": true, "route": { "kind": "context-nest", "path": "password" } }] }
+];
+
+// src/statements/generated/factories.generated.ts
+var SPECS = new Map(GENERATED_SPECS.map((s2) => [s2.name, s2]));
+var fromSpec = (name, a) => encodeFromSpec(SPECS.get(name), a);
+var generated = {
+  ai: {
+    external: {
+      mcp: {
+        server_details: (
+          /** `mvp:mcp_server_details` — fields: as, url, bearer_token, connection_type */
+          (a = {}) => fromSpec("mvp:mcp_server_details", a)
+        ),
+        tool: {
+          list: (
+            /** `mvp:mcp_list_tools` — fields: as, url, bearer_token, connection_type */
+            (a = {}) => fromSpec("mvp:mcp_list_tools", a)
+          ),
+          run: (
+            /** `mvp:mcp_call_tool` — fields: as, url, bearer_token, connection_type, tool, args */
+            (a = {}) => fromSpec("mvp:mcp_call_tool", a)
+          )
+        }
+      }
+    }
+  },
+  api: {
+    request: (
+      /** `mvp:api_request` — fields: as, url, method, params, headers, timeout, follow_location, verify_host, verify_peer, ca_certificate, certificate, certificate_pass, private_key, private_key_pass */
+      (a = {}) => fromSpec("mvp:api_request", a)
+    ),
+    stream: (
+      /** `mvp:streaming_api_response` — fields: value */
+      (a) => fromSpec("mvp:streaming_api_response", a)
+    )
+  },
+  array: {
+    difference: (
+      /** `mvp:array_difference` — fields: as, expr, value, by */
+      (a = {}) => fromSpec("mvp:array_difference", a)
+    ),
+    every: (
+      /** `mvp:array_every` — fields: expr, as, if */
+      (a = {}) => fromSpec("mvp:array_every", a)
+    ),
+    filter: (
+      /** `mvp:array_filter` — fields: expr, as, if */
+      (a = {}) => fromSpec("mvp:array_filter", a)
+    ),
+    filter_count: (
+      /** `mvp:array_filter_count` — fields: expr, as, if */
+      (a = {}) => fromSpec("mvp:array_filter_count", a)
+    ),
+    find: (
+      /** `mvp:array_find` — fields: expr, as, if */
+      (a = {}) => fromSpec("mvp:array_find", a)
+    ),
+    find_index: (
+      /** `mvp:array_find_index` — fields: expr, as, if */
+      (a = {}) => fromSpec("mvp:array_find_index", a)
+    ),
+    group_by: (
+      /** `mvp:array_group_by` — fields: as, expr, by */
+      (a = {}) => fromSpec("mvp:array_group_by", a)
+    ),
+    has: (
+      /** `mvp:array_has` — fields: expr, as, if */
+      (a = {}) => fromSpec("mvp:array_has", a)
+    ),
+    intersection: (
+      /** `mvp:array_intersection` — fields: as, expr, value, by */
+      (a = {}) => fromSpec("mvp:array_intersection", a)
+    ),
+    merge: (
+      /** `mvp:array_merge` — fields: name, value */
+      (a = {}) => fromSpec("mvp:array_merge", a)
+    ),
+    partition: (
+      /** `mvp:array_partition` — fields: expr, as, if */
+      (a = {}) => fromSpec("mvp:array_partition", a)
+    ),
+    pop: (
+      /** `mvp:array_pop` — fields: name, as */
+      (a = {}) => fromSpec("mvp:array_pop", a)
+    ),
+    push: (
+      /** `mvp:array_push` — fields: name, value */
+      (a) => fromSpec("mvp:array_push", a)
+    ),
+    shift: (
+      /** `mvp:array_shift` — fields: name, as */
+      (a = {}) => fromSpec("mvp:array_shift", a)
+    ),
+    unshift: (
+      /** `mvp:array_unshift` — fields: name, value */
+      (a) => fromSpec("mvp:array_unshift", a)
+    )
+  },
+  await: (
+    /** `mvp:async_function_await` — fields: as, ids, timeout */
+    (a = {}) => fromSpec("mvp:async_function_await", a)
+  ),
+  cloud: {
+    algolia: {
+      request: (
+        /** `mvp:algolia_request` — fields: as, application_id, api_key, url, method, payload */
+        (a) => fromSpec("mvp:algolia_request", a)
+      )
+    },
+    aws: {
+      opensearch: {
+        document: (
+          /** `mvp:amazon_opensearch_document` — fields: as, auth_type, key_id, access_key, region, base_url, method, index, doc_id, doc */
+          (a) => fromSpec("mvp:amazon_opensearch_document", a)
+        ),
+        query: (
+          /** `mvp:amazon_opensearch_query` — fields: as, auth_type, key_id, access_key, region, base_url, index, payload, size, from, included_fields, return_type, expression, sort */
+          (a = {}) => fromSpec("mvp:amazon_opensearch_query", a)
+        ),
+        request: (
+          /** `mvp:amazon_opensearch_request` — fields: as, auth_type, key_id, access_key, region, method, url, query */
+          (a = {}) => fromSpec("mvp:amazon_opensearch_request", a)
+        )
+      },
+      s3: {
+        delete_file: (
+          /** `mvp:amazon_s3_delete_file` — fields: as, bucket, region, key, secret, file_key */
+          (a) => fromSpec("mvp:amazon_s3_delete_file", a)
+        ),
+        get_file_info: (
+          /** `mvp:amazon_s3_get_file_metadata` — fields: as, bucket, region, key, secret, file_key */
+          (a) => fromSpec("mvp:amazon_s3_get_file_metadata", a)
+        ),
+        list_directory: (
+          /** `mvp:amazon_s3_list_directory` — fields: as, bucket, region, key, secret, prefix, next_page_token */
+          (a) => fromSpec("mvp:amazon_s3_list_directory", a)
+        ),
+        read_file: (
+          /** `mvp:amazon_s3_create_var_from_file_resource` — fields: as, bucket, region, key, secret, file_key */
+          (a) => fromSpec("mvp:amazon_s3_create_var_from_file_resource", a)
+        ),
+        sign_url: (
+          /** `mvp:amazon_s3_signed_url` — fields: as, bucket, region, key, secret, file_key, ttl */
+          (a) => fromSpec("mvp:amazon_s3_signed_url", a)
+        ),
+        upload_file: (
+          /** `mvp:amazon_s3_upload_file` — fields: as, bucket, region, key, secret, file_key, file, metadata, object_lock_mode, object_lock_retain_until */
+          (a) => fromSpec("mvp:amazon_s3_upload_file", a)
+        )
+      }
+    },
+    azure: {
+      storage: {
+        delete_file: (
+          /** `mvp:azure_blob_storage_delete_file` — fields: as, account_name, account_key, container_name, filePath */
+          (a) => fromSpec("mvp:azure_blob_storage_delete_file", a)
+        ),
+        get_file_info: (
+          /** `mvp:azure_blob_storage_get_file_metadata` — fields: as, account_name, account_key, container_name, filePath */
+          (a) => fromSpec("mvp:azure_blob_storage_get_file_metadata", a)
+        ),
+        list_directory: (
+          /** `mvp:azure_blob_storage_list_directory` — fields: as, account_name, account_key, container_name, path */
+          (a) => fromSpec("mvp:azure_blob_storage_list_directory", a)
+        ),
+        read_file: (
+          /** `mvp:azure_blob_storage_create_var_from_file_resource` — fields: as, account_name, account_key, container_name, filePath */
+          (a) => fromSpec("mvp:azure_blob_storage_create_var_from_file_resource", a)
+        ),
+        sign_url: (
+          /** `mvp:azure_blob_storage_signed_url` — fields: as, account_name, account_key, container_name, path, ttl */
+          (a) => fromSpec("mvp:azure_blob_storage_signed_url", a)
+        ),
+        upload_file: (
+          /** `mvp:azure_blob_storage_upload_file` — fields: as, account_name, account_key, container_name, filePath, file, metadata */
+          (a) => fromSpec("mvp:azure_blob_storage_upload_file", a)
+        )
+      }
+    },
+    elasticsearch: {
+      document: (
+        /** `mvp:elasticsearch_document` — fields: as, auth_type, key_id, access_key, base_url, index, method, doc_id, doc */
+        (a) => fromSpec("mvp:elasticsearch_document", a)
+      ),
+      query: (
+        /** `mvp:elasticsearch_query` — fields: as, auth_type, key_id, access_key, base_url, index, payload, size, from, included_fields, return_type, expression, sort */
+        (a = {}) => fromSpec("mvp:elasticsearch_query", a)
+      ),
+      request: (
+        /** `mvp:elasticsearch_request` — fields: as, auth_type, key_id, access_key, method, url, payload */
+        (a = {}) => fromSpec("mvp:elasticsearch_request", a)
+      )
+    },
+    google: {
+      storage: {
+        delete_file: (
+          /** `mvp:google_cloud_storage_delete_file` — fields: as, service_account, bucket, filePath */
+          (a) => fromSpec("mvp:google_cloud_storage_delete_file", a)
+        ),
+        get_file_info: (
+          /** `mvp:google_cloud_storage_get_file_metadata` — fields: as, service_account, bucket, filePath */
+          (a) => fromSpec("mvp:google_cloud_storage_get_file_metadata", a)
+        ),
+        list_directory: (
+          /** `mvp:google_cloud_storage_list_directory` — fields: as, service_account, bucket, path */
+          (a) => fromSpec("mvp:google_cloud_storage_list_directory", a)
+        ),
+        read_file: (
+          /** `mvp:google_cloud_storage_create_var_from_file_resource` — fields: as, service_account, bucket, filePath */
+          (a) => fromSpec("mvp:google_cloud_storage_create_var_from_file_resource", a)
+        ),
+        sign_url: (
+          /** `mvp:google_cloud_storage_signed_url` — fields: as, service_account, bucket, filePath, method, ttl */
+          (a) => fromSpec("mvp:google_cloud_storage_signed_url", a)
+        ),
+        upload_file: (
+          /** `mvp:google_cloud_storage_upload_file` — fields: as, service_account, bucket, filePath, file, metadata */
+          (a) => fromSpec("mvp:google_cloud_storage_upload_file", a)
+        )
+      }
+    }
+  },
+  datadog: {
+    log: (
+      /** `mvp:datadog_log` — fields: message, status, attributes, service, source, env, hostname, tags, timestamp, connection */
+      (a = {}) => fromSpec("mvp:datadog_log", a)
+    ),
+    log_bulk: (
+      /** `mvp:datadog_log_bulk` — fields: entries, connection */
+      (a) => fromSpec("mvp:datadog_log_bulk", a)
+    ),
+    metric: (
+      /** `mvp:datadog_metric` — fields: metric, value, type, tags, service, source, env, hostname, timestamp, connection */
+      (a) => fromSpec("mvp:datadog_metric", a)
+    ),
+    metric_bulk: (
+      /** `mvp:datadog_metric_bulk` — fields: entries, connection */
+      (a) => fromSpec("mvp:datadog_metric_bulk", a)
+    )
+  },
+  db: {
+    set_datasource: (
+      /** `mvp:set_data_source` — fields: value, workspace_id */
+      (a) => fromSpec("mvp:set_data_source", a)
+    )
+  },
+  debug: {
+    log: (
+      /** `mvp:debug_log` — fields: value */
+      (a) => fromSpec("mvp:debug_log", a)
+    ),
+    stop: (
+      /** `mvp:die` — fields: value */
+      (a) => fromSpec("mvp:die", a)
+    )
+  },
+  expect: {
+    to_be_defined: (
+      /** `mvp:test_expect_to_be_defined` — fields: expr */
+      (a = {}) => fromSpec("mvp:test_expect_to_be_defined", a)
+    ),
+    to_be_empty: (
+      /** `mvp:test_expect_to_be_empty` — fields: expr */
+      (a = {}) => fromSpec("mvp:test_expect_to_be_empty", a)
+    ),
+    to_be_false: (
+      /** `mvp:test_expect_to_be_false` — fields: expr */
+      (a = {}) => fromSpec("mvp:test_expect_to_be_false", a)
+    ),
+    to_be_greater_than: (
+      /** `mvp:test_expect_to_be_greater_than` — fields: expr, value */
+      (a = {}) => fromSpec("mvp:test_expect_to_be_greater_than", a)
+    ),
+    to_be_in_the_future: (
+      /** `mvp:test_expect_to_be_in_the_future` — fields: expr */
+      (a = {}) => fromSpec("mvp:test_expect_to_be_in_the_future", a)
+    ),
+    to_be_in_the_past: (
+      /** `mvp:test_expect_to_be_in_the_past` — fields: expr */
+      (a = {}) => fromSpec("mvp:test_expect_to_be_in_the_past", a)
+    ),
+    to_be_less_than: (
+      /** `mvp:test_expect_to_be_less_than` — fields: expr, value */
+      (a = {}) => fromSpec("mvp:test_expect_to_be_less_than", a)
+    ),
+    to_be_null: (
+      /** `mvp:test_expect_to_be_null` — fields: expr */
+      (a = {}) => fromSpec("mvp:test_expect_to_be_null", a)
+    ),
+    to_be_true: (
+      /** `mvp:test_expect_to_be_true` — fields: expr */
+      (a = {}) => fromSpec("mvp:test_expect_to_be_true", a)
+    ),
+    to_be_within: (
+      /** `mvp:test_expect_to_be_within` — fields: expr, min, max */
+      (a = {}) => fromSpec("mvp:test_expect_to_be_within", a)
+    ),
+    to_contain: (
+      /** `mvp:test_expect_to_contain` — fields: expr, value */
+      (a = {}) => fromSpec("mvp:test_expect_to_contain", a)
+    ),
+    to_end_with: (
+      /** `mvp:test_expect_to_end_with` — fields: expr, value */
+      (a = {}) => fromSpec("mvp:test_expect_to_end_with", a)
+    ),
+    to_equal: (
+      /** `mvp:test_expect_to_equal` — fields: expr, value */
+      (a = {}) => fromSpec("mvp:test_expect_to_equal", a)
+    ),
+    to_match: (
+      /** `mvp:test_expect_to_match` — fields: expr, value */
+      (a = {}) => fromSpec("mvp:test_expect_to_match", a)
+    ),
+    to_not_be_defined: (
+      /** `mvp:test_expect_to_not_be_defined` — fields: expr */
+      (a = {}) => fromSpec("mvp:test_expect_to_not_be_defined", a)
+    ),
+    to_not_be_null: (
+      /** `mvp:test_expect_to_not_be_null` — fields: expr */
+      (a = {}) => fromSpec("mvp:test_expect_to_not_be_null", a)
+    ),
+    to_not_equal: (
+      /** `mvp:test_expect_to_not_equal` — fields: expr, value */
+      (a = {}) => fromSpec("mvp:test_expect_to_not_equal", a)
+    ),
+    to_start_with: (
+      /** `mvp:test_expect_to_start_with` — fields: expr, value */
+      (a = {}) => fromSpec("mvp:test_expect_to_start_with", a)
+    )
+  },
+  lambda: (
+    /** `mvp:lambda` — fields: as, code, timeout */
+    (a = {}) => fromSpec("mvp:lambda", a)
+  ),
+  math: {
+    add: (
+      /** `mvp:math_add` — fields: name, value */
+      (a) => fromSpec("mvp:math_add", a)
+    ),
+    bitwise: {
+      and: (
+        /** `mvp:bitwise_and` — fields: name, value */
+        (a) => fromSpec("mvp:bitwise_and", a)
+      ),
+      or: (
+        /** `mvp:bitwise_or` — fields: name, value */
+        (a) => fromSpec("mvp:bitwise_or", a)
+      ),
+      xor: (
+        /** `mvp:bitwise_xor` — fields: name, value */
+        (a) => fromSpec("mvp:bitwise_xor", a)
+      )
+    },
+    div: (
+      /** `mvp:math_div` — fields: name, value */
+      (a) => fromSpec("mvp:math_div", a)
+    ),
+    mod: (
+      /** `mvp:math_mod` — fields: name, value */
+      (a) => fromSpec("mvp:math_mod", a)
+    ),
+    mul: (
+      /** `mvp:math_mul` — fields: name, value */
+      (a) => fromSpec("mvp:math_mul", a)
+    ),
+    sub: (
+      /** `mvp:math_sub` — fields: name, value */
+      (a) => fromSpec("mvp:math_sub", a)
+    )
+  },
+  microservice: {
+    request: (
+      /** `mvp:microservice_request` — fields: as, host, path, method, params, headers, timeout, follow_location */
+      (a) => fromSpec("mvp:microservice_request", a)
+    )
+  },
+  object: {
+    entries: (
+      /** `mvp:object_entries` — fields: as, value */
+      (a = {}) => fromSpec("mvp:object_entries", a)
+    ),
+    keys: (
+      /** `mvp:object_keys` — fields: as, value */
+      (a = {}) => fromSpec("mvp:object_keys", a)
+    ),
+    values: (
+      /** `mvp:object_values` — fields: as, value */
+      (a = {}) => fromSpec("mvp:object_values", a)
+    )
+  },
+  precondition: (
+    /** `mvp:precondition` — fields: expr, error_type, error, payload */
+    (a = {}) => fromSpec("mvp:precondition", a)
+  ),
+  realtime: {
+    get_session: (
+      /** `mvp:get_session` — fields: as */
+      (a = {}) => fromSpec("mvp:get_session", a)
+    )
+  },
+  redis: {
+    count: (
+      /** `mvp:redis_countlist` — fields: as, key */
+      (a) => fromSpec("mvp:redis_countlist", a)
+    ),
+    decr: (
+      /** `mvp:redis_decr` — fields: as, key, by */
+      (a) => fromSpec("mvp:redis_decr", a)
+    ),
+    del: (
+      /** `mvp:redis_del` — fields: key */
+      (a) => fromSpec("mvp:redis_del", a)
+    ),
+    get: (
+      /** `mvp:redis_get` — fields: as, key */
+      (a) => fromSpec("mvp:redis_get", a)
+    ),
+    has: (
+      /** `mvp:redis_has` — fields: as, key */
+      (a) => fromSpec("mvp:redis_has", a)
+    ),
+    incr: (
+      /** `mvp:redis_incr` — fields: as, key, by */
+      (a) => fromSpec("mvp:redis_incr", a)
+    ),
+    keys: (
+      /** `mvp:redis_keys` — fields: as, search */
+      (a) => fromSpec("mvp:redis_keys", a)
+    ),
+    pop: (
+      /** `mvp:redis_poplist` — fields: as, key, count */
+      (a) => fromSpec("mvp:redis_poplist", a)
+    ),
+    push: (
+      /** `mvp:redis_pushlist` — fields: as, key, value */
+      (a) => fromSpec("mvp:redis_pushlist", a)
+    ),
+    range: (
+      /** `mvp:redis_rangelist` — fields: as, key, start, stop */
+      (a) => fromSpec("mvp:redis_rangelist", a)
+    ),
+    ratelimit: (
+      /** `mvp:redis_ratelimit` — fields: as, key, max, ttl, error */
+      (a) => fromSpec("mvp:redis_ratelimit", a)
+    ),
+    remove: (
+      /** `mvp:redis_remove_list` — fields: as, key, value, count */
+      (a) => fromSpec("mvp:redis_remove_list", a)
+    ),
+    set: (
+      /** `mvp:redis_set` — fields: as, key, data, ttl, create_only */
+      (a) => fromSpec("mvp:redis_set", a)
+    ),
+    shift: (
+      /** `mvp:redis_shiftlist` — fields: as, key, count */
+      (a) => fromSpec("mvp:redis_shiftlist", a)
+    ),
+    unshift: (
+      /** `mvp:redis_unshiftlist` — fields: as, key, value */
+      (a) => fromSpec("mvp:redis_unshiftlist", a)
+    )
+  },
+  security: {
+    check_password: (
+      /** `mvp:check_pass` — fields: as, text_password, hash_password */
+      (a = {}) => fromSpec("mvp:check_pass", a)
+    ),
+    create_curve_key: (
+      /** `mvp:crypto_create_ec_key` — fields: as, curve, format */
+      (a = {}) => fromSpec("mvp:crypto_create_ec_key", a)
+    ),
+    create_password: (
+      /** `mvp:generate_pass` — fields: as, character_count, require_lowercase, require_uppercase, require_digit, require_symbol, symbol_whitelist */
+      (a = {}) => fromSpec("mvp:generate_pass", a)
+    ),
+    create_rsa_key: (
+      /** `mvp:crypto_create_rsa_key` — fields: as, bits, format */
+      (a = {}) => fromSpec("mvp:crypto_create_rsa_key", a)
+    ),
+    create_secret_key: (
+      /** `mvp:crypto_create_octet_key` — fields: as, bits, format */
+      (a = {}) => fromSpec("mvp:crypto_create_octet_key", a)
+    ),
+    create_uuid: (
+      /** `mvp:uuid4` — fields: as */
+      (a = {}) => fromSpec("mvp:uuid4", a)
+    ),
+    decrypt: (
+      /** `mvp:crypto_decrypt` — fields: as, data, algorithm, key, iv */
+      (a = {}) => fromSpec("mvp:crypto_decrypt", a)
+    ),
+    encrypt: (
+      /** `mvp:crypto_encrypt` — fields: as, data, algorithm, key, iv */
+      (a = {}) => fromSpec("mvp:crypto_encrypt", a)
+    ),
+    jwe_decode: (
+      /** `mvp:crypto_jwe_decode2` — fields: as, token, key, check_claims, key_algorithm, content_algorithm, timeDrift */
+      (a = {}) => fromSpec("mvp:crypto_jwe_decode2", a)
+    ),
+    jwe_encode: (
+      /** `mvp:crypto_jwe_encode3` — fields: as, headers, claims, key, key_algorithm, content_algorithm, ttl */
+      (a = {}) => fromSpec("mvp:crypto_jwe_encode3", a)
+    ),
+    jws_decode: (
+      /** `mvp:crypto_jws_decode2` — fields: as, token, key, check_claims, signature_algorithm, timeDrift */
+      (a = {}) => fromSpec("mvp:crypto_jws_decode2", a)
+    ),
+    jws_encode: (
+      /** `mvp:crypto_jws_encode2` — fields: as, headers, claims, key, signature_algorithm, ttl */
+      (a = {}) => fromSpec("mvp:crypto_jws_encode2", a)
+    ),
+    random_bytes: (
+      /** `mvp:random_bytes` — fields: as, length */
+      (a = {}) => fromSpec("mvp:random_bytes", a)
+    ),
+    random_number: (
+      /** `mvp:rand` — fields: as, min, max */
+      (a = {}) => fromSpec("mvp:rand", a)
+    )
+  },
+  storage: {
+    create_attachment: (
+      /** `mvp:create_attachment` — fields: as, value, access, filename, include_meta, type */
+      (a) => fromSpec("mvp:create_attachment", a)
+    ),
+    create_audio: (
+      /** `mvp:create_audio` — fields: as, value, access, filename */
+      (a) => fromSpec("mvp:create_audio", a)
+    ),
+    create_file_resource: (
+      /** `mvp:create_file_resource` — fields: as, filename, filedata */
+      (a) => fromSpec("mvp:create_file_resource", a)
+    ),
+    create_image: (
+      /** `mvp:create_image` — fields: as, value, access, filename */
+      (a) => fromSpec("mvp:create_image", a)
+    ),
+    create_video: (
+      /** `mvp:create_video` — fields: as, value, access, filename */
+      (a) => fromSpec("mvp:create_video", a)
+    ),
+    delete_file: (
+      /** `mvp:delete_file` — fields: pathname */
+      (a) => fromSpec("mvp:delete_file", a)
+    ),
+    read_file_resource: (
+      /** `mvp:create_var_from_file_resource` — fields: as, value */
+      (a) => fromSpec("mvp:create_var_from_file_resource", a)
+    ),
+    sign_private_url: (
+      /** `mvp:vault_sign_url` — fields: as, pathname, ttl */
+      (a) => fromSpec("mvp:vault_sign_url", a)
+    )
+  },
+  stream: {
+    from_csv: (
+      /** `mvp:csv_stream` — fields: as, value, separator, enclosure, escape_char */
+      (a) => fromSpec("mvp:csv_stream", a)
+    ),
+    from_jsonl: (
+      /** `mvp:jsonl_stream` — fields: as, value */
+      (a) => fromSpec("mvp:jsonl_stream", a)
+    ),
+    from_request: (
+      /** `mvp:streaming_api_request` — fields: as, url, method, params, headers, timeout, follow_location, verify_host, verify_peer, ca_certificate, certificate, certificate_pass, private_key, private_key_pass */
+      (a = {}) => fromSpec("mvp:streaming_api_request", a)
+    )
+  },
+  text: {
+    append: (
+      /** `mvp:text_append` — fields: name, value */
+      (a) => fromSpec("mvp:text_append", a)
+    ),
+    contains: (
+      /** `mvp:text_contains` — fields: name, as, value */
+      (a) => fromSpec("mvp:text_contains", a)
+    ),
+    ends_with: (
+      /** `mvp:text_ends_with` — fields: name, as, value */
+      (a) => fromSpec("mvp:text_ends_with", a)
+    ),
+    icontains: (
+      /** `mvp:text_icontains` — fields: name, as, value */
+      (a) => fromSpec("mvp:text_icontains", a)
+    ),
+    iends_with: (
+      /** `mvp:text_iends_with` — fields: name, as, value */
+      (a) => fromSpec("mvp:text_iends_with", a)
+    ),
+    istarts_with: (
+      /** `mvp:text_istarts_with` — fields: name, as, value */
+      (a) => fromSpec("mvp:text_istarts_with", a)
+    ),
+    ltrim: (
+      /** `mvp:text_ltrim` — fields: name, value */
+      (a) => fromSpec("mvp:text_ltrim", a)
+    ),
+    prepend: (
+      /** `mvp:text_prepend` — fields: name, value */
+      (a) => fromSpec("mvp:text_prepend", a)
+    ),
+    rtrim: (
+      /** `mvp:text_rtrim` — fields: name, value */
+      (a) => fromSpec("mvp:text_rtrim", a)
+    ),
+    starts_with: (
+      /** `mvp:text_starts_with` — fields: name, as, value */
+      (a) => fromSpec("mvp:text_starts_with", a)
+    ),
+    trim: (
+      /** `mvp:text_trim` — fields: name, value */
+      (a) => fromSpec("mvp:text_trim", a)
+    )
+  },
+  throw: (
+    /** `mvp:throw_error` — fields: name, value */
+    (a) => fromSpec("mvp:throw_error", a)
+  ),
+  util: {
+    geo_distance: (
+      /** `mvp:calculate_geo_distance` — fields: as, latitude_1, longitude_1, latitude_2, longitude_2 */
+      (a = {}) => fromSpec("mvp:calculate_geo_distance", a)
+    ),
+    get_all_input: (
+      /** `mvp:get_all_input` — fields: as */
+      (a = {}) => fromSpec("mvp:get_all_input", a)
+    ),
+    get_env: (
+      /** `mvp:get_env` — fields: as */
+      (a = {}) => fromSpec("mvp:get_env", a)
+    ),
+    get_vars: (
+      /** `mvp:get_vars` — fields: as */
+      (a = {}) => fromSpec("mvp:get_vars", a)
+    ),
+    ip_lookup: (
+      /** `mvp:ipaddress_lookup` — fields: as, value */
+      (a) => fromSpec("mvp:ipaddress_lookup", a)
+    ),
+    send_email: (
+      /** `mvp:send_email` — fields: as, service_provider, api_key, subject, message, to, bcc, cc, from, reply_to, scheduled_at */
+      (a = {}) => fromSpec("mvp:send_email", a)
+    ),
+    set_header: (
+      /** `mvp:setheader` — fields: value, duplicates */
+      (a) => fromSpec("mvp:setheader", a)
+    ),
+    sleep: (
+      /** `mvp:sleep` — fields: value */
+      (a) => fromSpec("mvp:sleep", a)
+    ),
+    template_engine: (
+      /** `mvp:template_string` — fields: as, value */
+      (a) => fromSpec("mvp:template_string", a)
+    )
+  },
+  webflow: {
+    request: (
+      /** `mvp:connect_webflow_api_request` — fields: as, path, method, params, headers, timeout, follow_location, verify_host, verify_peer, ca_certificate, certificate, certificate_pass, private_key, private_key_pass */
+      (a = {}) => fromSpec("mvp:connect_webflow_api_request", a)
+    )
+  },
+  zip: {
+    add_to_archive: (
+      /** `mvp:zip_add_file_resource` — fields: file, filename, zip, password, password_encryption */
+      (a) => fromSpec("mvp:zip_add_file_resource", a)
+    ),
+    create_archive: (
+      /** `mvp:zip_create_file_resource` — fields: as, filename, password, password_encryption */
+      (a) => fromSpec("mvp:zip_create_file_resource", a)
+    ),
+    delete_from_archive: (
+      /** `mvp:zip_delete_file_resource` — fields: filename, zip, password */
+      (a) => fromSpec("mvp:zip_delete_file_resource", a)
+    ),
+    extract: (
+      /** `mvp:zip_extract_file_resource` — fields: as, zip, password */
+      (a) => fromSpec("mvp:zip_extract_file_resource", a)
+    ),
+    view_contents: (
+      /** `mvp:zip_view_contents` — fields: as, zip, password */
+      (a) => fromSpec("mvp:zip_view_contents", a)
+    )
+  }
+};
+
+// src/statements/special/misc.ts
+function vf3(v) {
+  return { value: v.value, tag: v.tag, filters: v.filters };
+}
+function isTransformRecord(t) {
+  return !isTaggedValue(t) && !Array.isArray(t);
+}
+function arrayMap(a) {
+  const context = { output_type: "value", collection: vf3(a.source) };
+  if (a.transform !== void 0) {
+    const pairs = isTransformRecord(a.transform) ? Object.entries(a.transform).map(([key, value]) => ({ key: c.text(key), value })) : Array.isArray(a.transform) ? a.transform : void 0;
+    if (pairs) {
+      if (pairs.length === 0) {
+        throw new Error(
+          "array.map: an object `transform` needs at least one key \u2014 the engine's object branch iterates `transform_object` and an empty one maps every item to `{}`. Pass a record of values (`{ id: ref('$this') }`), a list of `{ key, value }` pairs, or a single value for the scalar form."
+        );
+      }
+      context.output_type = "object";
+      context.transform_object = pairs.map(({ key, value }) => ({
+        attribute_key: vf3(key),
+        attribute_value: vf3(value)
+      }));
+    } else {
+      context.transform_value = vf3(a.transform);
+    }
+  }
+  return annotate({ name: "mvp:array_map", context, as: a.as ?? "", input: [] }, a);
+}
+function arrayUnion(a) {
+  const context = { left: vf3(a.source) };
+  if (a.with) context.right = vf3(a.with);
+  if (a.transform) context.transform_value = vf3(a.transform);
+  return annotate({ name: "mvp:array_union", context, as: a.as ?? "", input: [] }, a);
+}
+function comment(text = "", a) {
+  return annotate({ name: "mvp:comment", description: text, context: {}, input: [] }, a);
+}
+function getRawInput(a = {}) {
+  return annotate({
+    name: "mvp:get_input",
+    context: {},
+    as: a.as ?? "",
+    // Both entries are `?=` optionals in the engine schema (`encoding?=json`,
+    // `exclude_middleware_modification?=false`) and Xano's editor writes neither
+    // for a plain body capture — so they are emitted only when authored.
+    input: [
+      ...a.encoding === void 0 ? [] : [{ name: "encoding", ...vf3(a.encoding) }],
+      ...a.excludeMiddleware === void 0 ? [] : [{ name: "exclude_middleware_modification", ...vf3(a.excludeMiddleware) }]
+    ]
+  }, a);
+}
+function postProcess(body, a) {
+  return annotate(
+    { name: "mvp:post_process", context: { run: body.map(encodeStatement) }, input: [] },
+    a
+  );
+}
+function realtimeEvent(a) {
+  const auth = { row_id: vf3(a.authId) };
+  if (a.authTable !== void 0) auth.dbo_id = resolveRef("dbo", a.authTable);
+  return annotate({
+    name: "mvp:realtime_event",
+    context: { channel: vf3(a.channel), data: vf3(a.data), auth },
+    input: []
+  }, a);
+}
+function realtimePublish(a) {
+  const server = publishServerValue(a.server);
+  if (!a.channel || a.channel.value === "") {
+    throw new Error(
+      "realtime.publish: `channel` is required \u2014 the filled-in channel path to publish onto (use `realtimeChannel().getChannel({\u2026})`)."
+    );
+  }
+  assertFilledChannel(a.channel);
+  const context = {
+    realtime_server: server,
+    channel: vf3(a.channel),
+    data: vf3(a.data)
+  };
+  if (a.message !== void 0) context.message = vf3(a.message);
+  const auth = {};
+  if (a.authTable !== void 0) auth.dbo_id = resolveRef("dbo", a.authTable);
+  if (a.authId !== void 0) auth.row_id = vf3(a.authId);
+  if (Object.keys(auth).length > 0) context.auth = auth;
+  return annotate({ name: "mvp:realtime_publish", context, input: [] }, a);
+}
+function assertFilledChannel(channel) {
+  if (!channel.tag.startsWith("const")) return;
+  if (typeof channel.value !== "string" || !/[{}]/.test(channel.value)) return;
+  throw new Error(
+    `realtime.publish: \`channel\` is "${channel.value}", which is still a TEMPLATE \u2014 its {param} was never filled in, so this publishes onto a path no client can join, and the engine swallows the miss silently. Fill it in with \`channel.getChannel({ \u2026 })\` (e.g. \`c.text(rooms.getChannel({ room_id: 42 }))\`), or build the path at runtime from a \`ref\`/\`inp\`.`
+  );
+}
+function publishServerValue(server) {
+  if (typeof server === "string") {
+    if (server === "") throw new Error("realtime.publish: `server` is required \u2014 the owning realtime server's name.");
+    return { value: server, tag: "const", filters: [] };
+  }
+  if (server && typeof server === "object" && "tag" in server) return vf3(server);
+  const name = server && typeof server === "object" ? server.name : void 0;
+  if (!name) {
+    throw new Error(
+      "realtime.publish: `server` is required \u2014 pass the `realtimeServer()` handle, its name, or a value naming it."
+    );
+  }
+  return { value: name, tag: "const", filters: [] };
+}
+function createAuthToken(a) {
+  return annotate({
+    name: "mvp:create_auth",
+    context: {},
+    as: a.as ?? "",
+    // Entry order and optionality come straight from the engine's own input
+    // schema — `id`, `dbtable`, `extras?={}`, `expiration?=86400`. The SDK
+    // previously wrote a different order with both optionals always present;
+    // Xano's editor writes this shape, so this is what a pulled workspace has.
+    input: [
+      { name: "id", ...vf3(a.id) },
+      {
+        name: "dbtable",
+        value: a.table === null ? "" : resolveRef("dbo", a.table),
+        tag: "const",
+        filters: []
+      },
+      ...a.extras === void 0 ? [] : [{ name: "extras", ...vf3(a.extras) }],
+      ...a.expiration === void 0 ? [] : [{ name: "expiration", ...vf3(a.expiration) }]
+    ]
+  }, a);
+}
+function createGuid(a = {}) {
+  return annotate({
+    name: "mvp:guid",
+    context: {},
+    as: a.as ?? "",
+    input: []
+  }, a);
+}
+function expectToThrow(a) {
+  const context = { run: a.body.map(encodeStatement) };
+  if (a.exception) context.value1 = vf3(a.exception);
+  return annotate({ name: "mvp:test_expect_to_throw", context, input: [] }, a);
+}
+function expectToMatch(a = {}) {
+  if (a.value) {
+    const refusal = barePatternRefusal(a.value);
+    if (refusal) throw new Error(`s.expect.to_match: ${refusal}. (issue #211)`);
+  }
+  return generated.expect.to_match(a);
+}
+registerStatement("mvp:array_map", arrayMap);
+registerStatement("mvp:guid", createGuid);
+registerStatement("mvp:array_union", arrayUnion);
+registerStatement("mvp:comment", comment);
+registerStatement("mvp:get_input", getRawInput);
+registerStatement("mvp:post_process", postProcess);
+registerStatement("mvp:realtime_event", realtimeEvent);
+registerStatement("mvp:realtime_publish", realtimePublish);
+registerStatement("mvp:create_auth", createAuthToken);
+registerStatement("mvp:test_expect_to_throw", expectToThrow);
+
+// src/statements/special/ip-lookup.ts
+function ipLookup(a) {
+  return generated.util.ip_lookup({
+    as: a.as,
+    value: a.value,
+    disabled: a.disabled,
+    description: a.description
+  });
+}
+
+// src/statements/special/output-select.ts
+function encodeOutputItems(paths) {
+  const roots = [];
+  const whole = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    const segments = path.split(".");
+    if (segments.some((segment) => segment === "")) {
+      throw new Error(
+        `db output: "${path}" has an empty path segment \u2014 use "column" or "column.key".`
+      );
+    }
+    let level = roots;
+    let walked = "";
+    for (let i = 0; i < segments.length; i++) {
+      const name = segments[i];
+      walked = walked === "" ? name : `${walked}.${name}`;
+      let node = level.find((item) => item.name === name);
+      if (!node) {
+        node = { name, children: [] };
+        level.push(node);
+      } else if (whole.has(walked) || i === segments.length - 1) {
+        throw new Error(
+          `db output: "${walked}" is selected both whole and by sub-key \u2014 list either "${walked}" or its "${walked}.<key>" paths, not both.`
+        );
+      }
+      if (i === segments.length - 1) whole.add(walked);
+      level = node.children;
+    }
+  }
+  return roots;
+}
+function outputPaths(items) {
+  if (!Array.isArray(items)) return null;
+  const out = [];
+  const walk = (list, prefix) => list.every((raw) => {
+    if (raw === null || typeof raw !== "object") return false;
+    const node = raw;
+    if (typeof node.name !== "string" || node.name === "" || node.name.includes(".")) return false;
+    const path = prefix === "" ? node.name : `${prefix}.${node.name}`;
+    const children = node.children;
+    if (children === void 0 || Array.isArray(children) && children.length === 0) {
+      out.push(path);
+      return true;
+    }
+    if (!Array.isArray(children)) return false;
+    return walk(children, path);
+  });
+  return walk(items, "") ? out : null;
+}
+
+// src/statements/special/addon-encode.ts
+function encodeInput2(input2) {
+  if (!input2) return [];
+  return Object.entries(input2).map(([name, v]) => leanInput(name, v));
+}
+function encodeOutput(cols) {
+  if (!cols?.length) return void 0;
+  return { customize: true, items: encodeOutputItems(cols) };
+}
+function splitAs(as) {
+  if (!as) {
+    throw new Error('addon: `as` must be a non-empty destination, e.g. "items._book" or "_book".');
+  }
+  const dot = as.lastIndexOf(".");
+  if (dot === -1) return { as };
+  const offset = as.slice(0, dot);
+  const alias = as.slice(dot + 1);
+  if (!offset || !alias) {
+    throw new Error(
+      `addon: \`as\` "${as}" has an empty offset or alias segment \u2014 use "offset.alias" (e.g. "items._book") or a bare alias ("_book").`
+    );
+  }
+  return { offset, as: alias };
+}
+function withEnvelopeOffset(offset, envelopeOffset) {
+  if (offset?.startsWith(envelopeOffset)) return offset;
+  return [envelopeOffset, offset].filter(Boolean).join(".");
+}
+function encodeOne(spec2, path, envelopeOffset) {
+  if (path.includes(spec2)) {
+    throw new Error("addon: `children` cannot reference an ancestor addon spec (cycle detected).");
+  }
+  const { offset, as } = splitAs(spec2.as);
+  const finalOffset = envelopeOffset !== void 0 ? withEnvelopeOffset(offset, envelopeOffset) : offset;
+  const stored = {
+    // An unbound attachment stores a blank id — the same "no target" the engine
+    // writes, and the same spelling `table: null` / `fn: null` already use.
+    id: spec2.addon === null ? "" : resolveRef("addon", spec2.addon),
+    as,
+    input: encodeInput2(spec2.input)
+  };
+  if (finalOffset) stored.offset = finalOffset;
+  const output = encodeOutput(spec2.output);
+  if (output !== void 0) stored.output = output;
+  if (spec2.children?.length) {
+    const nextPath = [...path, spec2];
+    stored.children = spec2.children.map((child) => encodeOne(child, nextPath));
+  }
+  return stored;
+}
+function encodeAddons(specs, envelopeOffset) {
+  if (!specs?.length) return [];
+  return specs.map((spec2) => encodeOne(spec2, [], envelopeOffset));
+}
+
+// src/statements/special/db.ts
+function entry(name, v, ignore = false, children = []) {
+  assertInputValue(name, v);
+  return {
+    name,
+    value: v.value,
+    tag: v.tag,
+    filters: v.filters,
+    ignore,
+    expand: children.length > 0,
+    children
+  };
+}
+function envelope(opts = {}) {
+  const { output: outputCols, addon: addons, addonOffset } = opts;
+  return {
+    description: "",
+    settings_registry: [],
+    // An empty selection normalizes to the full-record default — `[]` must not
+    // emit the degenerate `{customize:true, items:[]}` shape no golden attests.
+    output: outputCols?.length ? { customize: true, filters: [], items: encodeOutputItems(outputCols) } : { customize: false, filters: [], items: [] },
+    // `encodeAddons` returns `[]` when omitted, preserving the empty-`addon:[]`
+    // default byte-for-byte for statements that attach none.
+    addon: encodeAddons(addons, addonOffset)
+  };
+}
+function assertNoAddonShadow(table, addons) {
+  if (!addons?.length) return;
+  if (typeof table === "string" || !("schema" in table)) return;
+  const cols = new Set(tableColumns(table).map((col) => col.name));
+  for (const spec2 of addons) {
+    const as = spec2.as;
+    const dot = as.lastIndexOf(".");
+    const alias = dot === -1 ? as : as.slice(dot + 1);
+    if (cols.has(alias)) {
+      throw new Error(
+        `addon: alias "${alias}" (from as:"${as}") shadows an existing "${table.name}" column \u2014 the graft overwrites it at runtime and desyncs the row type. Rename the alias (Xano convention: a "_" prefix, e.g. as:"${dot === -1 ? "" : as.slice(0, dot + 1)}_${alias}").`
+      );
+    }
+  }
+}
+function dboBinding(table, tableAlias) {
+  const dbo = { id: table === null ? "" : resolveRef("dbo", table) };
+  if (tableAlias !== void 0) dbo.as = tableAlias;
+  return dbo;
+}
+function dboStatement(name, table, as, input2, opts = {}, tableAlias, enforceHiddenFields) {
+  if (table !== null) assertNoAddonShadow(table, opts.addon);
+  return {
+    name,
+    context: {
+      dbo: dboBinding(table, tableAlias),
+      // Written only when ON. The engine declares `enforce_hidden_fields?=false`
+      // and reads it as `?? false`, so absent IS off — and every one of the 557
+      // stored `dbo_add` statements in the offline corpus omits it.
+      ...enforceHiddenFields === true ? { enforce_hidden_fields: true } : {}
+    },
+    as: as ?? "",
+    input: input2,
+    ...envelope(opts)
+  };
+}
+function dbGet(args) {
+  return annotate(dboStatement(
+    "mvp:dbo_getby",
+    args.table,
+    args.as,
+    [
+      entry("field_name", c.text(args.fieldName ?? "id")),
+      entry("field_value", args.fieldValue),
+      // `lock?=false` in the engine schema, and Xano's own editor omits the entry
+      // when it is not set. Writing it unconditionally is a divergence, not a
+      // clarification — so it is written only when the author asks for a lock.
+      ...args.lock === void 0 ? [] : [entry("lock", c.bool(args.lock))]
+    ],
+    { output: args.output, addon: args.addon },
+    args.tableAlias
+  ), args);
+}
+function dbGetById(args) {
+  return annotate(dboStatement(
+    "mvp:dbo_get",
+    args.table,
+    args.as,
+    [entry("id", args.id)],
+    { output: args.output, addon: args.addon },
+    args.tableAlias
+  ), args);
+}
+function dbDel(args) {
+  return annotate(dboStatement(
+    "mvp:dbo_delby",
+    args.table,
+    args.as,
+    [entry("field_name", c.text(args.fieldName ?? "id")), entry("field_value", args.fieldValue)],
+    {},
+    args.tableAlias
+  ), args);
+}
+function dbHas(args) {
+  return annotate(dboStatement(
+    "mvp:dbo_hasby",
+    args.table,
+    args.as,
+    [entry("field_name", c.text(args.fieldName ?? "id")), entry("field_value", args.fieldValue)],
+    {},
+    args.tableAlias
+  ), args);
+}
+function dbPatch(args) {
+  return annotate(dboStatement(
+    "mvp:dbo_patch",
+    args.table,
+    args.as,
+    [
+      entry("field_name", c.text(args.fieldName ?? "id")),
+      entry("field_value", args.fieldValue),
+      entry("item", args.data)
+    ],
+    { output: args.output, addon: args.addon },
+    args.tableAlias
+  ), args);
+}
+function dbTruncate(args) {
+  return annotate(dboStatement(
+    "mvp:dbo_truncate",
+    args.table,
+    args.as,
+    args.reset === void 0 ? [] : [entry("reset", c.bool(args.reset))],
+    {},
+    args.tableAlias
+  ), args);
+}
+function rowEntries(data) {
+  return data.map(
+    (f2) => entry(f2.name, f2.value, f2.ignore ?? false, f2.children ? rowEntries(f2.children) : [])
+  );
+}
+var SYSTEM_IGNORE = {
+  add: /* @__PURE__ */ new Set(["id"]),
+  edit: /* @__PURE__ */ new Set(["id", "created_at"])
+};
+function defaultCell(col) {
+  if (col.default !== void 0 && col.default !== "") return c.text(String(col.default));
+  if (col.array || col.style?.type === "list") return c.array([]);
+  if (col.type === "obj" || col.type === "json") return c.obj({});
+  return c.null();
+}
+function columnsOf(table) {
+  if (typeof table === "object" && "schema" in table && table.schema) {
+    return tableColumns(table);
+  }
+  throw new Error(
+    "db row expansion needs the table definition (with a schema). Pass the table object, or author the row explicitly via `data: [...]`."
+  );
+}
+function requireBoundTable(table, argName) {
+  if (table === null) {
+    throw new Error(
+      `db: \`${argName}\` needs the table's columns, but \`table\` is null (an unbound statement). \`table: null\` represents a statement whose table was deleted \u2014 fix the binding, or pass the row values as \`data:\` instead of \`${argName}:\`.`
+    );
+  }
+  return table;
+}
+function expandRow(table, row, op) {
+  const cols = columnsOf(table);
+  const colNames = new Set(cols.map((col) => col.name));
+  for (const key of Object.keys(row)) {
+    if (!colNames.has(key)) {
+      const name = typeof table === "string" ? table : table.name;
+      throw new Error(`db row: "${key}" is not a column of table "${name}".`);
+    }
+  }
+  const systemIgnore = SYSTEM_IGNORE[op];
+  return cols.map((col) => {
+    const cell = row[col.name];
+    const supplied = cell !== void 0;
+    const ignore = systemIgnore.has(col.name) || op === "edit" && !supplied;
+    if (supplied && isNestedCell(cell)) {
+      return { name: col.name, value: c.text(""), ignore, children: nestedFields(cell) };
+    }
+    const isCell = typeof cell === "object" ? cell !== null : typeof cell === "function";
+    const value = !supplied ? defaultCell(col) : isCell ? cell : coerceCell(table, col, cell);
+    return { name: col.name, value, ignore };
+  });
+}
+function isNestedCell(cell) {
+  if (typeof cell !== "object" || cell === null || Array.isArray(cell)) return false;
+  const v = cell;
+  return !(typeof v.tag === "string" && typeof v.value === "string" && Array.isArray(v.filters));
+}
+function nestedFields(cell) {
+  return Object.entries(cell).map(([name, value]) => {
+    const child = value;
+    return isNestedCell(child) ? { name, value: c.text(""), children: nestedFields(child) } : { name, value: child };
+  });
+}
+function dbAdd(args) {
+  const data = args.row !== void 0 ? expandRow(requireBoundTable(args.table, "row"), args.row, "add") : args.data ?? [];
+  return annotate(dboStatement(
+    "mvp:dbo_add",
+    args.table,
+    args.as,
+    rowEntries(data),
+    { output: args.output, addon: args.addon },
+    args.tableAlias,
+    args.enforceHiddenFields
+  ), args);
+}
+function dbEdit(args) {
+  const data = args.row !== void 0 ? expandRow(requireBoundTable(args.table, "row"), args.row, "edit") : args.data ?? [];
+  return annotate(dboStatement(
+    "mvp:dbo_editby",
+    args.table,
+    args.as,
+    [
+      entry("field_name", c.text(args.fieldName ?? "id")),
+      entry("field_value", args.fieldValue),
+      ...rowEntries(data)
+    ],
+    { output: args.output, addon: args.addon },
+    args.tableAlias,
+    args.enforceHiddenFields
+  ), args);
+}
+function dbAddOrEdit(args) {
+  const data = args.row !== void 0 ? expandRow(requireBoundTable(args.table, "row"), args.row, "edit") : args.data ?? [];
+  const input2 = [
+    leanInput("field_name", c.text(args.fieldName ?? "id")),
+    leanInput("field_value", args.fieldValue),
+    ...data.map((f2) => ({ ignore: f2.ignore ?? false, ...leanInput(f2.name, f2.value) }))
+  ];
+  return annotate({
+    name: "mvp:dbo_addoreditby",
+    context: {
+      dbo: dboBinding(args.table, args.tableAlias),
+      ...args.enforceHiddenFields === true ? { enforce_hidden_fields: true } : {}
+    },
+    as: args.as ?? "",
+    input: input2
+  }, args);
+}
+function dbSchema(args) {
+  return annotate(dboStatement(
+    "mvp:dbo_get_schema",
+    args.table,
+    args.as,
+    [entry("path", args.path)],
+    {},
+    args.tableAlias
+  ), args);
+}
+function dbDirectQuery(args) {
+  return annotate({
+    name: "mvp:dbo_direct_query",
+    context: {
+      code: args.sql,
+      response_type: args.responseType ?? "list",
+      ...args.parser === void 0 ? {} : { parser: args.parser },
+      arg: (args.args ?? []).map((v) => ({ value: v.value, tag: v.tag, filters: v.filters }))
+    },
+    as: args.as ?? "",
+    input: [],
+    ...envelope()
+  }, args);
+}
+function assertBulkAddIds(args) {
+  if (args.allowIdField !== void 0) return;
+  const items = args.items;
+  if (items.tag !== "const:array" || items.filters.length > 0) return;
+  let rows;
+  try {
+    rows = JSON.parse(items.value);
+  } catch {
+    return;
+  }
+  if (!Array.isArray(rows)) return;
+  const withId = rows.findIndex(
+    (r) => typeof r === "object" && r !== null && !Array.isArray(r) && "id" in r
+  );
+  if (withId === -1) return;
+  throw new Error(
+    `db.bulk.add: item ${withId} carries an \`id\`, but \`allowIdField\` is not set \u2014 the engine DROPS \`id\` from every row unless it is on, assigning the next sequence value instead, with no error. Rows land at ids nothing else expects and foreign keys written against them point at the wrong rows. Pass \`allowIdField: true\` to pin the ids you supplied, or \`allowIdField: false\` to state that engine-assigned ids are intended. (Unlike a table \`seed\`, where supplying \`id\` pins it.) (issue #259)`
+  );
+}
+function bulkStatement(name, table, as, input2, tableAlias) {
+  return { name, context: { dbo: dboBinding(table, tableAlias) }, as: as ?? "", input: input2 };
+}
+function dbBulkAdd(args) {
+  assertBulkAddIds(args);
+  return annotate(bulkStatement("mvp:dbo_bulkadd", args.table, args.as, [
+    ...args.allowIdField === void 0 ? [] : [leanInput("allow_id_field", c.bool(args.allowIdField))],
+    leanInput("items", args.items)
+  ], args.tableAlias), args);
+}
+function searchConstrainsRows(search) {
+  if (search === void 0 || search === null) return false;
+  const expression = search.expression;
+  if (!Array.isArray(expression)) return true;
+  return expression.some((entry2) => {
+    const e = entry2;
+    if (e?.type === "group") return searchConstrainsRows(e.group);
+    return true;
+  });
+}
+function assertBulkDeleteScope(constrains, allRows) {
+  if (constrains && allRows) {
+    throw new Error(
+      "db.bulk.delete: `where` and `allRows: true` contradict each other \u2014 `allRows` means every row in the table. Drop one: keep `where` for a filtered delete, keep `allRows` for a full wipe."
+    );
+  }
+  if (constrains || allRows) return;
+  throw new Error(
+    'db.bulk.delete: this deletes EVERY row in the table \u2014 a filter that constrains nothing matches all rows, so this is a truncate with a row count. (An omitted `where`, an empty `where: []`, and an empty `and()`/`or()` group all encode to the same thing, which is how a dynamically built clause list reaches it.) Pass the filter you meant (`where: expr(col("status"), "=", c.text("expired"))`), or say the wipe is deliberate with `allRows: true`.'
+  );
+}
+function dbBulkDelete(args) {
+  const context = { dbo: dboBinding(args.table, args.tableAlias) };
+  const search = encodeSearch(args.where);
+  assertBulkDeleteScope(searchConstrainsRows(search), args.allRows);
+  context.search = search ?? encodeSearch(and());
+  return annotate({ name: "mvp:dbo_bulkdelete", context, as: args.as ?? "", input: [] }, args);
+}
+function dbBulkPatch(args) {
+  return annotate(bulkStatement(
+    "mvp:dbo_bulkpatch",
+    args.table,
+    args.as,
+    [leanInput("items", args.items)],
+    args.tableAlias
+  ), args);
+}
+function dbBulkUpdate(args) {
+  return annotate(bulkStatement(
+    "mvp:dbo_bulkupdate",
+    args.table,
+    args.as,
+    [leanInput("items", args.items)],
+    args.tableAlias
+  ), args);
+}
+function isPagingValue(x) {
+  return typeof x === "object" && x !== null && "tag" in x && "value" in x && "filters" in x;
+}
+function hasPageField(paging) {
+  return !!paging && (paging.page !== void 0 || paging.per_page !== void 0 || paging.offset !== void 0);
+}
+function pagingEnabled(paging, forceEnabled) {
+  return paging?.enabled ?? (hasPageField(paging) || forceEnabled);
+}
+function encodeSimpleExternal(paging) {
+  if (!paging) return void 0;
+  const out = {};
+  for (const k of ["page", "per_page", "offset", "search", "sort"]) {
+    const v = paging[k];
+    if (isPagingValue(v)) out[k] = { value: v.value, tag: v.tag, filters: v.filters };
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function encodeExternal(ext) {
+  const p = ext.permissions ?? {};
+  return {
+    value: ext.value.value,
+    tag: ext.value.tag,
+    filters: ext.value.filters,
+    permissions: {
+      search: p.search ?? true,
+      sort: p.sort ?? true,
+      page: p.page ?? true,
+      per_page: p.per_page ?? false
+    }
+  };
+}
+function encodeBind(binds) {
+  if (!binds?.length) return void 0;
+  const seen = /* @__PURE__ */ new Set();
+  return binds.map((b) => {
+    if (b.table === null && b.as === void 0) {
+      throw new Error(
+        "db.query bind: a join with `table: null` must name its `as` alias \u2014 an unbound join has no table name to derive one from. (`table: null` represents a join whose table was deleted; fix the pulled workspace rather than authoring it.)"
+      );
+    }
+    const as = b.as ?? (typeof b.table === "string" ? b.table : b.table.name);
+    if (seen.has(as)) {
+      throw new Error(
+        `db.query bind: duplicate join alias "${as}" \u2014 two joins to the same table need distinct \`as\` values so their dotted-path columns don't collide.`
+      );
+    }
+    seen.add(as);
+    const entry2 = {
+      // `null` writes the engine's own empty binding, exactly as `dboBinding`
+      // does for the query's own table — `resolveRef` rejects a target with
+      // neither a name nor a guid.
+      dbo: { as, id: b.table === null ? "" : resolveRef("dbo", b.table) },
+      join: b.join ?? "inner"
+    };
+    const search = encodeSearch(b.where);
+    if (search !== void 0) entry2.search = search;
+    return entry2;
+  });
+}
+function collectColOperands(search, out) {
+  if (search === null || typeof search !== "object") return;
+  if (Array.isArray(search)) {
+    for (const item of search) collectColOperands(item, out);
+    return;
+  }
+  const node = search;
+  if (node.tag === "col" && typeof node.operand === "string") out.push(node.operand);
+  for (const value of Object.values(node)) collectColOperands(value, out);
+}
+function assertResolvableColumnPaths(table, tableAlias, bindAliases, paths) {
+  if (table === null || typeof table === "string" || !("schema" in table)) return;
+  const def = table;
+  const columns = new Set(tableColumns(def).map((col) => col.name));
+  const known = new Set(bindAliases);
+  if (tableAlias !== void 0) known.add(tableAlias);
+  for (const { path, surface } of paths) {
+    const dot = path.indexOf(".");
+    if (dot <= 0) continue;
+    const prefix = path.slice(0, dot);
+    if (known.has(prefix) || columns.has(prefix)) continue;
+    if (prefix === def.name) {
+      throw new Error(
+        `db.query ${surface}: "${path}" \u2014 a column of "${def.name}" qualified by the table's own name only resolves when the query declares an alias for that table. Either drop the qualifier (\`${path.slice(dot + 1)}\`) or add \`tableAlias: "${def.name}"\` to the db.query. (A JOINED column is different: it keeps its bind alias, e.g. \`col("${bindAliases[0] ?? "<join alias>"}.id")\`.)`
+      );
+    }
+    throw new Error(
+      `db.query ${surface}: "${path}" \u2014 "${prefix}" is not a resolvable alias. A dotted path must start with a join's \`as\` alias${bindAliases.length ? ` (${bindAliases.map((a) => `"${a}"`).join(", ")})` : " (this query has no joins)"}, the query's own \`tableAlias\`, or an object column of "${def.name}". Bare column names address "${def.name}" directly.`
+    );
+  }
+}
+function assertNoEvalShadow(table, evals) {
+  if (!evals?.length) return;
+  if (typeof table === "string" || !("schema" in table)) return;
+  const cols = new Set(tableColumns(table).map((col) => col.name));
+  for (const e of evals) {
+    if (cols.has(e.as)) {
+      throw new Error(
+        `db.query eval: alias "${e.as}" shadows an existing "${table.name}" column \u2014 the computed value would overwrite it. Rename the eval alias (e.g. "${e.as}_calc").`
+      );
+    }
+  }
+}
+function encodeAggregate(agg, primaryAlias) {
+  const block = {
+    sort: encodeSort(agg?.sort),
+    eval: encodeEval(qualifyAggregateEvals(agg?.eval, primaryAlias, "eval")) ?? [],
+    group: encodeEval(qualifyAggregateEvals(agg?.group, primaryAlias, "group")) ?? []
+  };
+  if (agg?.paging) {
+    block.paging = {
+      page: agg.paging.page ?? 1,
+      per_page: agg.paging.per_page ?? 25,
+      metadata: agg.paging.metadata ?? true,
+      enabled: agg.paging.enabled ?? true
+    };
+  }
+  return { type: "aggregate", aggregate: block };
+}
+var DB_RETURN_TYPES = [
+  "list",
+  "single",
+  "count",
+  "exists",
+  "stream",
+  "aggregate"
+];
+function normalizeReturnType(raw) {
+  if (raw === void 0) return "list";
+  const unwrapped = isTaggedValue(raw) && raw.filters.length === 0 && raw.tag.startsWith("const") ? raw.value : raw;
+  if (typeof unwrapped === "string" && DB_RETURN_TYPES.includes(unwrapped)) {
+    return unwrapped;
+  }
+  const shown = isTaggedValue(raw) ? `${raw.tag}:${JSON.stringify(raw.value)}` : JSON.stringify(raw);
+  throw new Error(
+    `db.query: \`returnType\` is ${shown}, which is not one of ${DB_RETURN_TYPES.map((t) => JSON.stringify(t)).join(", ")}. It used to fall through to "list", so the query ran and returned a different shape than the one asked for, with no error anywhere (issue #62). \`returnType\` is read at encode time to pick the \`context.return\` block, so it cannot be a dynamic value \u2014 a filtered or non-constant tagged value cannot be resolved here.`
+  );
+}
+function encodeReturn(returnType, sort, paging, forceEnabled = false, distinct = "auto", aggregate, primaryAlias = "") {
+  const sortEls = encodeSort(sort);
+  if (returnType === "aggregate") return encodeAggregate(aggregate, primaryAlias);
+  if (returnType === "count" || returnType === "exists") return { type: returnType };
+  if (returnType === "single") return { type: "single", single: { sort: sortEls } };
+  const enabled = pagingEnabled(paging, forceEnabled);
+  const staticInt = (v, def) => typeof v === "number" ? v : def;
+  if (returnType === "stream") {
+    const stream = { sort: sortEls, distinct };
+    if (enabled) {
+      stream.paging = {
+        page: staticInt(paging?.page, 1),
+        per_page: staticInt(paging?.per_page, 25),
+        enabled: true
+      };
+    }
+    return { type: "stream", stream };
+  }
+  const pagingObj = {
+    enabled,
+    page: staticInt(paging?.page, 1),
+    offset: staticInt(paging?.offset, 0),
+    per_page: staticInt(paging?.per_page, 25),
+    metadata: paging?.metadata ?? true,
+    totals: paging?.totals ?? false
+  };
+  const configured = enabled || paging !== void 0 || sortEls.length > 0 || distinct !== "auto";
+  if (!configured) return { type: "list" };
+  return { type: "list", list: { distinct, sort: sortEls, paging: pagingObj } };
+}
+function dbQuery(args) {
+  if (args.table !== null) {
+    assertNoAddonShadow(args.table, args.addon);
+    assertNoEvalShadow(args.table, args.eval);
+  }
+  const returnType = normalizeReturnType(args.returnType);
+  const tableName = args.table === null ? "" : typeof args.table === "string" ? args.table : args.table.name;
+  const primaryAlias = args.tableAlias ?? tableName;
+  const aggregateAddsQualifier = returnType === "aggregate" && tableName !== "" && [...args.aggregate?.group ?? [], ...args.aggregate?.eval ?? []].some(
+    (e) => !e.name.includes(".")
+  );
+  const evalAddsQualifier = tableName !== "" && (args.eval ?? []).some((e) => !e.name.includes("."));
+  const emittedAlias = args.tableAlias ?? (aggregateAddsQualifier || evalAddsQualifier ? tableName : void 0);
+  const evals = primaryAlias === "" ? args.eval : qualifyAggregateEvals(args.eval, primaryAlias, "query eval");
+  const context = { dbo: dboBinding(args.table, emittedAlias) };
+  const search = encodeSearch(args.where, args.additionalWhere);
+  if (search !== void 0) context.search = search;
+  const binds = encodeBind(args.bind);
+  if (binds) context.bind = binds;
+  {
+    const bindAliases = (binds ?? []).map(
+      (b) => b.dbo.as
+    );
+    const paths = [];
+    const push = (surface, values) => {
+      for (const path of values) paths.push({ path, surface });
+    };
+    const searchPaths = [];
+    collectColOperands(search, searchPaths);
+    push("where", searchPaths);
+    for (const b of binds ?? []) {
+      const bindPaths = [];
+      collectColOperands(b.search, bindPaths);
+      push(`bind "${b.dbo.as}" where`, bindPaths);
+    }
+    push("sort", (args.sort ?? []).map((sort) => sort.sortBy));
+    push("eval", (evals ?? []).map((e) => e.name));
+    assertResolvableColumnPaths(args.table, emittedAlias, bindAliases, paths);
+  }
+  const encodedEvals = encodeEval(evals);
+  if (encodedEvals) context.eval = encodedEvals;
+  if (args.lock !== void 0) context.lock = c.bool(args.lock);
+  const simpleExternal = encodeSimpleExternal(args.paging);
+  if (args.external !== void 0) {
+    context.return = encodeReturn(returnType, args.sort, args.paging, true, args.distinct, args.aggregate, primaryAlias);
+    context.external = encodeExternal(args.external);
+    if (simpleExternal) context.simpleExternal = simpleExternal;
+  } else {
+    context.return = encodeReturn(returnType, args.sort, args.paging, false, args.distinct, args.aggregate, primaryAlias);
+    if (simpleExternal) context.simpleExternal = simpleExternal;
+  }
+  const usesPagingEnvelope = returnType === "list" && pagingEnabled(args.paging, args.external !== void 0) && (args.paging?.metadata ?? true);
+  return annotate({
+    name: "mvp:dbo_view",
+    context,
+    as: args.as ?? "",
+    input: [],
+    ...envelope({
+      output: args.output,
+      addon: args.addon,
+      addonOffset: usesPagingEnvelope ? "items[]" : void 0
+    })
+  }, args);
+}
+function dbTransaction(args) {
+  const stmt = {
+    name: "mvp:db_transaction",
+    context: { run: args.body.map(encodeStatement) },
+    input: []
+  };
+  if (args.as !== void 0) stmt.as = args.as;
+  return annotate(stmt, args);
+}
+var EXTERNAL_SQL_NAME = {
+  mssql: "mvp:dbo_external_mssql_query",
+  mysql: "mvp:dbo_external_mysql_query",
+  oracle: "mvp:dbo_external_oracle_query",
+  postgres: "mvp:dbo_external_postgres_query",
+  snowflake: "mvp:dbo_external_snowflake_query"
+};
+function dbExternalQuery(args) {
+  const connection = args.connectionString;
+  const connectionContext = typeof connection === "string" ? { connection_string: connection } : {
+    connection_string_flex: {
+      value: connection.value,
+      tag: connection.tag,
+      filters: connection.filters
+    }
+  };
+  return annotate({
+    name: EXTERNAL_SQL_NAME[args.engine],
+    context: {
+      code: args.sql,
+      response_type: args.responseType ?? "list",
+      ...args.parser === void 0 ? {} : { parser: args.parser },
+      ...connectionContext,
+      arg: (args.args ?? []).map((v) => ({ value: v.value, tag: v.tag, filters: v.filters }))
+    },
+    as: args.as ?? "",
+    input: [],
+    ...envelope()
+  }, args);
+}
+registerStatement("mvp:dbo_add", dbAdd);
+registerStatement("mvp:dbo_editby", dbEdit);
+registerStatement("mvp:dbo_addoreditby", dbAddOrEdit);
+registerStatement("mvp:dbo_bulkadd", dbBulkAdd);
+registerStatement("mvp:dbo_bulkdelete", dbBulkDelete);
+registerStatement("mvp:dbo_bulkpatch", dbBulkPatch);
+registerStatement("mvp:dbo_bulkupdate", dbBulkUpdate);
+registerStatement("mvp:dbo_view", dbQuery);
+registerStatement("mvp:db_transaction", dbTransaction);
+registerStatement("mvp:dbo_external_mssql_query", (a) => dbExternalQuery({ ...a, engine: "mssql" }));
+registerStatement("mvp:dbo_external_mysql_query", (a) => dbExternalQuery({ ...a, engine: "mysql" }));
+registerStatement("mvp:dbo_external_oracle_query", (a) => dbExternalQuery({ ...a, engine: "oracle" }));
+registerStatement("mvp:dbo_external_postgres_query", (a) => dbExternalQuery({ ...a, engine: "postgres" }));
+registerStatement("mvp:dbo_external_snowflake_query", (a) => dbExternalQuery({ ...a, engine: "snowflake" }));
+registerStatement("mvp:dbo_getby", dbGet);
+registerStatement("mvp:dbo_get", dbGetById);
+registerStatement("mvp:dbo_delby", dbDel);
+registerStatement("mvp:dbo_hasby", dbHas);
+registerStatement("mvp:dbo_patch", dbPatch);
+registerStatement("mvp:dbo_truncate", dbTruncate);
+registerStatement("mvp:dbo_get_schema", dbSchema);
+registerStatement("mvp:dbo_direct_query", dbDirectQuery);
+
+// src/statements/generated/catalog.ts
+for (const spec2 of GENERATED_SPECS) {
+  if (!isRegisteredStatement(spec2.name)) registerSpec(spec2);
+}
+var specByName = new Map(GENERATED_SPECS.map((s2) => [s2.name, s2]));
+function spec(name) {
+  const s2 = specByName.get(name);
+  if (!s2) throw new Error(`Generated catalog is missing expected statement "${name}".`);
+  return s2;
+}
+function mutation(name) {
+  const s2 = spec(name);
+  return (varName, value) => encodeFromSpec(s2, { name: varName, value });
+}
+function objectOp(name) {
+  const s2 = spec(name);
+  return (as, value) => encodeFromSpec(s2, { as, value });
+}
+var mathAdd = mutation("mvp:math_add");
+var mathSub = mutation("mvp:math_sub");
+var mathMul = mutation("mvp:math_mul");
+var mathDiv = mutation("mvp:math_div");
+var bitwiseAnd = mutation("mvp:bitwise_and");
+var bitwiseOr = mutation("mvp:bitwise_or");
+var bitwiseXor = mutation("mvp:bitwise_xor");
+var textAppend = mutation("mvp:text_append");
+var textPrepend = mutation("mvp:text_prepend");
+var objectKeys = objectOp("mvp:object_keys");
+var objectValues = objectOp("mvp:object_values");
+var objectEntries = objectOp("mvp:object_entries");
+var GENERATED_STATEMENT_NAMES = GENERATED_SPECS.map((s2) => s2.name);
+
+// src/kinds/microservice.ts
+function declaredServicePorts(def) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const container of def.deployment?.containers ?? []) {
+    for (const port of container.ports ?? []) {
+      if (port.servicePort) seen.add(port.servicePort);
+    }
+  }
+  return [...seen];
+}
+function argvEntries(argv) {
+  return (argv ?? []).map((name) => ({ name }));
+}
+function encodeContainer(c2) {
+  if (!c2.name) throw new Error("microservice: every container needs a `name`.");
+  return {
+    name: c2.name,
+    type: c2.type ?? "standard",
+    image: c2.image ?? "",
+    // `containerPort` defaults to `servicePort`, which is what the engine's own
+    // scaffold does when a port omits it.
+    ports: (c2.ports ?? []).map((p) => ({
+      servicePort: p.servicePort,
+      containerPort: p.containerPort ?? p.servicePort
+    })),
+    resources: { cpu: c2.resources?.cpu ?? "", ram: c2.resources?.ram ?? "" },
+    command: argvEntries(c2.command),
+    args: argvEntries(c2.args),
+    envs: (c2.env ?? []).map((e) => ({ name: e.name, value: e.value ?? "" })),
+    volumes: (c2.volumes ?? []).map((v) => ({ ...v })),
+    ...c2.pullSecret !== void 0 ? { pull_secret: c2.pullSecret } : {}
+  };
+}
+function encodeMicroservice(def) {
+  if (!def.name) throw new Error("microservice: `name` is required.");
+  const kind = def.kind ?? "builtin";
+  if (kind === "helm" && (def.deployment || def.ingresses?.length || def.configs?.length || def.volumes?.length)) {
+    throw new Error(
+      'microservice: `kind: "helm"` takes a `chart` and no deployment blocks \u2014 `deployment`/`ingresses`/`configs`/`volumes` belong to `kind: "builtin"`.'
+    );
+  }
+  if (kind !== "helm" && def.chart) {
+    throw new Error(
+      'microservice: `chart` belongs to `kind: "helm"`. A builtin microservice declares containers instead.'
+    );
+  }
+  const deployment = def.deployment ?? {};
+  return {
+    name: def.name,
+    description: def.description ?? "",
+    kind,
+    tenant_deploy: def.tenantDeploy ?? "auto",
+    configs: (def.configs ?? []).map((c2) => ({
+      name: c2.name,
+      type: c2.type ?? "",
+      value: c2.value ?? ""
+    })),
+    volumes: (def.volumes ?? []).map((v) => ({
+      name: v.name,
+      size: v.size ?? "",
+      class: v.class ?? ""
+    })),
+    ingresses: (def.ingresses ?? []).map((i) => ({
+      name: i.name,
+      domain: i.domain ?? "",
+      paths: (i.paths ?? []).map((p) => ({ service: p.service ?? "", path: p.path ?? "" }))
+    })),
+    deployment: {
+      docker: deployment.docker ?? "",
+      replicas: deployment.replicas ?? 1,
+      strategy: deployment.strategy ?? "Recreate",
+      containers: (deployment.containers ?? []).map(encodeContainer)
+    },
+    chart: {
+      ref: def.chart?.ref ?? "",
+      values: def.chart?.values ?? "",
+      version: def.chart?.version ?? ""
+    },
+    registry_auth: {
+      type: def.registryAuth?.type ?? "",
+      server: def.registryAuth?.server ?? "",
+      dockerconfigjson: def.registryAuth?.dockerconfigjson ?? ""
+    }
+  };
+}
+function microservice(def) {
+  encodeMicroservice(def);
+  return def;
+}
+var microserviceKind = {
+  name: "microservice",
+  payloadKey: "microservice",
+  encode: encodeMicroservice
+};
+registerKind(microserviceKind);
+
+// src/statements/special/api-request.ts
+function apiRequest(a = {}) {
+  assertSslConsistency("api.request", a);
+  return generated.api.request({
+    as: a.as,
+    url: coerceText(a.url),
+    ...coerceHttpFields(a),
+    disabled: a.disabled,
+    description: a.description,
+    output: a.output
+  });
+}
+function streamFromRequest(a = {}) {
+  assertSslConsistency("stream.from_request", a);
+  return annotate(generated.stream.from_request({
+    as: a.as,
+    url: coerceText(a.url),
+    ...coerceHttpFields(a)
+  }), a);
+}
+function webflowRequest(a = {}) {
+  assertSslConsistency("webflow.request", a);
+  return generated.webflow.request({
+    as: a.as,
+    path: coerceText(a.path),
+    ...coerceHttpFields(a),
+    disabled: a.disabled,
+    description: a.description
+  });
+}
+
+// src/statements/special/microservice.ts
+function resolveMicroserviceHost(host, port) {
+  if (isValue2(host)) {
+    if (port !== void 0) {
+      throw new Error(
+        'microservice.request: `port` cannot be joined onto a dynamic `host` at build time. Build the joined `"name:port"` string in the value itself instead.'
+      );
+    }
+    return host;
+  }
+  if (typeof host === "string") {
+    if (port !== void 0 && host.includes(":")) {
+      throw new Error(
+        `microservice.request: \`host\` already carries a port ("${host}"), so \`port: ${String(port)}\` is ambiguous. Pass the port once \u2014 either joined into \`host\` or as \`port\`.`
+      );
+    }
+    return port === void 0 ? host : `${host}:${port}`;
+  }
+  const declared = declaredServicePorts(host);
+  if (port !== void 0) {
+    if (declared.length > 0 && !declared.includes(String(port))) {
+      throw new Error(
+        `microservice.request: microservice "${host.name}" does not expose port ${String(port)}. It declares: ${declared.join(", ")}.`
+      );
+    }
+    return `${host.name}:${port}`;
+  }
+  if (declared.length === 1) return `${host.name}:${declared[0]}`;
+  if (declared.length === 0) return host.name;
+  throw new Error(
+    `microservice.request: microservice "${host.name}" declares ${declared.length} ports (${declared.join(", ")}), so \`port\` is required to pick one.`
+  );
+}
+var MICROSERVICE_DEFAULTS = {
+  method: "GET",
+  params: {},
+  headers: [],
+  timeout: 10,
+  follow_location: true
+};
+function microserviceRequest(a) {
+  return generated.microservice.request({
+    as: a.as,
+    host: coerceText(resolveMicroserviceHost(a.host, a.port)),
+    path: coerceText(a.path),
+    // `??` (not `||`) so an explicit `false`/`0`/`""` is honored, not defaulted.
+    method: coerceText(a.method ?? MICROSERVICE_DEFAULTS.method),
+    params: coerceObj(a.params ?? MICROSERVICE_DEFAULTS.params),
+    headers: coerceHeaders(a.headers ?? MICROSERVICE_DEFAULTS.headers),
+    timeout: coerceInt(a.timeout ?? MICROSERVICE_DEFAULTS.timeout),
+    follow_location: coerceBool(a.follow_location ?? MICROSERVICE_DEFAULTS.follow_location),
+    disabled: a.disabled,
+    description: a.description
+  });
+}
+
+// src/statements/special/precondition.ts
+var PRECONDITION_ERROR_TYPES = [
+  "standard",
+  "notfound",
+  "toomanyrequests",
+  "accessdenied",
+  "unauthorized",
+  "badrequest",
+  "inputerror"
+];
+var PRECONDITION_ERROR_STATUS = {
+  standard: 500,
+  badrequest: 400,
+  inputerror: 400,
+  unauthorized: 401,
+  accessdenied: 403,
+  notfound: 404,
+  toomanyrequests: 429
+};
+function precondition(a = {}) {
+  return generated.precondition(a);
+}
+function throwError(a) {
+  return generated.throw(a);
+}
+
+// src/statements/special/closed-sets.ts
+var STORAGE_ACCESS = ["public", "private"];
+var HEADER_DUPLICATES = ["replace", "append"];
+function createAttachment(a) {
+  return generated.storage.create_attachment(a);
+}
+function createAudio(a) {
+  return generated.storage.create_audio(a);
+}
+function createImage(a) {
+  return generated.storage.create_image(a);
+}
+function createVideo(a) {
+  return generated.storage.create_video(a);
+}
+function setHeader(a) {
+  return generated.util.set_header(a);
+}
+
+// src/statements/special/lambda-args.ts
+function lambda(a = {}) {
+  return generated.lambda(a);
+}
+
+// src/statements/s.ts
+var externalQuery = (engine) => ({
+  direct_query: (a) => dbExternalQuery({ ...a, engine })
+});
+var cloudJobNs = Object.assign(cloudJob, { await: cloudJobAwait, status: cloudJobStatus });
+var s = {
+  ...generated,
+  // Typed overrides of generated factories: `precondition` narrows `error_type`
+  // to the status-bearing enum, and `throw` documents that it returns HTTP 200
+  // (use `precondition` for a status-observable rejection). See issue #21.
+  precondition,
+  throw: throwError,
+  // Typed refusal of `capture`, which belongs to `lam.fn` — the bare TS2353 the
+  // generated factory produced implied dropping the field rather than moving
+  // the body. Same bytes (#73).
+  lambda,
+  // Hand-authored specials (not in the codegen'd catalog).
+  set_var: setVar,
+  update_var: updateVar,
+  conditional,
+  comment,
+  for: forLoop,
+  foreach: foreachLoop,
+  while: whileLoop,
+  group,
+  switch: switchStatement,
+  try_catch: tryCatch,
+  return: returnValue,
+  foreach_break: foreachBreak,
+  foreach_continue: foreachContinue,
+  foreach_remove: foreachRemove,
+  // Call family — invoke another workspace object. `api.call`/`api.realtime_event`
+  // merge into the generated `api` namespace; the rest are new namespaces.
+  // `api.request` (and `stream.from_request`/`webflow.request`/`microservice.request`
+  // below) are typed hand-authored overrides of their generated factories.
+  function: { run: functionRun, call: functionCall },
+  action: { call: actionCall, package: { call: actionPackageCall } },
+  workflow_test: { call: workflowTestCall },
+  api: { ...generated.api, call: apiCall, realtime_event: realtimeEvent, request: apiRequest },
+  // Microservices are a top-level feature: the `microservice()` def and the
+  // statement that calls one live side by side. The override is load-bearing —
+  // `...generated` above already exposes the RAW generated factory here, and it
+  // has none of the defaulting that lets a call name only `host` and `path`.
+  microservice: { ...generated.microservice, request: microserviceRequest },
+  // `realtime.publish` is the CURRENT-layer send statement (`api.realtime_event` is the
+  // superseded one); `get_session` beside it is generated.
+  realtime: { ...generated.realtime, publish: realtimePublish },
+  stream: { ...generated.stream, from_request: streamFromRequest },
+  webflow: { ...generated.webflow, request: webflowRequest },
+  task: { call: taskCall },
+  tool: { call: toolCall },
+  trigger: { call: triggerCall },
+  middleware: { call: middlewareCall },
+  addon: { call: addonCall },
+  // Database family — merges into the generated `db` namespace.
+  db: {
+    ...generated.db,
+    add: dbAdd,
+    edit: dbEdit,
+    add_or_edit: dbAddOrEdit,
+    get: dbGet,
+    get_by_id: dbGetById,
+    del: dbDel,
+    has: dbHas,
+    patch: dbPatch,
+    truncate: dbTruncate,
+    schema: dbSchema,
+    direct_query: dbDirectQuery,
+    query: dbQuery,
+    transaction: dbTransaction,
+    bulk: { add: dbBulkAdd, delete: dbBulkDelete, patch: dbBulkPatch, update: dbBulkUpdate },
+    external: {
+      mssql: externalQuery("mssql"),
+      mysql: externalQuery("mysql"),
+      oracle: externalQuery("oracle"),
+      postgres: externalQuery("postgres"),
+      snowflake: externalQuery("snowflake")
+    }
+  },
+  // AI agent + cloud jobs.
+  ai: { ...generated.ai, agent: { run: aiAgentRun } },
+  cloud: { ...generated.cloud, job: cloudJobNs },
+  // Array map/union, expect.to_throw, auth-token, raw-input/post-process merge
+  // into their generated namespaces.
+  array: { ...generated.array, map: arrayMap, union: arrayUnion },
+  expect: { ...generated.expect, to_throw: expectToThrow, to_match: expectToMatch },
+  security: { ...generated.security, create_auth_token: createAuthToken, create_guid: createGuid },
+  util: {
+    ...generated.util,
+    get_raw_input: getRawInput,
+    get_input: getRawInput,
+    post_process: postProcess,
+    // Typed override of the generated factory: same bytes, plus the nested
+    // result shape a `ref` into the bound var has no other way to learn (#226).
+    ip_lookup: ipLookup,
+    // `duplicates` is a closed set the codegen ships as a bare `string`.
+    set_header: setHeader
+  },
+  // `access` is a closed set the codegen ships as a bare `string`, and it
+  // defaults to `public` — a misspelled `"private"` used to serve the file to
+  // the world with no compile-time signal.
+  storage: {
+    ...generated.storage,
+    create_attachment: createAttachment,
+    create_audio: createAudio,
+    create_image: createImage,
+    create_video: createVideo
+  }
+};
+
+// src/kinds/realtime-channel.ts
+function realtimeServerRefName(context, server) {
+  const name = typeof server === "string" ? server : server?.name;
+  if (!name) {
+    throw new Error(`${context}: \`server\` is required \u2014 a channel path is unique only within its realtime server.`);
+  }
+  return name;
+}
+function resolveRealtimeServerRef(context, server) {
+  if (typeof server !== "string" && server?.guid) return server.guid;
+  return deriveGuid("realtime_server", realtimeServerRefName(context, server));
+}
+function encodeRealtimeChannel(def) {
+  if (!def.name) throw new Error("realtimeChannel: `name` is required (the channel path).");
+  const context = `realtimeChannel "${def.name}"`;
+  assertChannelPathParams(def);
+  return {
+    name: def.name,
+    description: def.description ?? "",
+    active: def.active ?? true,
+    server: { id: resolveRealtimeServerRef(context, def.server) },
+    input: Object.entries(def.input ?? {}).map(([name, d]) => encodeInput(name, d)),
+    anonymous_clients: def.anonymousClients ?? false,
+    presence: def.presence ?? false,
+    publish: {
+      who: def.publish?.who ?? "nobody",
+      direct: def.publish?.direct ?? false
+    },
+    conversation: {
+      enabled: def.conversation?.enabled ?? false,
+      limit: def.conversation?.limit ?? 0,
+      ttl: def.conversation?.ttl ?? 0
+    },
+    delivery: {
+      guarantee: def.delivery?.guarantee ?? "at_most_once",
+      per_recipient: def.delivery?.perRecipient ?? false
+    },
+    rate_limit: { messages_per_minute: def.rateLimit?.messagesPerMinute ?? 0 },
+    history: encodeContainerHistory("message", def.history),
+    tag: encodeTags(def.tags)
+  };
+}
+var realtimeChannelKind = {
+  name: "channel",
+  payloadKey: "channel",
+  encode: encodeRealtimeChannel,
+  guidOf: (def) => realtimeChannelGuid(def)
+};
+registerKind(realtimeChannelKind);
+function channelPathParams(path) {
+  return parsePathParams(`realtimeChannel "${path}"`, path);
+}
+function assertChannelPathParams(def) {
+  const context = `realtimeChannel "${def.name}"`;
+  assertStoredName(context, def.name, "route");
+  const params = parsePathParams(context, def.name);
+  assertPathParamInputs(context, params, def.input);
+  return params;
+}
+function realtimeChannel(def) {
+  assertChannelPathParams(def);
+  const context = `realtimeChannel "${def.name}"`;
+  const getChannel = (params) => fillPathParams(context, "getChannel()", def.name, params);
+  return { ...def, getChannel };
+}
+function realtimeChannelGuid(def) {
+  if (def.guid) return def.guid;
+  const context = `realtimeChannel "${def.name}"`;
+  return deriveGuid(
+    "channel",
+    realtimeChannelSeedName(realtimeServerRefName(context, def.server), def.name)
+  );
+}
+
+// src/kinds/trigger-inputs.ts
+var ERROR_EVENT_DESCRIPTION = `Which event fired the trigger. "new" fires on first capture and on every snapshot re-capture for non-ignored signatures (rate-limited by the ~5min snapshot dedup window). "regression" fires when a previously-fixed signature re-occurs (the fix didn't hold, or the same bug regressed back). "fixed" fires when a user marks a signature as fixed.`;
+function realtimeClientInput() {
+  return input.object(
+    {
+      extras: f.json(),
+      permissions: f.object({ dbo_id: f.int(), row_id: f.text() }, { required: true })
+    },
+    { required: true }
+  );
+}
+function encodeAll(map) {
+  return Object.entries(map).map(([name, d]) => encodeInput(name, d));
+}
+var CATALOG = {
+  // Database trigger — new/old rows, action op, datasource label.
+  database: () => ({
+    new: input.json(),
+    old: input.json(),
+    action: input.enum(["insert", "update", "delete", "truncate"], { required: true }),
+    // NOTE (Xano quirk, mirror don't fix): `updateDefaults` stores `datasource`
+    // as `text` but copy-pastes the `action` enum into its `values`. We mirror
+    // the stored shape exactly rather than "correcting" it.
+    datasource: input.text({ required: true, values: ["insert", "update", "delete", "truncate"] })
+  }),
+  // Toolset trigger (MCP server / agent) — the connected toolset + its tools.
+  toolset: () => ({
+    toolset: input.object(
+      {
+        id: f.int({ description: "The toolset ID" }),
+        name: f.text({ description: "The toolset name", methods: ["trim"] }),
+        instructions: f.text({ description: "The toolset instructions", methods: ["trim"] })
+      },
+      { description: "The toolset being connected to" }
+    ),
+    tools: input.list(
+      input.object({
+        id: f.int({ description: "The tool ID" }),
+        name: f.text({ description: "The tool name", methods: ["trim"] }),
+        instructions: f.text({ description: "The tool instructions", methods: ["trim"] })
+      }),
+      { description: "The list of tools on the MCP Server" }
+    )
+  }),
+  // Workspace lifecycle trigger — branch action + the branches involved.
+  workspace: () => ({
+    to_branch: input.object({ id: f.int(), label: f.text({ methods: ["trim"] }) }),
+    from_branch: input.object({ id: f.int(), label: f.text({ methods: ["trim"] }) }),
+    action: input.enum(["branch_live", "branch_merge", "branch_new"], { required: true })
+  }),
+  // Realtime channel trigger — message/join action + channel/client/options/payload.
+  workspace_realtime_channel: () => ({
+    action: input.enum(["message", "join"], { required: true, default: "message" }),
+    channel: input.text({ required: true }),
+    client: input.object(
+      {
+        extras: f.json(),
+        permissions: f.object(
+          { dbo_id: f.int(), row_id: f.text() },
+          { required: true }
+        )
+      },
+      { required: true }
+    ),
+    options: input.object({ authenticated: f.bool(), channel: f.text() }),
+    payload: input.json({ required: true, nullable: true })
+  }),
+  // Realtime SERVER lifecycle trigger — connect/disconnect on a realtime server.
+  // Mirrors the engine's stored input array exactly: the action enum carries NO
+  // default (unlike the legacy channel trigger's `"message"`), and `client` is
+  // the same connecting-client object both realtime lifecycle types use.
+  realtime_server: () => ({
+    action: input.enum(["connect", "disconnect"], { required: true }),
+    realtime_server: input.text({ required: true }),
+    client: realtimeClientInput()
+  }),
+  // Realtime CHANNEL lifecycle trigger — join/leave/deliver on a channel. Same
+  // shape as the server type with the addressed channel path in place of the
+  // server name.
+  //
+  // The action enum carries all THREE actions the engine declares for this type,
+  // regardless of which ones a given trigger enables: the enum describes what
+  // `action` can hold at runtime, and the per-trigger selection lives in `meta`.
+  //
+  // `payload` IS declared, and it is what distinguishes this type from the server
+  // one above. It sits between `channel` and `client`, and it is the message body
+  // — optional (a join/leave carries none) and nullable, unlike the LEGACY
+  // channel trigger's required `payload`.
+  //
+  // This entry was previously absent, on the strength of a live capture read as
+  // showing a `deliver`-only trigger storing three inputs. A sweep of a current
+  // instance says otherwise, without exception: all 30 channel triggers store
+  // four entries in this order, and all 11 realtime_server triggers store three.
+  // A pulled channel trigger was regenerating an input short, so `inp("payload")`
+  // did not resolve and re-deploying dropped an entry the engine supplies.
+  channel: () => ({
+    action: input.enum(["join", "leave", "deliver"], { required: true }),
+    channel: input.text({ required: true }),
+    payload: input.json({ nullable: true }),
+    client: realtimeClientInput()
+  }),
+  // Error trigger — the error signature schema (verbatim from buildErrorTriggerInputSchema).
+  error: () => ({
+    event: input.enum(["new", "regression", "fixed"], { description: ERROR_EVENT_DESCRIPTION }),
+    id: input.int({
+      description: "The error signature row id. Use to build deep links into the error-logs UI."
+    }),
+    signature: input.text({ description: "Stable hash that identifies this error signature." }),
+    error: input.object(
+      {
+        code: f.text({ description: "Machine-readable error code." }),
+        message: f.text({ description: "Human-readable error message." })
+      },
+      { description: "Error code and message captured from the failing run." }
+    ),
+    caller: input.object(
+      {
+        type: f.text({
+          description: "Caller kind (api, function, task, middleware, trigger, unknown)."
+        }),
+        id: f.int({ description: "Caller object id." }),
+        name: f.text({ description: "Caller object name.", nullable: true })
+      },
+      { description: "Where the error originated. Null on 'fixed' events.", nullable: true }
+    ),
+    statement: input.object(
+      {
+        name: f.text({ description: "Statement name." }),
+        xsid: f.text({ description: "Statement xsid within the function stack." })
+      },
+      { description: "Failing statement. Null on 'fixed' events.", nullable: true }
+    ),
+    actor: input.object(
+      {
+        id: f.int({ description: "User id." }),
+        name: f.text({ description: "User name.", nullable: true })
+      },
+      {
+        description: "User who marked the error as fixed. Populated only for 'fixed' events.",
+        nullable: true
+      }
+    ),
+    count: input.object(
+      {
+        total: f.int({ description: "Total occurrences since first seen." }),
+        last_hour: f.int({ description: "Occurrences in the last hour." })
+      },
+      { description: "Occurrence counts for this signature." }
+    ),
+    first_seen: input.text({ description: "ISO-8601 UTC timestamp of the first occurrence." }),
+    last_seen: input.text({ description: "ISO-8601 UTC timestamp of the most recent occurrence." }),
+    fixed_at: input.text({
+      description: "ISO-8601 UTC timestamp the error was marked fixed. Null otherwise.",
+      nullable: true
+    })
+  })
+};
+function impliedInputs(objType) {
+  return encodeAll(CATALOG[objType]());
+}
+
+// src/kinds/trigger-handle.ts
+function accessor(base) {
+  const fn = (path) => inp(`${base}.${path}`);
+  return Object.assign(fn, inp(base));
+}
+function buildTriggerHandle(objType) {
+  const handle = {};
+  for (const { name } of impliedInputs(objType)) {
+    handle[name] = accessor(name);
+  }
+  return handle;
+}
+
+// src/kinds/trigger.ts
+function baseMeta() {
+  return {
+    database: {
+      datasource: [],
+      search: { expression: [] },
+      action: { delete: false, insert: false, truncate: false, update: false }
+    },
+    toolset: { action: { connection: false } },
+    workspace: { action: { branch_live: false, branch_merge: false, branch_new: false } },
+    workspace_realtime_channel: { action: { message: false, join: false } },
+    // The two realtime lifecycle groups. Every trigger type carries the WHOLE
+    // skeleton with only its own group's flags set — verified against a live
+    // engine capture, which emits all six groups for a table trigger, a workspace
+    // trigger, and both realtime lifecycle triggers alike.
+    realtime_server: { action: { connect: false, disconnect: false } },
+    channel: { action: { join: false, leave: false, deliver: false } }
+  };
+}
+function assertSearchMatchesActions(name, expression, action) {
+  if (action.truncate) {
+    throw new Error(
+      `tableTrigger "${name}": \`search\` is not supported with the \`truncate\` action \u2014 a truncate fires once for the whole table, with no row to test.`
+    );
+  }
+  const operands = collectOperands(expression);
+  for (const [enabled, forbidden] of [
+    [action.insert, "OLD"],
+    [action.delete, "NEW"]
+  ]) {
+    if (!enabled) continue;
+    const hit = operands.find((o) => o.startsWith(`${forbidden}.`));
+    if (hit !== void 0) {
+      const act = forbidden === "OLD" ? "insert" : "delete";
+      throw new Error(
+        `tableTrigger "${name}": \`search\` reads \`${hit}\`, which does not exist for the \`${act}\` action this trigger is enabled for. Use ${forbidden === "OLD" ? "`NEW.*`" : "`OLD.*`"}, or split the actions into separate triggers.`
+      );
+    }
+  }
+}
+function collectOperands(node) {
+  if (Array.isArray(node)) return node.flatMap(collectOperands);
+  if (node === null || typeof node !== "object") return [];
+  const out = [];
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "operand" && typeof value === "string") out.push(value);
+    else out.push(...collectOperands(value));
+  }
+  return out;
+}
+function encodeTrigger(def) {
+  if (!def.name) throw new Error("trigger: `name` is required.");
+  const xdo = {
+    name: def.name,
+    active: def.active ?? true,
+    description: def.description ?? "",
+    obj_id: def.objId ?? 0,
+    obj_type: def.objType,
+    history: encodeHistory("trigger", def.history),
+    output: [],
+    meta: def.meta,
+    tag: encodeTags(def.tags),
+    // Inputs are implied by type (fixed by Xano, not user-editable) — always
+    // inject the canonical per-type array, never a user-supplied map.
+    input: impliedInputs(def.objType),
+    run: (def.stack ?? []).map(encodeStatement)
+  };
+  if (def.hasResult) {
+    xdo.result = encodeResponse(def.response);
+  } else {
+    xdo.result = [];
+  }
+  return xdo;
+}
+function tableTrigger(args) {
+  const meta = baseMeta();
+  meta.database.datasource = (args.datasources ?? []).map((tag) => ({ tag }));
+  meta.database.action = {
+    delete: args.actions?.delete ?? false,
+    insert: args.actions?.insert ?? false,
+    truncate: args.actions?.truncate ?? false,
+    update: args.actions?.update ?? false
+  };
+  if (args.search !== void 0) {
+    const encoded = encodeExpression(args.search);
+    assertSearchMatchesActions(args.name, encoded.expression, meta.database.action);
+    meta.database.search = encoded;
+  }
+  const objId = args.table !== void 0 ? resolveRef("dbo", args.table) : args.objId;
+  const t = buildTriggerHandle("database");
+  return {
+    name: args.name,
+    guid: args.guid,
+    description: args.description,
+    active: args.active,
+    tags: args.tags,
+    objId,
+    objType: "database",
+    hasResult: false,
+    meta,
+    stack: args.stack?.(t) ?? []
+  };
+}
+function realtimeTrigger(args) {
+  const meta = baseMeta();
+  meta.workspace_realtime_channel.action = {
+    message: args.actions?.message ?? false,
+    join: args.actions?.join ?? false
+  };
+  const t = buildTriggerHandle("workspace_realtime_channel");
+  return {
+    name: args.name,
+    guid: args.guid,
+    description: args.description,
+    active: args.active,
+    tags: args.tags,
+    objId: args.objId,
+    objType: "workspace_realtime_channel",
+    hasResult: true,
+    meta,
+    // The `?? []` fallback matches `S`'s own `readonly []` default (which is what
+    // `S` resolves to when the callback is omitted); the cast covers the branch
+    // TypeScript cannot tie back to that default.
+    stack: args.stack?.(t) ?? [],
+    // Xano default (updateResult): echo the `payload` input back. It is a plain
+    // `Value` with no trace, so an omitted callback derives `unknown`.
+    response: args.response ? args.response(t) : inp("payload")
+  };
+}
+function realtimeServerTrigger(args) {
+  const t = buildTriggerHandle("realtime_server");
+  const serverMeta = baseMeta();
+  serverMeta.realtime_server.action = {
+    connect: args.actions?.connect ?? false,
+    disconnect: args.actions?.disconnect ?? false
+  };
+  return {
+    name: args.name,
+    guid: args.guid,
+    description: args.description,
+    active: args.active,
+    tags: args.tags,
+    objId: args.realtimeServer !== void 0 ? resolveRef("realtime_server", args.realtimeServer) : args.objId,
+    objType: "realtime_server",
+    hasResult: true,
+    meta: serverMeta,
+    // See the `realtimeTrigger` note: the fallback matches `S`'s own default.
+    stack: args.stack?.(t) ?? [],
+    response: args.response?.(t)
+  };
+}
+function realtimeChannelTrigger(args) {
+  const t = buildTriggerHandle("channel");
+  const channelMeta = baseMeta();
+  channelMeta.channel.action = {
+    join: args.actions?.join ?? false,
+    leave: args.actions?.leave ?? false,
+    deliver: args.actions?.deliver ?? false
+  };
+  return {
+    name: args.name,
+    guid: args.guid,
+    description: args.description,
+    active: args.active,
+    tags: args.tags,
+    objId: args.channel !== void 0 ? realtimeChannelGuid(args.channel) : args.objId,
+    objType: "channel",
+    hasResult: true,
+    meta: channelMeta,
+    // See the `realtimeTrigger` note: the fallback matches `S`'s own default.
+    stack: args.stack?.(t) ?? [],
+    response: args.response?.(t)
+  };
+}
+function mcpServerTrigger(args) {
+  return toolsetTrigger(args, args.mcpServer);
+}
+function agentTrigger(args) {
+  return toolsetTrigger(args, args.agent);
+}
+function workspaceTrigger(args) {
+  const meta = baseMeta();
+  meta.workspace.action = {
+    branch_live: args.actions?.branch_live ?? false,
+    branch_merge: args.actions?.branch_merge ?? false,
+    branch_new: args.actions?.branch_new ?? false
+  };
+  const t = buildTriggerHandle("workspace");
+  return {
+    name: args.name,
+    guid: args.guid,
+    description: args.description,
+    active: args.active,
+    tags: args.tags,
+    objId: args.objId,
+    objType: "workspace",
+    hasResult: false,
+    meta,
+    stack: args.stack?.(t) ?? []
+  };
+}
+function errorTrigger(args) {
+  const t = buildTriggerHandle("error");
+  return {
+    name: args.name,
+    guid: args.guid,
+    description: args.description,
+    active: args.active,
+    tags: args.tags,
+    objId: args.objId,
+    objType: "error",
+    hasResult: false,
+    meta: baseMeta(),
+    stack: args.stack?.(t) ?? []
+  };
+}
+function toolsetTrigger(args, target) {
+  const meta = baseMeta();
+  meta.toolset.action.connection = true;
+  const t = buildTriggerHandle("toolset");
+  return {
+    name: args.name,
+    guid: args.guid,
+    description: args.description,
+    active: args.active,
+    tags: args.tags,
+    objId: target !== void 0 ? resolveRef("toolset", target) : args.objId,
+    objType: "toolset",
+    hasResult: true,
+    meta,
+    // Xano default (updateRun): copy the toolset/tools inputs into stack vars.
+    // See the `realtimeTrigger` note on the cast; the default stack's `set_var`
+    // bindings are untraceable anyway, so an omitted callback derives `unknown`.
+    stack: args.stack ? args.stack(t) : [setVar("toolset", inp("toolset")), setVar("tools", inp("tools"))],
+    // Xano default (updateResult): return the toolset/tools vars.
+    response: args.response ? args.response(t) : { toolset: ref("toolset"), tools: ref("tools") }
+  };
+}
+var triggerKind = {
+  name: "trigger",
+  payloadKey: "trigger",
+  encode: encodeTrigger
+};
+registerKind(triggerKind);
+
+// src/kinds/workspace-config.ts
+var LEGACY_REALTIME = {
+  hash: "",
+  mode: "",
+  enabled: false,
+  channels: []
+};
+var DEFAULT_DOCUMENTATION = {
+  token: "",
+  whitelist: {},
+  require_token: false
+};
+var DEFAULT_PREFERENCES = {
+  allow_push: false,
+  track_performance: true,
+  use_internal_docs: false
+};
+var DEFAULT_SETTINGS = {
+  ai_enabled: false,
+  ai_settings: {
+    providers: {
+      google: { model: "", api_key: "" },
+      openai: { model: "", api_key: "" },
+      anthropic: { model: "", api_key: "" },
+      "azure-openai": { model: "", api_key: "", base_url: "", api_version: "" }
+    },
+    default_provider: "free"
+  },
+  hide_xano_agent: false
+};
+function mergeOverDefaults(defaults, authored) {
+  return mergeOver(
+    defaults,
+    authored ?? {}
+  );
+}
+function mergeOver(base, over) {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(over)) {
+    const under = out[key];
+    out[key] = isPlainRecord(under) && isPlainRecord(value) ? mergeOver(under, value) : structuredClone(value);
+  }
+  return out;
+}
+function isPlainRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function encodeWorkspaceEnv(env) {
+  return Object.entries(env).map(([name, value]) => ({ name, value, market_item: [] }));
+}
+function encodeWorkspaceMiddleware(m) {
+  return {
+    function_pre: encodeMiddlewareList(m.function?.pre),
+    function_post: encodeMiddlewareList(m.function?.post),
+    query_pre: encodeMiddlewareList(m.query?.pre),
+    query_post: encodeMiddlewareList(m.query?.post),
+    task_pre: encodeMiddlewareList(m.task?.pre),
+    task_post: encodeMiddlewareList(m.task?.post),
+    tool_pre: encodeMiddlewareList(m.tool?.pre),
+    tool_post: encodeMiddlewareList(m.tool?.post)
+  };
+}
+function encodeWorkspaceConfig(def) {
+  if (def.name === void 0 || def.name === null) {
+    throw new Error(
+      'workspace: no name. `workspaceConfig({ name })` is optional because the config inherits the name from `workspace("\u2026")` \u2014 so either start from `workspace("my-app")` or give this config an explicit `name`.'
+    );
+  }
+  assertCanonical(`workspace "${def.name}"`, def.canonical);
+  return {
+    name: def.name,
+    description: def.description ?? "",
+    canonical: def.canonical ?? "",
+    use_xdo: def.use_xdo ?? false,
+    preferences: mergeOverDefaults(DEFAULT_PREFERENCES, def.preferences),
+    realtime: def.realtime ?? { ...LEGACY_REALTIME },
+    documentation: def.documentation ?? { ...DEFAULT_DOCUMENTATION },
+    swagger: def.swagger ?? false,
+    ...def.middleware !== void 0 ? { middleware: encodeWorkspaceMiddleware(def.middleware) } : {},
+    ...def.history !== void 0 ? { history: buildWorkspaceHistory(def.history) } : {},
+    env: def.env ? encodeWorkspaceEnv(def.env) : [],
+    settings: mergeOverDefaults(DEFAULT_SETTINGS, def.settings),
+    // Presence-preserving: each key is written only when the author set it, and
+    // each nested optional likewise, so a pulled workspace re-exports to its own
+    // bytes whether or not the engine happened to store the `?=` default.
+    ...def.use_custom_names !== void 0 ? { use_custom_names: def.use_custom_names } : {},
+    ...def.defaults !== void 0 ? { defaults: { ...def.defaults } } : {},
+    ...def.datasources !== void 0 ? { datasources: def.datasources.map((d) => ({ ...d })) } : {},
+    ...def.datasource_live !== void 0 ? { datasource_live: { ...def.datasource_live } } : {}
+  };
+}
+var workspaceKind = {
+  name: "workspace",
+  payloadKey: "workspace",
+  encode: encodeWorkspaceConfig
+};
+registerKind(workspaceKind);
+function workspaceConfig(def) {
+  return def;
+}
+
+export {
+  setVar,
+  updateVar,
+  encodeSearch,
+  encodeSort,
+  encodeEval,
+  qualifyAggregateEvals,
+  returnValue,
+  die,
+  debugLog,
+  foreachBreak,
+  foreachContinue,
+  foreachRemove,
+  forLoop,
+  foreachLoop,
+  whileLoop,
+  group,
+  switchCase,
+  switchStatement,
+  tryCatch,
+  functionRun,
+  functionCall,
+  apiCall,
+  taskCall,
+  toolCall,
+  triggerCall,
+  middlewareCall,
+  addonCall,
+  actionCall,
+  actionPackageCall,
+  workflowTestCall,
+  aiAgentRun,
+  cloudJob,
+  cloudJobAwait,
+  cloudJobStatus,
+  ignored,
+  encodeFromSpec,
+  registerSpec,
+  GENERATED_SPECS,
+  generated,
+  arrayMap,
+  arrayUnion,
+  comment,
+  getRawInput,
+  postProcess,
+  realtimeEvent,
+  createAuthToken,
+  expectToThrow,
+  ipLookup,
+  outputPaths,
+  dbGet,
+  dbDel,
+  dbHas,
+  dbPatch,
+  dbTruncate,
+  dbAdd,
+  dbEdit,
+  dbAddOrEdit,
+  dbSchema,
+  dbDirectQuery,
+  dbBulkAdd,
+  searchConstrainsRows,
+  dbBulkDelete,
+  dbBulkPatch,
+  dbBulkUpdate,
+  dbQuery,
+  dbTransaction,
+  dbExternalQuery,
+  mathAdd,
+  mathSub,
+  mathMul,
+  mathDiv,
+  bitwiseAnd,
+  bitwiseOr,
+  bitwiseXor,
+  textAppend,
+  textPrepend,
+  objectKeys,
+  objectValues,
+  objectEntries,
+  GENERATED_STATEMENT_NAMES,
+  declaredServicePorts,
+  encodeMicroservice,
+  microservice,
+  microserviceKind,
+  PRECONDITION_ERROR_TYPES,
+  PRECONDITION_ERROR_STATUS,
+  STORAGE_ACCESS,
+  HEADER_DUPLICATES,
+  s,
+  impliedInputs,
+  realtimeServerRefName,
+  resolveRealtimeServerRef,
+  encodeRealtimeChannel,
+  realtimeChannelKind,
+  channelPathParams,
+  realtimeChannel,
+  realtimeChannelGuid,
+  encodeTrigger,
+  tableTrigger,
+  realtimeTrigger,
+  realtimeServerTrigger,
+  realtimeChannelTrigger,
+  mcpServerTrigger,
+  agentTrigger,
+  workspaceTrigger,
+  errorTrigger,
+  triggerKind,
+  DEFAULT_PREFERENCES,
+  DEFAULT_SETTINGS,
+  encodeWorkspaceConfig,
+  workspaceKind,
+  workspaceConfig
+};
+//# sourceMappingURL=chunk-FJ6ZS5KB.js.map