@xanots/sdk 0.0.1

package/dist/internal.js

@@ -0,0 +1,2065 @@
+import {
+  FIELD_METHODS,
+  IMPLEMENTED_STATEMENTS,
+  STATEMENT_SURFACES,
+  SUPERSEDED_STATEMENTS,
+  TOTAL_STATEMENTS,
+  sPathOf
+} from "./chunk-4BXJGVZ3.js";
+import {
+  addonKind,
+  agentKind,
+  apiGroupKind,
+  encodeAddon,
+  encodeAgent,
+  encodeApiGroup,
+  encodeMcpServer,
+  encodeMiddleware,
+  encodeRealtimeMessage,
+  encodeRealtimeServer,
+  encodeSchedule,
+  encodeTask,
+  encodeTool,
+  encodeToolRefs,
+  encodeToolsetBase,
+  encodeWorkflowTest,
+  mcpServerKind,
+  middlewareKind,
+  realtimeMessageGuid,
+  realtimeMessageKind,
+  realtimeServerKind,
+  resolveRealtimeServerCanonical,
+  resolveToolsetCanonical,
+  taskKind,
+  toolKind,
+  workflowTestKind
+} from "./chunk-YDZYMZBE.js";
+import {
+  GENERATED_SPECS,
+  GENERATED_STATEMENT_NAMES,
+  HEADER_DUPLICATES,
+  PRECONDITION_ERROR_STATUS,
+  PRECONDITION_ERROR_TYPES,
+  STORAGE_ACCESS,
+  channelPathParams,
+  declaredServicePorts,
+  encodeFromSpec,
+  encodeMicroservice,
+  encodeRealtimeChannel,
+  encodeTrigger,
+  encodeWorkspaceConfig,
+  generated,
+  microserviceKind,
+  realtimeChannelGuid,
+  realtimeChannelKind,
+  registerSpec,
+  triggerKind,
+  workspaceKind
+} from "./chunk-FJ6ZS5KB.js";
+import {
+  COMMANDS,
+  FLAGS,
+  GLOBAL_FLAGS,
+  flagKey,
+  flagSummary
+} from "./chunk-YYRDLFSJ.js";
+import {
+  DECODE_ONLY_STATEMENTS,
+  FILTER_NAMES,
+  FILTER_SPECS,
+  LAMBDA_BINDINGS,
+  LAMBDA_GLOBALS,
+  LAMBDA_MODULE_GLOBALS,
+  PAYLOAD_ARRAY_KEYS,
+  QUERY_EXPRESSION_FILTERS,
+  TAGS,
+  VECTOR_FILTERS,
+  buildBundle,
+  buildMiddlewareBlock,
+  buildWorkspaceHistory,
+  calcSignatureJson,
+  encodeColumn,
+  encodeContainerHistory,
+  encodeFunction,
+  encodeHistory,
+  encodeIndex,
+  encodeMiddlewareEntry,
+  encodeMiddlewareList,
+  encodeObject,
+  encodeQuery,
+  encodeResponse,
+  encodeTable,
+  encodeView,
+  functionKind,
+  getKind,
+  isQueryExpressionFilter,
+  isRegisteredKind,
+  phpJsonEncode,
+  queryKind,
+  registerKind,
+  registeredKinds,
+  resolveAuthRef,
+  serializeBundle,
+  tableKind,
+  toNestedFields
+} from "./chunk-EMCAWMHC.js";
+import "./chunk-WHOJWOSV.js";
+import {
+  encodeStatement,
+  getStatementFactory,
+  isRegisteredStatement
+} from "./chunk-LH6Z6KFV.js";
+import {
+  LOCK_VERSION,
+  REFERENCEABLE_KINDS,
+  WORKSPACE_KEY,
+  adoptFromBundle,
+  createLockContext,
+  deriveGuid,
+  emptyLock,
+  getLockedCanonical,
+  getLockedGuid,
+  isLockSeeded,
+  lockKey,
+  mergeObserved,
+  mintCanonical,
+  parseLock,
+  recordObserved,
+  renameLockEntry,
+  resolvePayloadKey,
+  resolveRef,
+  serializeLock,
+  validateLockModel
+} from "./chunk-4HT3BNZ7.js";
+
+// src/manifest/manifest.ts
+function argGrammar(args) {
+  if (args === void 0 || args.length === 0) return void 0;
+  return args.map((a) => a.required ? `<${a.name}>` : `[${a.name}]`).join(" ");
+}
+function flagsOf(refs) {
+  if (refs === void 0 || refs.length === 0) return void 0;
+  return refs.map((ref) => ({ flag: FLAGS[flagKey(ref)].spec, description: flagSummary(ref) }));
+}
+function buildCliGlobalFlags() {
+  return GLOBAL_FLAGS.map((key) => ({
+    flag: FLAGS[key].spec,
+    description: FLAGS[key].summary
+  }));
+}
+function buildCli() {
+  const out = [];
+  for (const [name, spec] of Object.entries(COMMANDS)) {
+    if (spec.removed !== void 0) continue;
+    const description = spec.aliasOf === void 0 ? spec.summary : `${spec.summary} (alias of \`${spec.aliasOf}\`)`;
+    const subs = Object.entries(spec.subcommands ?? {});
+    if (subs.length === 0) {
+      out.push({
+        command: name,
+        ...argGrammar(spec.args) !== void 0 ? { args: argGrammar(spec.args) } : {},
+        ...flagsOf(spec.flags) !== void 0 ? { flags: flagsOf(spec.flags) } : {},
+        description
+      });
+      continue;
+    }
+    for (const [subName, sub] of subs) {
+      if (sub.removed !== void 0) continue;
+      const args = argGrammar(sub.args ?? spec.args);
+      const flags = flagsOf(sub.flags ?? spec.flags);
+      out.push({
+        command: `${name} ${subName}`,
+        ...args !== void 0 ? { args } : {},
+        ...flags !== void 0 ? { flags } : {},
+        description: sub.summary
+      });
+    }
+  }
+  return out.sort((a, b) => a.command.localeCompare(b.command));
+}
+var KIND_DESCRIPTORS = [
+  { kind: "function", payloadKey: "function", authorFactory: "defineFunction", description: "Reusable server-side logic (a custom function) callable from any stack via `s.function.run`.", registerMethod: "registerFunctions" },
+  { kind: "table", payloadKey: "dbo", authorFactory: "table", description: "A database table: typed columns (`f.*`), indexes, and views; the schema other kinds read and write.", registerMethod: "registerTables" },
+  { kind: "query", payloadKey: "query", authorFactory: "query", description: "An HTTP API endpoint (verb + path) bound to an API group; the main request/response surface.", registerMethod: "registerQueries" },
+  { kind: "api_group", payloadKey: "app", authorFactory: "apiGroup", description: "A container that groups queries under a shared base path, CORS, and swagger config.", registerMethod: "registerApiGroups" },
+  {
+    kind: "trigger",
+    payloadKey: "trigger",
+    authorFactory: "{tableTrigger,realtimeServerTrigger,realtimeChannelTrigger,mcpServerTrigger,agentTrigger,workspaceTrigger,errorTrigger}",
+    description: "An event-driven handler fired by a DB write, a realtime server connection or channel join/leave/deliver, an MCP/agent connection, a branch lifecycle event, or an error \u2014 inputs are implied by type and arrive on the `t` handle.",
+    registerMethod: "registerTriggers",
+    subKinds: [
+      { authorFactory: "tableTrigger", objType: "database", description: 'Fires when rows change on a bound table (insert/update/delete/truncate). The changed row is exposed as `t.new`/`t.old`, typed to the table when a `table()` handle is bound. Config-only (no response). `search` filters rows in the DATABASE, so it uses `col("NEW.x")`/`col("OLD.x")`, not `t`; invalid with `truncate`, and insert/delete cannot read the absent side.' },
+      { authorFactory: "realtimeTrigger", objType: "workspace_realtime_channel", legacy: true, description: "the SUPERSEDED realtime trigger, against the workspace-global realtime layer \u2014 a different object from the current `channel`, despite the similar name. For a join hook use `realtimeChannelTrigger({ actions: { join: true } })`; for message handling use a `realtimeMessage()` handler, which is the current equivalent of its `message` action (a message is an authored unit now, not a trigger action)." },
+      { authorFactory: "realtimeServerTrigger", objType: "realtime_server", description: "Fires when a client connects to or disconnects from a realtime server; inspect the connecting client and its permissions via `t`. Bind with `realtimeServer`. Response-bearing." },
+      { authorFactory: "realtimeChannelTrigger", objType: "channel", description: "Fires when a client joins or leaves a channel; inspect the addressed channel path and the client via `t`. Bind with a `realtimeChannel()` handle (a bare path is ambiguous across servers). Response-bearing." },
+      { authorFactory: "mcpServerTrigger", objType: "toolset", description: "Fires when an MCP client connects to a bound MCP server; gate or annotate the exposed tools via `t.toolset`/`t.tools`. Response-bearing." },
+      { authorFactory: "agentTrigger", objType: "toolset", description: "Fires when a client connects to a bound agent; gate or annotate its toolset via `t.toolset`/`t.tools`. Response-bearing." },
+      { authorFactory: "workspaceTrigger", objType: "workspace", description: "Fires on branch lifecycle events (branch new/merge/live); inspect the from/to branch and action via `t`. Config-only." },
+      { authorFactory: "errorTrigger", objType: "error", description: "Fires when an error signature is first seen, regresses, or is marked fixed; inspect the error, caller, statement, and occurrence counts via `t`. Config-only." }
+    ]
+  },
+  { kind: "tool", payloadKey: "tool", authorFactory: "tool", description: "An agent/MCP tool: a callable capability with typed inputs an AI agent can invoke.", registerMethod: "registerTools" },
+  { kind: "mcp_server", payloadKey: "toolset", authorFactory: "mcpServer", description: "An MCP server exposing a set of tools to external MCP clients.", registerMethod: "registerMcpServers" },
+  { kind: "agent", payloadKey: "toolset", authorFactory: "agent", description: "An AI agent: an LLM configuration plus the tools it can call. Invoke it from any stack (query/function/task/tool/trigger) with `s.ai.agent.run` \u2014 no public endpoint; the result is a rich envelope whose completion text is at `.result`.", registerMethod: "registerAgents" },
+  { kind: "task", payloadKey: "task", authorFactory: "task", description: "A scheduled background job (cron/interval) that runs a stack on a timer.", registerMethod: "registerTasks" },
+  { kind: "workflow_test", payloadKey: "workflow_test", authorFactory: "workflowTest", description: 'An end-to-end test: a named stack with NO input and NO response that invokes other objects (`s.function.call`, `s.task.call`, `s.api.call`) and asserts on what they bind with `s.expect.*`. `datasource` defaults to `""` (an EMPTY datasource, recommended); naming one makes the engine CLONE that datasource before every run, so pointing a test at production-sized data can be slow enough to fail the run \u2014 `"live"` warns at compile time.', registerMethod: "registerWorkflowTests" },
+  { kind: "middleware", payloadKey: "middleware", authorFactory: "middleware", description: "A reusable pre/post stack attached to a query/function/task/tool/API group to run before or after its own logic.", registerMethod: "registerMiddleware" },
+  { kind: "addon", payloadKey: "addon", authorFactory: "addon", description: "A reusable read fragment that enriches a query result by joining related table data.", registerMethod: "registerAddons" },
+  { kind: "realtime_server", payloadKey: "realtime_server", authorFactory: "realtimeServer", description: "A realtime (websocket) server: the canonical-addressed container that owns realtime channels. Off until `enabled: true`. Returns a handle with `getUrl(baseUrl)`/`getPath()` for the client's socket URL (`wss://<host>/ws/<canonical>`).", registerMethod: "registerRealtimeServers" },
+  { kind: "channel", payloadKey: "channel", authorFactory: "realtimeChannel", description: "A realtime channel: a joinable path on a realtime server (`rooms/{room_id}`) with typed path params, join/publish policy, a client-visible conversation transcript, and delivery semantics. Owns message handlers. Returns a handle with `getChannel(params)` for the path a client joins.", registerMethod: "registerRealtimeChannels" },
+  { kind: "message", payloadKey: "message", authorFactory: "realtimeMessage", description: "A realtime message handler: a named message type on a channel with its own typed payload and stack \u2014 the realtime analogue of a query. Pass the `realtimeChannel()` handle as `channel` and the owning server comes with it.", registerMethod: "registerRealtimeMessages" },
+  { kind: "microservice", payloadKey: "microservice", authorFactory: "microservice", description: "A container workload deployed alongside the workspace, called from a stack with `s.microservice.request`. Two mutually exclusive shapes via `kind`: `builtin` declares containers (image/ports/resources/env/command/args) plus optional `ingresses`, and `helm` points at a chart and its `values` \u2014 passing both throws. EARLY SURFACE, expected to change \u2014 every export of a workspace declaring one prints a notice saying so. `configs`/`volumes` are typed and `@deprecated` but NOT deployable: the engine rejects an import carrying either, so `export()` fails the build rather than letting the deploy fatal. Put a value the workload reads in a container's `env`, and storage in a container's own `volumes` (`emptyDir`/`persistent`/`config`). Container names are free-form \u2014 they need not match the microservice name, which is what a stack addresses. SECRETS RIDE ALONG \u2014 `chart.values` and `registryAuth.dockerconfigjson` are carried into the bundle, and into a pulled tree, verbatim (they must be, or a pulled microservice could not be redeployed). Both are stored strings with NO deploy-time indirection: `process.env.X` in the def resolves at EXPORT and writes the literal into the bundle, so it is not a way to keep the credential out. Either leave `registryAuth` unset (public image, or a credential attached outside this workspace) or treat the bundle and any pulled tree as secret material \u2014 keep them out of git, or rotate after. Export prints a notice per microservice carrying either field; `--strict` does not promote it. For a secret a STACK reads, the mapped surface is `workspaceConfig({ env })` + `env(\"NAME\")`.", registerMethod: "registerMicroservices" },
+  { kind: "workspace", payloadKey: "workspace", authorFactory: "workspaceConfig", description: "Workspace-level configuration such as default middleware chains and request-history defaults per host kind.", registerMethod: "registerWorkspace" }
+];
+var ENGINE_OBJECT_KINDS = [
+  { kind: "addon", authorFactory: "addon" },
+  { kind: "agent", authorFactory: "agent" },
+  { kind: "agent_trigger", authorFactory: "agentTrigger" },
+  { kind: "api_group", authorFactory: "apiGroup" },
+  { kind: "branch", authorFactory: null, absence: "instance-owned: a branch is instance state, not workspace source" },
+  { kind: "channel", authorFactory: "realtimeChannel" },
+  { kind: "channel_trigger", authorFactory: "realtimeChannelTrigger" },
+  { kind: "error_trigger", authorFactory: "errorTrigger" },
+  { kind: "function", authorFactory: "defineFunction" },
+  { kind: "market_item", authorFactory: null, absence: "instance-owned: marketplace provenance belongs to the instance that installed it" },
+  { kind: "mcp_server", authorFactory: "mcpServer" },
+  { kind: "mcp_server_trigger", authorFactory: "mcpServerTrigger" },
+  { kind: "message", authorFactory: "realtimeMessage" },
+  { kind: "microservice", authorFactory: "microservice" },
+  { kind: "middleware", authorFactory: "middleware" },
+  { kind: "query", authorFactory: "query" },
+  {
+    kind: "realtime_channel",
+    authorFactory: null,
+    absence: "unmodeled: the SUPERSEDED workspace-global realtime channel. Its trigger is authorable (`realtimeTrigger`) so a legacy workspace's handlers survive a pull, but the channel object itself is not \u2014 author a `realtimeServer` + `realtimeChannel` instead"
+  },
+  { kind: "realtime_server", authorFactory: "realtimeServer" },
+  { kind: "realtime_server_trigger", authorFactory: "realtimeServerTrigger" },
+  { kind: "realtime_trigger", authorFactory: "realtimeTrigger" },
+  { kind: "run.job", authorFactory: null, absence: "unmodeled: a container job \u2014 declares a main entrypoint plus pre/post steps and its env" },
+  { kind: "run.service", authorFactory: null, absence: "unmodeled: a long-running container service \u2014 declares a pre step and its env" },
+  { kind: "table", authorFactory: "table" },
+  { kind: "table_trigger", authorFactory: "tableTrigger" },
+  {
+    kind: "tablemap",
+    authorFactory: null,
+    absence: "unmodeled: a column mapping over a table, used to shape an external schema onto it"
+  },
+  { kind: "task", authorFactory: "task" },
+  { kind: "tool", authorFactory: "tool" },
+  { kind: "workflow_test", authorFactory: "workflowTest" },
+  { kind: "workspace", authorFactory: "workspaceConfig" },
+  { kind: "workspace_trigger", authorFactory: "workspaceTrigger" }
+];
+var TOTAL_OBJECT_KINDS = ENGINE_OBJECT_KINDS.length;
+var NAMESPACE_NOTES = {
+  debug: "Despite the namespace, `s.debug.stop` is a REAL control-flow terminator, not a development aid: it ends the request with an error value (`mvp:die`). It is also exported flat as `die()` \u2014 the one flat alias whose name does not mirror its `s.*` path, so there is no `s.die`. Compare `s.throw`, which raises a named error the surrounding `s.try_catch` can catch.",
+  expect: "Assertions. **Put them in a `workflowTest({...})` stack** \u2014 assert on what a `.call` bound with `as`. That is where they belong and effectively the only place to author them. They are NOT inert elsewhere, which is the part worth knowing: a failure raises and aborts whatever stack it is in, so an `s.expect.*` left in a `query`/`function`/`task` takes the request down with an HTTP 500 carrying the assertion's own message (`to_equal failed - expected value 2 does not equal 1`). Treat one outside a `workflowTest` as a mistake to remove, not as a check that quietly does nothing. Two behaviours to know when writing them: `to_throw` sees only an error carrying a MESSAGE, so a failure whose message is empty \u2014 an endpoint answering `ERROR_CODE_ACCESS_DENIED` is the common one \u2014 reports \"response is ok\" as though nothing failed, and `to_be_within` EXCLUDES both bounds \u2014 `min < expr < max` \u2014 while `s.security.random_number`'s bounds are inclusive.",
+  workflow_test: "Run another workflow test from inside one. Pass the `workflowTest()` def handle, not a name."
+};
+var PUBLISHED_AUTHOR_FACTORIES = new Set(
+  KIND_DESCRIPTORS.filter((d) => !d.unpublished).flatMap(
+    (d) => d.subKinds ? d.subKinds.filter((sub) => !sub.unpublished).map((sub) => sub.authorFactory) : [d.authorFactory]
+  )
+);
+var IMPLEMENTED_OBJECT_KINDS = ENGINE_OBJECT_KINDS.filter(
+  (k) => k.authorFactory !== null && PUBLISHED_AUTHOR_FACTORIES.has(k.authorFactory)
+);
+function unmodeledObjectKinds() {
+  const implemented = new Set(IMPLEMENTED_OBJECT_KINDS.map((k) => k.kind));
+  return ENGINE_OBJECT_KINDS.filter((k) => !implemented.has(k.kind)).map((k) => ({
+    kind: k.kind,
+    absence: k.absence ?? "built but withheld from the published surface"
+  }));
+}
+var VALUE_CONSTRUCTORS = [
+  { name: "c.text", signature: "(s: string) => Value", description: 'String constant \u2192 tag "const".' },
+  { name: "c.int", signature: "(n: number | bigint | string) => Value", description: 'Integer constant \u2192 tag "const:int". The engine stores integers as STRINGS and has no 53-bit limit, so pass a string or bigint for anything past Number.MAX_SAFE_INTEGER \u2014 c.int("18446744073709551615") is exact where the number literal for it is already \u2026616. A number that is not a safe integer THROWS rather than encoding the rounded value.' },
+  { name: "c.decimal", signature: "(n: number | string) => Value", description: 'Decimal constant \u2192 tag "const:decimal". Pass a string only to keep a stored spelling a number cannot reproduce (c.decimal("10.00") keeps its trailing zeros).' },
+  { name: "c.blank", signature: '(tag: "const:<type>") => Value', description: `The editor's UNCONFIGURED value box (stored value ""), emitted by codegen for a pulled workspace \u2014 do not author it. NOT a zero or an empty collection: the engine reads "" and "0" differently, so c.blank("const:int") \u2260 c.int(0) and neither canonicalizes into the other. Constant tags except const/const:obj, whose blanks are c.text("")/c.obj(null).` },
+  { name: "c.bool", signature: "(b: boolean) => Value", description: 'Boolean constant \u2192 tag "const:bool".' },
+  { name: "c.null", signature: '(tag?: "const:null" | "const:obj") => Value', description: `Null constant, stored value "null". Bare c.null() is tag "const:null". c.null("const:obj") is the OBJECT-TYPED null the engine writes into a db.* statement's @meta slot \u2014 different stored bytes from c.obj(null), which is the blank object (value ""), though both evaluate to null. Codegen emits whichever spelling the workspace stored; do not swap one for the other.` },
+  { name: "c.obj", signature: "(o?: Json | null) => Value", description: 'Object constant \u2192 tag "const:obj". A populated one stores an empty {} carrying one `set` filter per key \u2014 the editor\'s form, and the only populated form the engine reads back (a populated JSON string arrives truncated and fails the request with ERROR_FATAL "Unable to decode."). \u26A0 a ZERO-BASED numeric key is an INDEX in the engine\'s data model, so c.obj({"0":"a"}) evaluates to the list ["a"] (a non-zero-based one like {"2":\u2026} survives as a key) \u2014 that is the platform, not this encoding. No argument = the empty object {} \u2014 use this one. Explicit null = the legacy blank form the engine evaluates to null, NOT {}; it exists only so a pulled workspace round-trips, do not author it. Plain JSON literals only \u2014 a nested tagged value (inp/ref/auth/c.*) is rejected; for a computed object response use a record of values, not c.obj.' },
+  { name: "c.array", signature: "(a: Json[]) => Value", description: 'Array constant (JSON string) \u2192 tag "const:array". Plain JSON literals only \u2014 a nested tagged value is rejected, same as c.obj.' },
+  { name: "c.expression", signature: "(source: string) => Value", description: `Xano Expression Engine source, passed through VERBATIM \u2192 tag "const:expr2". The string IS the expression: c.expression('"Hi, " ~ $input.name'), c.expression("$var.price * $var.qty"). \u26A0\uFE0F NOT VALIDATED \u2014 never parsed or type-checked, invisible to InferResponse, and untouched by a rename that updates every typed ref(); a typo surfaces at runtime or as a wrong answer. Use it ONLY for syntax the typed surfaces cannot express (~ concatenation, inline arithmetic, conditionals) \u2014 prefer ref/inp/col, withFilters+fl.*, and obj() (which BUILDS a checked expression). Not the expr() condition builder.` },
+  { name: "c.expressionLegacy", signature: "(source: string) => Value", legacy: true, description: "the older `const:expr` expression form, emitted by codegen for workspaces that still hold one \u2014 author `c.expression` instead." },
+  { name: "c.now", signature: "() => Value", description: "Current time as epoch-ms \u2014 the engine-native const:epochms constant (no filter). Valid inline as a where/cmp operand. For cutoff math (cutoff = now - max_age) either compare inline or, for reuse/readability, hoist it into an s.set_var and compare against the var." },
+  { name: "obj", signature: "(fields: Record<string, Value | nested>) => ObjValue<typeof fields>", description: 'Dynamic object value \u2192 tag "const:expr2" (an object-literal expression string). The dynamic sibling of c.obj: members may be inp/ref/auth/col values, env()/setting()/sys.*, c.now(), c.* constants, nested records, or arrays \u2014 and each member may carry a FILTER CHAIN (withFilters + fl.*), which renders as the expression pipe `$var.row|get:"a.b"`. That matters most for the null-safe drill: db.get binds null on a miss, so ref(path, { safe: true }) inside an obj() is the normal shape, not a workaround \u2014 you do NOT need a preceding s.set_var to hoist it. The member record rides the return type, so InferResponse resolves each member the way it resolves a top-level response key \u2014 `response: { user: obj({ id: ref("row.id") }) }` derives `{ user: { id: Col | null } }`, and a raw nested object literal (`response: { user: { id: ref("row.id") } }`, auto-wrapped through this) derives the same. NEST WITH A RAW RECORD, not an inner obj() call: an inner call yields a const:expr2 value, which the expression serializer has no spelling for and THROWS. Still rejected: a filter ARGUMENT carrying its own chain (a trailing | binds to the whole value, not one argument), a DISABLED filter (an expression string cannot record that), and the output/response/toolset/reg tags \u2014 build those in a prior step and ref() them. Use for e.g. s.ai.agent.run args.' },
+  { name: "ref", signature: "(name: string, opts?: { safe?: boolean }) => Value", description: 'Reference a stack variable \u2192 tag "var". Pass { safe: true } for null-safe nested access \u2014 a dotted ref("owner.user_id", { safe: true }) compiles through the get filter so it resolves to null instead of raising "Unable to locate var" when the base is null.' },
+  {
+    name: "inp",
+    signature: "(name: string) => Value",
+    description: 'Reference a function/endpoint input \u2192 tag "input". Resolves ONLY against the `input` block of the def it sits in \u2014 a value produced earlier in the stack is `ref("var.field")`, not `inp("field")`. A name that is not declared here deploys clean and fails at runtime with ERROR_FATAL "Unable to locate input: <name>" on every branch that reads it; `export()` warns, and `--strict` fails the build. Sending the name in the request does NOT rescue it \u2014 an undeclared input is never bound, so the call fails identically with the value present. A dotted path drills INTO a declared input (`inp("action.amount")` needs a declared `action`).'
+  },
+  { name: "col", signature: "(name: string) => Value", description: 'Reference a table column \u2192 tag "col".' },
+  { name: "auth", signature: "(path?: string) => Value", description: 'Reference the authenticated identity (auth("id") \u2192 $auth.id) \u2192 tag "auth".' },
+  { name: "caught", signature: '(path?: "code" | "message" | "name" | "result") => Value', description: 'Read the caught error inside an s.try_catch CATCH arm \u2192 tag "trycatch". Valid ONLY there \u2014 it reads empty in the try/finally arms and outside the statement. Those four fields are all the engine binds (result is the attached payload); bare caught() is the whole error record. \u26A0 For an ENGINE-raised exception only `code` and `name` are populated; for an `s.throw`, `message` is the fixed string "Throw Error Statement" and your text is in `result`. So `caught("name")` is useful in both cases and `caught("message")` in NEITHER.' },
+  { name: "toolset", signature: '(path: "token" | "params" | `params.${string}`) => Value', description: `Read a toolset-scoped binding inside a tool \u2192 tag "toolset". The engine binds two: token (the calling URL's token, null when absent) and params (its parameters, as an object); a dotted params.<key> reads one parameter out of that object. Bound only while a tool runs under its toolset \u2014 anywhere else it reads empty.` },
+  { name: "env", signature: "(name: string) => Value", description: 'Read a WORKSPACE environment variable (set via workspaceConfig({ env }) or the dashboard) \u2192 `$env.NAME`. Compiles to tag "setting" with the plain name. env("remote_ip") reads a user var named remote_ip, not the caller IP \u2014 use sys.remoteIp() for that.' },
+  { name: "setting", signature: "(name: string) => Value", description: 'Reference a workspace setting \u2192 tag "setting". Built-in system vars are $-prefixed settings, e.g. setting("$remote_ip"); prefer the typed sys.* accessors.' },
+  { name: "sys.*", signature: "() => Value", description: 'Built-in system / request-context variables \u2192 tag "setting" ($-prefixed). Accessors: remoteIp, requestMethod, requestUri, requestQueryString, httpHeaders, requestAuthToken, apiBaseUrl, datasource, branch, tenant, release, platform, isDebugger. In XanoScript these are $env.$remote_ip etc.; sys.remoteIp() is the public-endpoint rate-limit key (auth("id") is null there).' },
+  { name: "filter", signature: "(name: string, ...args: Value[]) => FilterXdo", description: "Build a filter-chain entry by raw name (escape hatch)." },
+  { name: "fl.*", signature: "(...args: Value[]) => FilterXdo", description: "Typed value-pipeline filters; see the `filters` catalog." },
+  { name: "withFilters", signature: "(value: Value, ...filters: FilterXdo[]) => Value", description: "Attach a filter chain to a value (filters passed spread; an array is also accepted)." }
+];
+var FIELD_DESCRIPTORS = [
+  { name: "text", stored: "text" },
+  { name: "int", stored: "int" },
+  { name: "decimal", stored: "decimal" },
+  { name: "bool", stored: "bool" },
+  { name: "uuid", stored: "uuid" },
+  { name: "date", stored: "date" },
+  { name: "email", stored: "email" },
+  { name: "password", stored: "password" },
+  { name: "json", stored: "json" },
+  { name: "timestamp", stored: "epochms" },
+  { name: "image", stored: "blob_img" },
+  { name: "video", stored: "blob_video" },
+  { name: "audio", stored: "blob_audio" },
+  { name: "attachment", stored: "blob" },
+  // Input-only: a raw upload is the request's bytes, not something a table holds.
+  { name: "file", stored: "file", inputOnly: true },
+  // Input-only: a column linking a whole table is a foreign key (tableRef).
+  { name: "dbLink", stored: "<tableGuid>_mvpschema", inputOnly: true },
+  { name: "geo.point", stored: "geo_point" },
+  { name: "geo.multipoint", stored: "geo_multipoint" },
+  { name: "geo.linestring", stored: "geo_linestring" },
+  { name: "geo.multilinestring", stored: "geo_multilinestring" },
+  { name: "geo.polygon", stored: "geo_polygon" },
+  { name: "geo.multipolygon", stored: "geo_multipolygon" },
+  { name: "enum", stored: "enum" },
+  { name: "vector", stored: "vector" },
+  { name: "object", stored: "obj" },
+  { name: "tableRef", stored: "int", methodKey: "tableRef" }
+];
+function buildFieldTypes() {
+  return FIELD_DESCRIPTORS.map(({ name, stored, methodKey, inputOnly }) => ({
+    name,
+    stored,
+    methods: Object.keys(FIELD_METHODS[methodKey ?? name] ?? {}),
+    ...inputOnly ? { inputOnly: true } : {}
+  }));
+}
+function buildFilters() {
+  return FILTER_NAMES.map((name) => {
+    const spec = FILTER_SPECS[name];
+    const entry = { name, fl: `fl.${name}`, typed: !!spec };
+    if (spec?.args?.length) entry.args = spec.args;
+    if (spec?.variadic) entry.variadic = true;
+    if (spec?.result) entry.result = spec.result;
+    if (spec?.group) entry.group = spec.group;
+    if (spec?.description) entry.description = spec.description;
+    return entry;
+  });
+}
+var SPECS_BY_NAME = new Map(GENERATED_SPECS.map((s) => [s.name, s]));
+var LEGACY_SURFACES = {
+  "api.realtime_event": "publishes to the SUPERSEDED workspace-global realtime layer, NOT to a `realtimeChannel()` \u2014 its `channel` is a string against that layer, so pointing it at a current-layer channel path publishes into the void. Use `s.realtime.publish` instead: it names the owning `realtimeServer()`, so it addresses a real `realtimeChannel()`."
+};
+var OVERRIDDEN_SURFACES = /* @__PURE__ */ new Set([
+  "mvp:api_request",
+  "mvp:streaming_api_request",
+  "mvp:connect_webflow_api_request",
+  "mvp:microservice_request"
+]);
+var STATEMENT_RESULTS = {
+  // db.* — mirrors the curated "Runtime behavior" block and InferResponse (#105/#145).
+  "db.get": { name: "as", type: "InferRow<T> | null", note: "binds null on a miss, never throws" },
+  "db.add": { name: "as", type: "InferRow<T>", note: "the full inserted row incl. id/created_at" },
+  "db.edit": { name: "as", type: "InferRow<T>", note: "the full post-mutation row; throws NotFound on a miss" },
+  "db.patch": { name: "as", type: "InferRow<T>", note: "the full post-mutation row; throws NotFound on a miss" },
+  "db.add_or_edit": { name: "as", type: "InferRow<T>", note: "upserts and never misses" },
+  "db.del": { name: "as", type: "null", note: "the engine deletes and returns no value; throws NotFound on a miss" },
+  "db.has": { name: "as", type: "boolean" },
+  "db.query": { name: "as", type: "InferRow<T>[]", note: "a paging envelope when metadata paging is on" },
+  "db.bulk.patch": { name: "as", type: "InferRow<T>[]" },
+  "db.bulk.delete": { name: "as", type: "number", note: "count of deleted rows" },
+  // security.check_password binds a boolean (does the plaintext match the stored hash), #109/#145.
+  "security.check_password": {
+    name: "as",
+    type: "boolean",
+    note: "true when the plaintext matches the stored hash. \u26A0 input.password double-hashes \u2014 pass input.text() plaintext"
+  },
+  // util.* — two whose UNITS and SHAPE cost teams time, and neither is guessable
+  // from the signature.
+  "util.geo_distance": {
+    name: "as",
+    type: "number",
+    note: "great-circle distance in METRES (a decimal) \u2014 divide by 1000 for km. Identical points return 0"
+  },
+  "util.ip_lookup": {
+    name: "as",
+    type: "IpLookupResult | null",
+    note: 'NESTED, not flat: { continent: {code,name}, country: {code,name}, region: {code,name}, city: {name}, postal: {code}, location: {latitude, longitude, tz, radius} }. Coordinates are ref("geo.location.latitude"/".longitude"), place names ref("geo.city.name"/"geo.region.name"/"geo.country.name"); radius is KILOMETRES. \u26A0 Every leaf is nullable and region/city/postal commonly ARE null for a routable public address \u2014 that is a normal hit, not a failed lookup. `city` is an OBJECT, so a bare ref("geo.city") into a text column fails on the object and { safe: true } does NOT help; drill to city.name with a fallback. The whole var is null for an unresolvable address'
+  },
+  // Clearly-typed declarative ops.
+  "array.every": { name: "as", type: "boolean" },
+  "math.add": { name: "as", type: "number" },
+  "math.bitwise.and": { name: "as", type: "number" },
+  "math.bitwise.or": { name: "as", type: "number" },
+  "math.bitwise.xor": { name: "as", type: "number" },
+  "object.keys": { name: "as", type: "string[]" },
+  "object.values": { name: "as", type: "unknown[]" },
+  "object.entries": { name: "as", type: "[string, unknown][]" }
+};
+var CONTEXT_FIELD_ENUMS = {
+  "mvp:precondition:error_type": PRECONDITION_ERROR_TYPES,
+  // `access` defaults to `public`, so a misspelling fails OPEN — the file is
+  // served to the world. The members were unlisted anywhere, leaving `private`
+  // inferable only from `s.storage.sign_private_url`'s existence (#65).
+  "mvp:create_attachment:access": STORAGE_ACCESS,
+  "mvp:create_audio:access": STORAGE_ACCESS,
+  "mvp:create_image:access": STORAGE_ACCESS,
+  "mvp:create_video:access": STORAGE_ACCESS,
+  "mvp:setheader:duplicates": HEADER_DUPLICATES
+};
+function fieldsOf(spec) {
+  return spec.rules.map((r) => {
+    const f = {
+      name: r.field,
+      type: r.type,
+      optional: r.optional || r.default !== void 0
+    };
+    if (r.default !== void 0) f.default = r.default;
+    const curated = CONTEXT_FIELD_ENUMS[`${spec.name}:${r.field}`];
+    if (r.enum !== void 0) f.enum = r.enum;
+    else if (curated) f.enum = [...curated];
+    return f;
+  });
+}
+function buildManifest(opts = {}) {
+  const objectKinds = KIND_DESCRIPTORS.filter((d) => !d.unpublished).map((d) => ({
+    ...d,
+    registered: isRegisteredKind(d.kind),
+    // A published kind can still have unpublished sub-kinds (the two realtime
+    // lifecycle trigger types under `trigger`), so filter that level too.
+    ...d.subKinds ? { subKinds: d.subKinds.filter((sub) => !sub.unpublished) } : {}
+  }));
+  const statements = STATEMENT_SURFACES.map(([surface, storedName]) => {
+    const spec = SPECS_BY_NAME.get(storedName);
+    const overridden = OVERRIDDEN_SURFACES.has(storedName);
+    const entry = {
+      surface,
+      storedName,
+      sPath: sPathOf(surface),
+      registered: isRegisteredStatement(storedName),
+      declarative: spec !== void 0 && !overridden
+    };
+    if (spec) {
+      entry.output = spec.output ?? false;
+      if (!overridden) entry.fields = fieldsOf(spec);
+    }
+    if (Object.hasOwn(STATEMENT_RESULTS, surface)) entry.result = STATEMENT_RESULTS[surface];
+    if (Object.hasOwn(LEGACY_SURFACES, surface)) entry.legacy = true;
+    return entry;
+  });
+  const filters = buildFilters();
+  return {
+    name: "xanots",
+    version: opts.version ?? "0.0.0",
+    description: "TypeScript SDK that compiles a typed Xano workspace into the importable packageExport JSON bundle.",
+    coverage: {
+      // Counted over the ENGINE's catalog, not over this SDK's kinds: the engine
+      // has one object kind per trigger type where the SDK has one `trigger`
+      // kind with sub-kinds, so counting SDK kinds reported 16/30 for a surface
+      // that actually authors 23 of them.
+      objectKinds: {
+        implemented: IMPLEMENTED_OBJECT_KINDS.length,
+        total: TOTAL_OBJECT_KINDS,
+        unmodeled: unmodeledObjectKinds()
+      },
+      statements: {
+        implemented: statements.filter((s) => s.registered).length,
+        total: TOTAL_STATEMENTS
+      },
+      filters: { typed: filters.filter((f) => f.typed).length, total: filters.length }
+    },
+    values: { constructors: [...VALUE_CONSTRUCTORS], tags: TAGS },
+    objectKinds,
+    fieldTypes: buildFieldTypes(),
+    statements,
+    filters,
+    cli: buildCli(),
+    cliGlobalFlags: buildCliGlobalFlags()
+  };
+}
+var DEFAULT_KEEP = /* @__PURE__ */ new Set([
+  "storage.create_image:access",
+  "storage.create_attachment:access",
+  "storage.create_audio:access",
+  "storage.create_video:access"
+]);
+function preconditionStatusLine() {
+  const byStatus = /* @__PURE__ */ new Map();
+  for (const type of PRECONDITION_ERROR_TYPES) {
+    const status = PRECONDITION_ERROR_STATUS[type];
+    byStatus.set(status, [...byStatus.get(status) ?? [], type]);
+  }
+  return [...byStatus].sort(([a], [b]) => a - b).map(([status, types]) => `${types.map((t) => `\`${t}\``).join("/")} \u2192 ${status}`).join(", ");
+}
+var fieldLine = (f, sPath) => {
+  const keepDefault = f.default !== void 0 && DEFAULT_KEEP.has(`${sPath}:${f.name}`);
+  const type = f.enum ? f.enum.map((v) => JSON.stringify(v)).join(" | ") : f.type;
+  return `${f.name}${f.optional ? "?" : ""}: ${type}${keepDefault ? ` = ${JSON.stringify(f.default)}` : ""}`;
+};
+var FILTER_NOTES = {
+  // "Direction" family — which operand is the subject is genuinely confusing.
+  contains: "piped value is the subject text; the arg is the substring searched for",
+  ends_with: "piped value is the subject text; the arg is the substring searched for",
+  starts_with: "piped value is the subject text; the arg is the substring searched for",
+  icontains: "case-insensitive; piped value is the subject, the arg is the substring",
+  iends_with: "case-insensitive; piped value is the subject, the arg is the substring",
+  istarts_with: "case-insensitive; piped value is the subject, the arg is the substring",
+  // "empty" is a specific set of values, not just null.
+  filter_empty: 'keeps entries that are not empty ("", null, 0, "0", false, [], {})',
+  first_notempty: 'first value that is not empty ("", null, 0, "0", false, [], {})',
+  // The `code` arg is a JS FUNCTION BODY (it must `return`), not a column path,
+  // and which identifiers it can see depends on the filter — see **Lambda bodies**.
+  // Build it with `lam.fn`, which makes the bindings the function's parameters.
+  map: "`code` is a JS body run per element, over `$this`/`$index`/`$parent` \u2014 build it with `lam.fn`",
+  filter: "`code` is a JS body run per element (keep it? true/false), over `$this`/`$index`/`$parent`",
+  every: "`code` is a JS body run per element (true for all?), over `$this`/`$index`/`$parent`",
+  some: "`code` is a JS body run per element (true for any?), over `$this`/`$index`/`$parent`",
+  find: "`code` is a JS body run per element; returns the first element it accepts",
+  findIndex: "`code` is a JS body run per element; returns the first matching index",
+  reduce: "`code` is a JS body run per element; the ACCUMULATOR is `$result` (there is no `$acc`) and `initial_value` is REQUIRED \u2014 omitting it would slot the code as the initial value",
+  lambda: "runs a JS body once over the piped value, which it binds as `$this` (NOT `$parent`)",
+  // The one filter next to `lambda` that is NOT a lambda. It reads as one, its
+  // upstream description names a `$this` that does not exist on its path, and
+  // both wrong spellings can return a plausible value with HTTP 200 — so the
+  // note has to say what the binding IS, not only what it isn't.
+  transform: '`expression` is Xano Expression Engine source, NOT a JS body \u2014 no `return`, and the piped value is `$0` (or `$$`), NOT `$this` (which is null here). `$var`/`$input`/`$env`/`$auth` resolve and filters pipe inside it: `$0 * 2`, `$0|sort|join:","`. Parenthesize a pipe inside an object literal \u2014 `{ s: ($0|sort|join:",") }` \u2014 or its comma is read as the key separator and later keys vanish silently. For JavaScript use `lambda`',
+  // The sort mode is the whole behavior of this filter, and picking it wrong is
+  // SILENT — every unrecognized spelling falls through to `itext`, so the array
+  // comes back sorted as case-insensitive text with no error anywhere. That is
+  // how "top N by score/distance/recency" comes out wrong (#198).
+  fsort: '`type` is the comparator, and ONLY "number" compares numerically \u2014 "text"/"itext" are strcmp/strcasecmp, "natural"/"inatural" are the human-readable "a2 < a10" orderings. Default "itext". Anything else silently sorts as text, so a numeric sort MUST spell "number"; the path arg drills into each element',
+  // The CSV pair reads as interchangeable and is not: only `csv_create` writes a
+  // header, and `csv_encode`'s per-row column order misaligns heterogeneous rows
+  // with no error at all (#246).
+  csv_encode: "writes NO header \u2014 values only, each row in THAT row's key order with no normalization across rows, so rows whose keys differ in order or count silently misalign columns. Nested cells are JSON-encoded and `false` writes empty. A piped array of SCALARS is treated as one row. Use `csv_create` for a header",
+  csv_create: "the header-writing counterpart to `csv_encode`: the PIPED value is the list of column names (written as the header line) and `rows` carries the data rows",
+  // A group-by whose name reads as a lookup table. The singular spelling
+  // `idx[key].name` is null at runtime rather than an error (#267).
+  index_by: "a GROUP-BY: every value is an ARRAY of the items sharing that key, even when only one does, so a lookup reads `idx[key][0]`. Items whose path is missing or non-scalar are dropped",
+  // Non-obvious names.
+  epochms_transform: 'applies a relative shift (e.g. "+1 day") to the timestamp',
+  unpick: "returns the object without the named keys (inverse of a pick)"
+};
+function wrapList(items, indent, width = 84) {
+  const lines = [];
+  let line = "";
+  for (const item of items) {
+    const next = line === "" ? indent + item : `${line} \xB7 ${item}`;
+    if (next.length > width && line !== "") {
+      lines.push(line + " \xB7");
+      line = indent + item;
+    } else {
+      line = next;
+    }
+  }
+  if (line !== "") lines.push(line);
+  return lines;
+}
+function renderLambdaSection() {
+  const lines = ["## Lambda bodies (JavaScript)", ""];
+  lines.push(
+    "**A lambda is an escape hatch, not a default.** The body runs outside the request's own",
+    "runtime, and a workspace has a BOUNDED pool of lambda workers every lambda in it shares",
+    "\u2014 so a call both crosses a process boundary and draws on a workspace-wide resource.",
+    "Reach for one only when the typed surface cannot express the work: if a native filter,",
+    "an `expr(...)`/`obj(...)` expression, or a plain statement can, use that. The crossing",
+    "is per CALL, not per element \u2014 an iterating filter sends the body ONCE and loops on the",
+    "other side, so one body over a whole list beats one called from inside a stack loop.",
+    "",
+    "The lambda statement (`s.lambda({ as, code, timeout? })`) and eight filters run a",
+    "JavaScript body. **Write the body as a FUNCTION, not a `c.text` string** \u2014 the",
+    "bindings are its parameters, so the editor supplies them and a wrong name is a",
+    "compile error instead of a wrong value at runtime. Write it inline and the surface",
+    "is implied by where it sits; nothing names one:",
+    "",
+    "```ts",
+    "fl.map(({ $this }) => $this * 2)                                   // map's bindings, typed from the position",
+    "fl.reduce({ initial_value: 0, code: ({ $result, $this }) => $result + $this })",
+    's.lambda({ as: "total", code: ({ $var }) => $var.subtotal * 1.2 })  // ambient only \u2014 $this is a compile error',
+    "```",
+    "",
+    "The parameters are a fiction \u2014 only the BODY is sent, and the engine injects the",
+    "bindings as free identifiers \u2014 so DESTRUCTURE them. `(b) => b.$this` emits",
+    "`return b.$this`, and `b` is undefined at runtime (the SDK refuses it).",
+    "",
+    "\u26A0 An inline `code:` arrow receives BINDINGS ONLY. `capture` is an option of",
+    "`lam.fn`, not a field of `s.lambda` or of a filter \u2014 to pass data in, move the",
+    "body into `lam.fn(fn, { capture })` (below). Writing `capture:` beside `code:`",
+    "is a type error, and the fix is to relocate the body, not to drop the field.",
+    "",
+    "For a body built away from its call site:",
+    "",
+    "- `lam.fn(({ $result, $this }) => $result + $this, { surface?, capture? })` \u2014 name a `surface` to check it here, or omit it and the call site checks it.",
+    '- `lam.raw("return 1", { surface })` \u2014 text, same validation.',
+    '- `lam.file("./lambdas/total.ts")` \u2014 a default-exported function in its own type-checked module, read as text at build time. The deterministic option under a bundler, where a function\'s source is whatever the bundler emitted. NODE ONLY, and it is the `lam` import that changes: `import { lam } from "@xanots/sdk/node"`. The isomorphic `lam` has no `file` (no filesystem in a browser bundle); its `fn` and `raw` are the same functions.',
+    "",
+    "Nothing from the enclosing scope crosses implicitly. The body is sent as TEXT and runs",
+    "in a different process, so a closed-over `const rate` is undefined there, and the body",
+    "throwing on it returns the diagnostic text with HTTP 200 \u2014 a wrong VALUE, not an error.",
+    "Put what the body needs in `capture`; it arrives as the SECOND parameter and is emitted",
+    "ahead of the body as a `const` prelude:",
+    "",
+    "```ts",
+    'lam.fn(({ $this }, { capturedRate }) => $this * capturedRate, { surface: "map", capture: { capturedRate: rate } })',
+    "```",
+    "",
+    "\u26A0 A capture key must NOT share its name with a module-scope binding. An inline body is",
+    "recovered with `toString()`, and a `.ts` loader renames one of two same-named bindings \u2014",
+    "so the body reads `rate2` while the prelude declares `rate`, and `rate2` is undefined at",
+    "runtime (the body throws and the engine returns that text in the value slot with HTTP",
+    "200 \u2014 a wrong value, not an error). Build time refuses it. The key does not have to keep",
+    "the name of what it carries: `capture: { capturedRate: rate }` above is the safe form.",
+    "",
+    "Capture JSON data only \u2014 string, number, boolean, null, object, array. A function,",
+    "`undefined`, `symbol` or `bigint` has no JSON form that survives, and a `Date`/`Map`/",
+    "`Set`/`RegExp` has one that LIES (a `Date` arrives as a string, the rest as `{}`), so",
+    "all of them are refused at build time \u2014 the class ones at any depth. Capture the plain",
+    "form and rebuild in the body (`d.getTime()` \u2192 `new Date(d)`). The captured type flows into",
+    "that second parameter (no explicit type arguments), and an object may be declared as an",
+    "`interface` or a `type` alias alike.",
+    "",
+    "A body is a FUNCTION BODY: it must `return` its value. Bindings by surface \u2014 an",
+    "identifier outside its surface's set is undefined at runtime, and the SDK refuses",
+    "it at build time whichever spelling you use:",
+    ""
+  );
+  const ambient = LAMBDA_BINDINGS["s.lambda"];
+  const tick = (x) => `\`${x}\``;
+  lines.push(
+    `- every surface: ${ambient.map(tick).join(" \xB7 ")} (+ the ${LAMBDA_GLOBALS.map(tick).join(" / ")} globals)`
+  );
+  const extras = (surface) => LAMBDA_BINDINGS[surface].filter((b) => !ambient.includes(b));
+  const byExtras = /* @__PURE__ */ new Map();
+  for (const surface of Object.keys(LAMBDA_BINDINGS)) {
+    if (surface === "s.lambda") continue;
+    const key = extras(surface).join(" ");
+    byExtras.set(key, [...byExtras.get(key) ?? [], surface]);
+  }
+  for (const [key, surfaces] of byExtras) {
+    const label = surfaces.map((x) => tick(x.includes(".") ? x : `fl.${x}`)).join(" \xB7 ");
+    lines.push(`- ${label}: + ${key.split(" ").map(tick).join(" \xB7 ")}`);
+  }
+  lines.push(
+    `- \`s.lambda\`: ambient only \u2014 no \`$this\`, no \`$parent\`, no \`$result\`.`,
+    "",
+    "`$result` is `reduce`'s ACCUMULATOR (there is no `$acc`). `$this` is the element in",
+    "an iterating filter and the piped value in `fl.lambda`; `$parent` is the whole array",
+    "and exists only on the iterating filters. A stack variable is reached as",
+    "`$var.name` \u2014 it is NOT also injected as a bare `$name`.",
+    "",
+    "Four hazards and the dependency route, all live-verified:",
+    "",
+    "- \u26A0 A body that THROWS does not fail the request: the engine returns its diagnostic",
+    "  TEXT as the value with HTTP 200, so the failure reads as bad data. Validate before",
+    "  consuming a lambda result numerically, and prefer a `lam.*` body, which cannot fail",
+    "  this way for a binding reason.",
+    "- \u26A0 `timeout` bounds a body that AWAITS, not one that spins. It is COOPERATIVE \u2014 only",
+    "  observed at an `await` \u2014 so synchronous work runs to completion however long it takes:",
+    "  a 1s `timeout` over a body that busy-loops for 3s lets it run all 3 and return",
+    "  normally. Treat it as a bound on WAITING (a slow `fetch`), not a kill switch on",
+    "  compute \u2014 if a loop could run away, bound it yourself inside the body.",
+    "- \u26A0 A top-level `import`/`export` is a syntax error \u2014 the body is a function body, not",
+    "  a module. Reach a dependency through the PRELOADED globals below, which need no",
+    '  specifier. A dynamic `import("\u2026")` or `require("\u2026")` with a LITERAL specifier is not',
+    "  portable: on an instance that bundles the body before running it, every literal",
+    "  specifier is resolved ahead of time against a filesystem where none of them exist, so",
+    '  `await import("node:crypto")` comes back as the TEXT `Could not resolve "node:crypto"`',
+    "  with HTTP 200. Other instances resolve it at run time and it works \u2014 so it is",
+    "  instance-dependent, and only the globals are not.",
+    "- Preloaded globals, live-probed \u2014 no specifier, so these work everywhere:",
+    ...wrapList(LAMBDA_MODULE_GLOBALS.map(tick), "  "),
+    "  \u2026plus `fetch`, `Buffer`, `TextEncoder`/`TextDecoder`, and the `crypto` above",
+    "  (`randomUUID`, `createHmac`, `subtle` all present). `Object.keys(globalThis)`",
+    "  inside a body lists whatever else a given instance carries.",
+    "- \u26A0 `console` output goes to the request LOG, not stdout. `log` \xB7 `error` \xB7 `warn` \xB7",
+    "  `info` \xB7 `debug` \xB7 `trace` all route there; the body's `console` is a purpose-built",
+    "  object, so anything outside that set is undefined and CALLING it throws \u2014 which,",
+    "  per the first hazard, replaces the return value with the error text at HTTP 200.",
+    "",
+    "TypeScript annotations survive in the body, and top-level `await` works.",
+    ""
+  );
+  return lines;
+}
+var NAVIGATION_SLOT = "<!--navigation-->";
+function renderTestsSection() {
+  return [
+    "## Saved unit tests",
+    "",
+    "Named input sets run against one object, with assertions on its response \u2014 the tests the Xano editor shows. NOT `workflowTest()`, which is a standalone object with its own stack that calls other objects.",
+    "",
+    "- `tests?: TestDef[]` on `query()`, `defineFunction()`, and `middleware()`. No other kind stores them.",
+    "- `{ name, id?, description?, datasource?, input?, expect?, token? }`.",
+    "- `name` is unique within the object and is the key a statement's `mock` resolves against; a duplicate throws.",
+    "- `id` defaults to a derivation from the owning object plus the name. A pulled test carries the id Xano minted, emitted explicitly.",
+    '- `datasource` defaults to `""` \u2014 an EMPTY datasource. Any other value names one the engine CLONES before the run; `"live"` warns at encode time.',
+    '- \u26A0 That empty default means **no `table({ seed })` rows exist while a unit test runs**, exactly as for a `workflowTest()` \u2014 every `db` read misses and a count or index assertion (`resp("0.id")`) fails against a deployment whose endpoint returns those rows over HTTP a second later. Create what the test needs INSIDE the run \u2014 a `defineFunction` fixture the stack calls first \u2014 or `mock` the read.',
+    "- `input` is `{ <input name>: Value }` \u2014 tagged values (`c.*`, `ref`, \u2026), never plain JS scalars.",
+    "- `token` runs the test as an authenticated caller. A pull does NOT bring it back: it is an expiring credential, reported as a deliberate omission.",
+    "",
+    "### Assertions: `expect.*`, not `s.expect.*`",
+    "",
+    "- `expect.*` builds a `{type, vars}` record stored on a `tests` entry. `s.expect.*` builds a STATEMENT for a `workflowTest()` stack. Different return types; not interchangeable.",
+    "- Subject first \u2014 argument order is the assertion: `expect.to_equal(resp(), c.int(2))`.",
+    '- `resp()` is the response under test; `resp("id")` drills, `resp("a-b")` takes the bracket escape.',
+    "- Subject only: `to_be_defined`, `to_not_be_defined`, `to_be_empty`, `to_be_null`, `to_not_be_null`, `to_be_true`, `to_be_false`, `to_be_in_the_future`, `to_be_in_the_past`.",
+    "- Subject + operand: `to_equal`, `to_not_equal`, `to_be_greater_than`, `to_be_less_than`, `to_contain`, `to_start_with`, `to_end_with`, `to_match` (operand is a delimiter-wrapped pattern \u2014 build it with `c.regex`).",
+    "- `expect.to_be_within(subject, min, max)` \u2014 both bounds EXCLUSIVE; a subject equal to either fails.",
+    "- `expect.to_throw(exception?)` takes NO subject. With an argument the error message must CONTAIN that text (case-insensitive substring); with none, any error passes.",
+    "",
+    "### Mocks",
+    "",
+    "A statement returns a value instead of doing its work, for one named test.",
+    "",
+    '- `s.set_var("x", c.int(1), { mock: { "adds one": c.int(123) } })`. Every statement takes `mock`.',
+    "- Keyed by TEST NAME. A name the object does not declare THROWS at encode: the engine ignores a mock whose key is not a real test id, so it would deploy clean and silently never apply.",
+    "- `{ value, enabled: false }` keeps a mock stored but switched off.",
+    "- A mock applies ONLY while its test runs. It changes nothing about a normal request.",
+    "",
+    "### `example`",
+    "",
+    "`example?: { input?, output? }` on `query()` \u2014 the saved request/response sample the editor records. Free-form JSON, not tagged values. A pull DOES bring it back.",
+    "",
+    "### What a `workflowTest()` run actually sees",
+    "",
+    "The run is isolated in ways that make a correct test fail for reasons the failure message does not name.",
+    "",
+    "- The run uses an EMPTY datasource, so **no `table({ seed })` rows exist while it runs** and every `db` read misses. A test that buys seeded row 1 fails with its own precondition message, which reads as a wrong id rather than an empty database. Create what the test needs INSIDE the test \u2014 typically a `defineFunction` fixture the stack calls first.",
+    '- `s.api.call` does NOT raise when the endpoint answers with an error. It BINDS the error envelope (`{code, message}`) to its `as` and carries on, so a later `s.expect.to_be_defined({ expr: ref("r.field") })` reports the ASSERTION while the real failure was the call, four statements up. Assert on the envelope \u2014 `s.expect.to_contain({ expr: ref("r.code"), value: c.text("ERROR_CODE_INPUT_ERROR") })` \u2014 when a call may fail. `s.function.run` raises instead; the two disagree.',
+    "- `s.expect.to_throw({ body, exception? })` runs `body` in an ISOLATED var stack, so a variable bound EARLIER in the test is not visible inside it \u2014 bind what the body needs inside the body. `exception` is text the raised message must CONTAIN; omit it to accept any error.",
+    "- `s.expect.to_throw` catches such a call only when the error carries a MESSAGE. `ERROR_CODE_ACCESS_DENIED` arrives with an empty one, so `to_throw` around an auth-refused call reports `to_throw failed - response is ok` \u2014 which reads as a broken auth gate on a gate that works.",
+    "- An endpoint's `auth` gate is NOT enforced on `s.api.call`. A `query({ auth: users })` runs anyway and fails only where its stack dereferences `auth(...)`. A stack that never touches `auth(...)` runs unauthenticated and passes.",
+    "- Neither `auth.token` nor an `Authorization` entry in `headers` authenticates the call \u2014 a token that answers 200 over real HTTP is refused here. To cover auth-gated logic, move the body into a `defineFunction` taking the user id and `s.function.call` that; the gate itself is not reachable from a workflow test.",
+    "",
+    "### Running them",
+    "",
+    "`xanots test run-all` runs the unit tests AND the `workflowTest()` objects an environment carries. It takes no entry file and compiles nothing: it runs what is DEPLOYED, so deploy before testing.",
+    "",
+    "- `--dest ephemeral` (DEFAULT, `--name <env>` to pick one), `--dest sandbox`, or `--dest workspace`. Unlike `deploy`, `workspace` is allowed here \u2014 running a test reads.",
+    '- `xanots test list` shows what is there without running it; `xanots test run "<name>"` runs one. When a name is ambiguous the error prints the qualified `function:math/happy path` form, which `run` also accepts.',
+    "- `--kind unit|workflow` narrows to one family. `--concurrency <n>` defaults to 1: tests share the environment database.",
+    "- A failing suite exits 5, distinct from a crash. Tests that could not be REACHED exit 6 \u2014 retry that one, investigate the other. An environment with no tests is success, not failure.",
+    "- `xanots deploy ./index.ts --test` deploys and then runs the suite against what it just shipped. A failure exits 5 WITHOUT retracting the deploy \u2014 the environment is live either way.",
+    ""
+  ];
+}
+function renderSections(m) {
+  const lines = [];
+  lines.push(`# ${m.name} v${m.version}`, "");
+  lines.push(`> ${m.description}`, "");
+  lines.push(
+    "Author a Xano workspace in TypeScript: build typed objects, register them on a",
+    "`new Xano()` instance, and call `.export()` to get one importable bundle. Compile",
+    "with `xanots export ./xano/index.js`.",
+    "",
+    `Coverage: object kinds ${m.coverage.objectKinds.implemented}/${m.coverage.objectKinds.total}, statement surfaces ${m.coverage.statements.implemented}/${m.coverage.statements.total}, filters ${m.coverage.filters.total} (${m.coverage.filters.typed} typed).`,
+    // The shortfall by name: an agent that cannot see WHICH kinds are missing
+    // will invent a factory for one. Reasons live in `manifest.json`.
+    `Not authorable here: ${m.coverage.objectKinds.unmodeled.map((k) => k.kind).join(", ")} \u2014 these cannot be authored and do not survive a pull; see \`coverage.objectKinds.unmodeled\` in \`manifest.json\`.`,
+    "",
+    "This file is the whole always-read surface: the mental model, the deploy contract,",
+    "every gotcha, and control flow. Per-surface detail lives in the topic files listed",
+    "below \u2014 open the one whose condition matches the task, and skip the rest. For",
+    "exhaustive per-entry detail in NEITHER \u2014 a statement's full field schema with engine",
+    "defaults, a filter's complete argument list, the engine `storedName` mapping \u2014 do a",
+    "TARGETED lookup in the shipped `manifest.json` (grep or `jq` the one entry you need;",
+    "it is ~55k tokens, so never read it whole). Its top-level keys are `" + Object.keys(m).join("`, `") + "`. `statements` and `filters` are ARRAYS, not maps \u2014 SELECT, do not index:",
+    `  jq '.statements[] | select(.sPath=="db.get")' manifest.json`,
+    `  jq '.filters[]    | select(.name=="json_decode")' manifest.json`,
+    `Select a statement on \`sPath\` (the \`s.*\` path you write), NOT \`surface\` (the XanoScript term): ${m.statements.filter((s) => s.surface !== s.sPath).length} of ${m.statements.length} differ \u2014 \`var\`\u2192\`set_var\`, \`break\`\u2192\`foreach_break\`, \`foreach.remove\`\u2192\`foreach_remove\`, and every \`expect.*\`.`,
+    "",
+    NAVIGATION_SLOT
+  );
+  lines.push(
+    "## Quickstart",
+    "",
+    "Authoring is **declarative def-objects** passed to factories \u2014 there is no",
+    "callback/chaining builder.",
+    "",
+    "```ts",
+    'import { workspace, apiGroup, query, table, input, f, ref, inp, auth, s } from "@xanots/sdk";',
+    "",
+    "const users = table({",
+    '  name: "users",',
+    "  auth: true, // backs authentication",
+    "  // `id` (int PK) + `created_at` (epochms) are auto-injected \u2014 don't declare them.",
+    "  schema: {",
+    "    email: f.email({ required: true }),",
+    "    name: f.text(),",
+    "  },",
+    '  // Indexes: { type, fields: [{ name, op? }] }. `"unique"` is shorthand for `"btree|unique"`.',
+    "  // A DOTTED name indexes a key inside a column (`xdo.email`); only the part before the",
+    "  // first dot is checked against the schema.",
+    '  index: [{ type: "unique", fields: [{ name: "email" }] }],',
+    "});",
+    "",
+    "const posts = table({",
+    '  name: "posts",',
+    "  schema: {",
+    "    author: f.tableRef(users), // foreign key \u2192 users (NOT `ref`)",
+    "    body: f.text({ required: true }),",
+    "  },",
+    "});",
+    "",
+    'const api = apiGroup({ name: "blog", canonical: "blog" }); // canonical \u2192 the URL token',
+    "",
+    "const createPost = query({",
+    '  name: "create_post", verb: "POST", apiGroup: api, auth: users, // the auth table',
+    "  input: { body: input.text({ required: true }) },",
+    "  stack: [",
+    '    s.db.add({ table: posts, row: { author: auth("id"), body: inp("body") }, as: "post" }),',
+    "  ],",
+    '  response: ref("post"),',
+    "});",
+    "",
+    "const listPosts = query({",
+    '  name: "list_posts", verb: "GET", apiGroup: api,',
+    '  stack: [s.db.query({ table: posts, sort: [{ sortBy: "created_at", dir: "desc" }], as: "rows" })],',
+    '  response: ref("rows"),',
+    "});",
+    "",
+    'export default workspace("my-blog")',
+    "  .registerTables([users, posts])",
+    "  .registerApiGroups([api])",
+    "  .registerQueries([createPost, listPosts]);",
+    "```",
+    "",
+    "Compile: `xanots export ./index.ts --out bundle.json` (or `writeBundle(app, path)`",
+    "from `@xanots/sdk/node` in code). The default export must be the `Xano` registry. The entry must be an",
+    'ES module (XanoTS defs are ESM-only): set `"type": "module"` in the nearest',
+    'package.json or name the entry `.mts`. `npm init -y` writes `"type": "commonjs"`,',
+    'which fails with a "must be ES modules" error until you switch it to module.',
+    "",
+    "Set `canonical` on every `apiGroup`. The engine mints the URL token server-side, so",
+    "without one a group's client paths are unresolvable until a lock exists: the bundle",
+    "exports fine and `xanots paths` / `getPath()` then fail on the very queries it just",
+    "built. An explicit `canonical` resolves them from the source alone.",
+    "",
+    "Build warnings: `export()` prints the shapes that deploy clean and then do the wrong",
+    "thing (a `bulk.update` zero-filling omitted columns, an `ignoreEmpty` on an empty",
+    "operand, a `ref()` nothing binds). Each has a legitimate use, so each only warns \u2014",
+    "but nothing fails on a message no one reads, so in CI and in unattended agent builds",
+    "pass `--strict` (`emitBundle(app, { strict: true })` / `app.export({ strict: true })`):",
+    "every warning becomes a hard failure. Same bundle bytes either way.",
+    "",
+    "Identity: object guids derive from `(type, name)`, so renames change identity.",
+    "`xanots export <entry> --lock` freezes every guid + api-group/toolset canonical in a lock",
+    "file written BESIDE THE ENTRY FILE \u2014 `xano/xano.lock` for the standard scaffold, NOT the",
+    "project root \u2014 which you commit (auto-read once present; CI guard `--frozen-lock` fails",
+    "instead of changing the lock). Fix-up subcommands:",
+    "`xanots lock rename <kind> <old> <new>` (kind = payloadKey or table/api_group),",
+    "`xanots lock prune <entry-file> [keys\u2026] --yes` \u2014 finding orphans RUNS the entry's module scope",
+    "(env assertions included); `--no-verify --yes <kind:name>\u2026` prunes named keys with no evaluation",
+    "and no orphan check,",
+    "`xanots lock adopt <live-bundle.json> [--yes]` \u2014 all accept `--lock=<path>`.",
+    "Programmatic use: call `seedLockOverrides(readLockFile(path))` BEFORE importing",
+    "any def module \u2014 references bake guids at import time, so late seeding is a",
+    "silent no-op (`resetLockOverrides` exists for tests).",
+    "Development workflow: opt in EARLY \u2014 run `xanots export ./xano/index.ts --lock` once and COMMIT",
+    "`xano.lock` beside the entry file; every later export then keeps identities",
+    "stable across renames and environments. To rename an object: rename in code,",
+    "export (stderr prints the exact fix-up), run `xanots lock rename <kind> <old>",
+    "<new>`, export again \u2014 the original guid is emitted under the new name, so the",
+    "engine renames in place instead of delete+create. Taking over an existing",
+    "workspace: `xanots lock adopt <its-packageExport.json>` first, then export.",
+    "",
+    "## Deploy",
+    "",
+    "`xanots init` \u2192 `xanots deploy` \u2192 URL. Each `deploy` runs the same compile",
+    "pipeline as `export` (honoring `xano.lock`), then imports the result into a live",
+    "environment and prints its URL.",
+    "\u26A0 Every deploy is a FULL REPLACE: it clears that environment's workspace \u2014 objects",
+    "AND records \u2014 before importing. The blast radius is a disposable environment, not a",
+    "production workspace, but confirm with the user before the first run.",
+    "",
+    "**Two destinations, and the choice changes more than the target.**",
+    "",
+    "- `--dest ephemeral` (DEFAULT) \u2014 a NAMED, workspace-scoped, auto-expiring tenant",
+    "  (~1h; `--expires-hours` 1\u201372 at create time). The active one is tracked in",
+    "  `./.xano/ephemeral.json`, so deploying again REFRESHES it and the URL is unchanged;",
+    "  if it expired or was swept, a fresh one is created and the new URL is called out.",
+    "  `--static` puts the frontend ON THE EPHEMERAL, so backend and frontend share one",
+    "  disposable environment.",
+    "  \u26A0 Only the BACKEND URL survives a refresh: the replace clears static hosting too,",
+    "  so `--static` publishes a NEW host every run and the previous URL stops serving.",
+    "- `--dest sandbox` \u2014 your single throwaway tenant, no expiry. `--static` puts the",
+    "  frontend on your OWN (parent) workspace instead, because the sandbox tenant does",
+    "  not serve static hosting.",
+    "- `xanots release` promotes to your INSTANCE workspace and MERGES, not replaces:",
+    "  adds/updates what you define, deletes nothing, writes no rows. Destruction is",
+    "  opt-in per flag, previewed + confirmed, and can drop a table WITH its rows.",
+    "  NOT flag-gated: removing a column from a schema destroys that column's data",
+    "  (previewed against live). `--prune` deletes only what `xano.lock` records this",
+    "  project released, and refuses without a lock.",
+    "",
+    "Nothing from a DEPLOY is written back into `xano.lock` (an ephemeral/sandbox is a",
+    "separate workspace, so its identities must not pollute yours). The one write-back is",
+    "`release --replace`, which mints fresh identities in the workspace the lock describes:",
+    "it re-pins the lock from the rebuilt workspace, because otherwise the next release",
+    "matches nothing and duplicates every object. Deploying an ENTRY",
+    "FILE still updates the local lock via the shared compile step, exactly as `export`",
+    "does \u2014 only when a lock exists or `--lock` is passed.",
+    "",
+    "**Frontend wiring.** `--static <dir>` injects the DEPLOYED env's backend URL as",
+    "`window.XANO_HOST` into EVERY html document in the build, before the app bundle runs,",
+    "so the frontend needs no rebuild to target an env. Every document, not just the root:",
+    "a prerendered build serves a different one per route, and a route without the global",
+    "renders fine while every call goes to the wrong origin. Read it at runtime with a build-time",
+    "fallback:",
+    "  const HOST = (typeof window !== 'undefined' && window.XANO_HOST) || import.meta.env.VITE_XANO_HOST;",
+    "In LOCAL DEV there is no injected global, so the fallback is what answers: set",
+    "`VITE_XANO_HOST` in a `.env.local` beside `.env.example` at the PROJECT ROOT. The",
+    "scaffold's vite config sets `envDir` there (its `root` is `frontend/`, and Vite",
+    "resolves `.env` files against `root`) \u2014 without it the var reads as undefined, the",
+    "host falls back to '', and every call 404s off the dev server.",
+    '\u26A0 It is INJECTED in bracket form \u2014 `window["XANO_HOST"]="\u2026"` \u2014 so verifying a deploy',
+    "by grepping `window.XANO_HOST` matches nothing and reads as a failed inject. Grep the",
+    "bare `XANO_HOST` token.",
+    "\u26A0 `xanots validate` ignores the deploy login and reads `XANO_VALIDATE_INSTANCE` /",
+    "`XANO_VALIDATE_TOKEN` (+ optional `XANO_VALIDATE_WORKSPACE_ID`) from the environment.",
+    "**Displaying a stored file.** A file column comes back as `{ path, name, type, size,",
+    "meta, access, url }`. \u26A0 Do NOT use its `url`: on a tenant-scoped environment that field",
+    "addresses the instance host WITHOUT the `/tenant/<name>` segment and 404s, silently \u2014",
+    "as a broken `<img>`, with every API assertion still passing. Build the URL from `path`",
+    "instead: `fileUrl(row.avatar, HOST)` (exported from `@xanots/sdk`) returns `null` for",
+    "an absent file and is correct on an ephemeral and an instance workspace alike.",
+    "\u26A0 A static host serves these files verbatim, so everything injected is PUBLIC \u2014 base",
+    "URLs and publishable keys only, never secrets. Secrets go in backend env, read",
+    "server-side via `env(name)`.",
+    "",
+    "**Full CLI surface:** `xanots <command> --help` lists every command, flag, and",
+    "default; the shipped `manifest.json` carries the same in its `cli` array. This doc",
+    "does not duplicate it \u2014 it covers what you must know to AUTHOR a workspace.",
+    "**Recommended style:** reach statements through the `s` namespace",
+    "(`s.db.add`, `s.math.add`, \u2026) \u2014 one discoverable, tab-completable surface. The",
+    "flat factory aliases (`dbAdd`, `dbQuery`, `setVar`, `mathAdd`, \u2026) are exported",
+    "and identical in output; prefer `s.*` in new code so examples stay consistent.",
+    ""
+  );
+  lines.push(
+    "## Gotchas",
+    "",
+    "Non-obvious authoring rules:",
+    "",
+    "- **No callback builder.** Flat def-objects + `register*`, not",
+    "  `workspace(w => w.table(...))`. `workspace(name)` returns a named `new Xano()`;",
+    "  tables are `table({ schema: { col: f.text() } })`.",
+    "- **Foreign key is `f.tableRef(table)`, not `ref`.** `ref(name)` references a",
+    "  stack variable (a value); `f.tableRef` is the column constructor.",
+    "- **Reference-helper picker:** `ref` = stack var (`as:` output), `inp` = input,",
+    '  `col` = table column (in `db.query` `where`), `auth("id")` = the caller,',
+    "  `c.*` = a constant. Pick by what you're pointing at.",
+    "- **`s.api.call` / `s.task.call` / `s.trigger.call` / `s.workflow_test.call` are",
+    "  WORKFLOW-TEST ONLY.** Outside a `workflowTest({...})` stack the engine cannot reach",
+    "  the target, so one in a query/function/task deploys clean and then answers the first",
+    "  real request with `ERROR_FATAL: <Type> does not exist: <type>:<n>` \u2014 and not per",
+    "  host kind, the same call fails identically from a function a query runs.",
+    "  `export()` refuses them. `s.function.call`, `s.tool.call`, `s.middleware.call` and",
+    "  `s.addon.call` run anywhere, as does `s.function.run` (the ordinary function",
+    "  invocation). To share logic between endpoints, put it in a `defineFunction` and",
+    "  `s.function.run` it from both.",
+    "- **`expect.*` is a unit-test assertion; `s.expect.*` is a workflow-test statement.**",
+    "  A statement's `mock` is keyed by TEST NAME; an undeclared name throws. See `llms/tests.md`.",
+    "- **Drilling into a maybe-null `db.get` result 500s \u2014 use `ref(path, { safe: true })`.**",
+    '  `db.get` binds `null` on a no-match, but a nested `ref("owner.user_id")` resolves',
+    '  `$owner.user_id` in one lookup and raises a runtime "Unable to locate var" (HTTP 500)',
+    "  when `owner` is null \u2014 so an ownership/existence guard throws instead of failing",
+    '  cleanly. Either guard existence first (`expr(ref("owner"), "!=", c.null())`,',
+    "  or a `db.has`/`db.query`-count precondition), or drill with the null-safe opt-in:",
+    '  `expr(ref("owner.user_id", { safe: true }), "=", auth("id"))` compiles through the',
+    "  `get` filter and yields `null` (guard reads `false`) rather than 500ing.",
+    "  Works inside `obj({...})` too \u2014 no per-member `s.set_var` hoist needed.",
+    "  \u26A0 EXPRESSION and `obj()` operands ONLY \u2014 never a `db.*` match argument. `null`",
+    "  is not a legal `fieldValue`/`id`, so a chained get (fetch the child row, then",
+    "  fetch its parent to check the owner) fails with HTTP 400 `Missing param:",
+    "  field_value` one statement BEFORE the guard \u2014 the same net effect as the 500,",
+    "  with an internal-sounding status the caller should never see. Only an id",
+    "  matching no row reaches it, so it deploys clean. In the chained case guarding",
+    "  existence first is MANDATORY, not a stylistic alternative: precondition on",
+    '  `expr(ref("ticket"), "!=", c.null())`, then drill WITHOUT `safe` (the base is',
+    "  known non-null by then). `export()` warns on a safe ref in that position.",
+    "  \u26A0 That is for a base that EXISTS and may be null. If the base binds nothing at all",
+    "  (a typo), `{ safe: true }` turns the 500 into a silent `null` and buries the bug \u2014",
+    "  `export()` warns on a `ref()` whose base segment no `as` in that stack binds, with a",
+    "  did-you-mean; fix the name instead.",
+    "- **DB reads are field-match, not `where`-expr.** `db.get`/`db.edit`/`db.del`/",
+    "  `db.has`/`db.patch` match one field: `{ fieldName, fieldValue }` (`fieldName`",
+    "  defaults to the PK `id`). Only `db.query` takes a `where`/`additionalWhere`",
+    "  `expr(...)`; writes (`db.add`/`db.edit`/`db.add_or_edit`) take a `row`/`data`.",
+    "  `db.get_by_id` is the exception to the field-match rule \u2014 it is the dedicated",
+    "  get-by-primary-key statement and takes `{ table, id }`, NOT `fieldValue`.",
+    "  Signatures: `llms/statements-data.md`.",
+    "- **Single-field only \u2014 no composite match.** These ops match exactly ONE field;",
+    "  there is no two-field form (the engine's by-field lookup takes a single",
+    "  predicate). For a `(a, b)` existence/fetch \u2014 e.g. dedupe a `(habit, date)`",
+    '  check-in \u2014 use `db.query({ where: [expr(col("habit"), "=", ...), expr(col("date"), "=", ...)], as })`',
+    "  (a `where` array is ANDed) and branch on the result, rather than pushing the",
+    "  check to the client.",
+    "- **System columns are auto-injected.** `id` + `created_at` are prepended to",
+    "  every table (`system: true` by default); declaring them by hand is redundant.",
+    '  `id` is an `int` PK by default; pass `idType: "uuid"` on the table for a uuid key.',
+    "  Both are valid targets wherever a column name is accepted \u2014 `db.query` `sort`/",
+    "  `output`, a `db.get`/`edit`/`del` `fieldName`, etc. (the column-name type is",
+    '  `keyof schema | "id" | "created_at"`), and both appear in `InferRow<typeof table>`.',
+    "- **Seed a table's starting rows with `table({ seed })`.** `seed` takes rows",
+    "  typed against the table's schema as a WRITE shape (a column without",
+    "  `required: true`, and the system columns, may be omitted; `null` needs",
+    '  `nullable: true`) \u2014 inline (`seed: [{ name: "\u2026" }]`), a FILE',
+    '  (`seed: seedFile("./seed.json", import.meta.url)`; path resolves against the DECLARING',
+    '  file), or a thunk (`seed: () => import("./seed.json")`, async ok, `.default` unwrapped).',
+    "  Inline rows are TYPED against the schema at compile time; a `seedFile`/thunk seed is",
+    "  NOT \u2014 the JSON is opaque to the typechecker, and the `xanots export`/`deploy` CLI",
+    "  validates it instead, naming the row index, the offending column, and the known",
+    "  columns. \u26A0 Prefer `seedFile` for a file: a thunk's `import()` sits in",
+    "  YOUR module, so a bundler emits the JSON as a served chunk. NEITHER is a secrecy",
+    "  boundary \u2014 a bundler that inlines the asset ships them either way. Never put secrets",
+    "  in `seed`. `deploy --static` REFUSES a build carrying internal/sensitive seed values;",
+    "  `--allow-seed-in-static` overrides for deliberately public demo credentials.",
+    "  Deploy is a full replace, so re-deploying re-seeds",
+    "  cleanly (no duplication). Omit `id` and rows auto-number `1..N` (int PK) or take",
+    "  a stable derived uuid (uuid PK); supplying `id` pins it (engine preserves it,",
+    "  resets an int sequence past the max). All-or-nothing \u2014 mixing explicit and",
+    "  omitted `id` throws. A `system:false` PK is the author's to supply. Pinning is",
+    "  `seed`-only \u2014 `s.db.bulk.add` DROPS `id` unless `allowIdField: true`.",
+    "- **`use_xdo` storage mode.** Workspace setting (`registerWorkspace({ use_xdo })`,",
+    "  default `false`) controlling whether fields are stored as JSON under the `xdo`",
+    "  column (`true`, adds a `gin(xdo)` index) or as real columns (`false`, no gin).",
+    "  Tables inherit it; override per-table with `table({ useXdo })`. Resolved at",
+    "  `export()`, so the workspace and tables can be registered in any order.",
+    "- **Self-referencing tables** need the bare-name form: inside `tweets`'s own",
+    '  schema, write `f.tableRef("tweets", { type: "int" })` \u2014 the `const tweets`',
+    `  handle isn't assigned yet, so the handle form throws "used before declaration".`,
+    "- **Same-name siblings collide.** Object guids derive from `(type, name)` and",
+    "  ignore a query's `verb`, so a `GET` and `POST` both named `posts` clash;",
+    "  `export()` throws on the collision \u2014 give them DISTINCT names (`posts` and",
+    "  `posts/create`; the verb still carries the semantics). A distinct explicit",
+    "  `guid` on each clears that throw but is NOT a lasting fix: a lock entry is",
+    "  keyed by `(type, name)` too and cannot hold two guids, so `export --lock`",
+    "  refuses the pair \u2014 and a committed lock is the recommended workflow.",
+    "  `export()` warns on a same-name pair even unlocked. An explicit `guid` is",
+    "  for pinning identity across a rename, not for sharing a name.",
+    "- **`export()` vs `emitBundle()` vs `writeBundle()`:** `writeBundle(app, path)`",
+    "  writes it to disk; `export()` returns the bundle object;",
+    "  `emitBundle()` returns the pretty JSON string. All three run the SAME build-time",
+    "  checks, INCLUDING seed validation of a literal `seed: [...]` array (row shape,",
+    "  unknown column, coercion, enum membership, the all-or-nothing `id` rule). A",
+    '  DEFERRED seed \u2014 a thunk (`() => import("./seed.json")`) or `seedFile()` \u2014 needs an',
+    "  await or the filesystem, so it is materialised and checked only by the",
+    "  `xanots export`/`deploy` CLI path. Seed rows are never emitted into the bundle",
+    "  either way; only `deploy` ships them. The `node:fs` writers",
+    "  (`writeBundle`/`writeArtifact`) and lock-file I/O import from `@xanots/sdk/node`,",
+    "  NOT the browser-safe `@xanots/sdk` entry (which a frontend can import query",
+    "  defs from to use `getPath()`/`InferInput` with no Node built-ins in the bundle).",
+    "  The compiler machinery (per-kind `encode*`, the registries, the bundle serializer,",
+    "  the lock model) is on `@xanots/sdk/internal` and is never needed to author.",
+    "- **Client bundle size / tree-shaking.** `@xanots/sdk` is `sideEffects: false` and pulls",
+    "  no Node built-ins, so a bundler drops unused SDK exports. But importing a **def** for its",
+    "  `getPath()`/`verb`/`getUrl()`/`getChannel()` also pulls whatever its `stack` references:",
+    "  the `s.*`/`c.*` factory CALLS run at module load to BUILD it. Types are free.",
+    "  \u26A0 A FLOOR \u2014 **~289 kB minified (~57 kB gzipped)** for the FIRST def; splitting modules",
+    "  never removes it. The floor is the RUNTIME, not the def: a second def, or a much richer",
+    "  one, adds ~1 kB. So the cost is paid by importing ANY def at all, and reducing what a",
+    "  def does will not reduce it.",
+    "  Fix: `xanots paths <entry> --emit xano/routes.gen.ts` (`routes` is an accepted alias) \u2014 verbs, paths, and sockets as",
+    '  plain data importing NOTHING, still compile-checked: `routePath("blog/{slug}", { slug })`,',
+    '  `channelPath("rooms/{room_id}", { room_id })`, `socketUrl("chat", baseUrl)` (tenant base',
+    "  URLs lifted to `wss://h/ws/<tenant>:<canonical>`). A rename is a type error, not a 404.",
+    "- **Intra-workspace imports use `.js` specifiers** (`../tables/links.js`), not",
+    "  extensionless \u2014 the defs compile under `moduleResolution: bundler`. Add the `.js`.",
+    "- **Verifying a def outside a bundler.** Inside a bundler (Vite/webpack) importing a",
+    "  query def to read `getPath()`/`verb` works directly. To spot-check from Node, run a REAL",
+    '  file with `tsx <file.ts>` **from inside the project root** \u2014 not `tsx -e "import \u2026"`',
+    "  (its CJS-preparse mis-resolves the package `exports` map \u2192 ERR_PACKAGE_PATH_NOT_EXPORTED),",
+    "  and not bare `node file.ts` (chokes on the `.js`-specifier intra-workspace imports the",
+    "  xanots CLI's own loader resolves). Running from outside the project root also breaks",
+    "  the `@xanots/sdk` specifier resolution.",
+    "- **A helper returning `Statement[]` widens the stack and kills `InferResponse`.**",
+    "  Factoring a repeated guard into `function requireX(): Statement[]` and spreading it",
+    '  (`...requireX("d")`) drops the stack\'s TUPLE type, so EVERY `ref()`/`as` in that stack \u2014',
+    "  including ones declared after the spread \u2014 resolves to `unknown` and the query's",
+    "  response types as `StackTupleWidened`. Nothing fails at the helper: the error surfaces",
+    "  wherever the response is consumed, often a frontend package's typecheck. Fix: return",
+    "  `statements(s.a(...), s.b(...))` \u2014 a const-generic identity export whose tuple survives",
+    "  the spread. A helper that builds its array in a LOOP cannot be a tuple; declare",
+    "  `responseShape` on the query there. See `llms/statements-runtime.md`.",
+    "- **Block specials nest a `body`, not a `stack`.** `s.for`/`s.foreach`/",
+    "  `s.while`/`s.switch`/`s.try_catch`/`s.db.transaction`/`s.expect.to_throw`",
+    "  take their sub-stack as `body` (`try`/`catch`/`finally` for `try_catch`);",
+    "  `s.group(body)` and `s.util.post_process(body)` take it **positionally**.",
+    "  `s.for` is **count-bounded** (`{ as, count, body }`), not from/to. See the",
+    "  authored signatures in `llms/statements-data.md`.",
+    "- **MCP servers & agents are distinct root kinds** that both persist under the",
+    "  `toolset` payload key (so a same-name pair collides). `mcpServer({...})` exposes",
+    "  tools over MCP (auth is per-tool \u2014 no server-level gate); `agent({...})` carries a",
+    "  typed `llm` block \u2014 and so may an `mcpServer`, since the two are ONE stored",
+    "  object distinguished by `type`. Their `tools` take a `tool()` handle (or name), resolved to the",
+    "  tool's guid like the call family; a raw numeric `id` is an escape hatch.",
+    "- **`task.schedule` is an array** of `{ startsOn, freq?, repeatEnabled?, endsOn?, endsEnabled? }`",
+    "  (`ScheduleDef[]`), not a single `{ type, value }`. `freq` is seconds; `startsOn`/",
+    '  `endsOn` are timestamp strings validated at encode time \u2014 `"2026-01-01T00:00:00Z"`, or',
+    '  the space-separated `"2026-01-01 00:00:00+0000"` a pulled workspace carries. Never',
+    "  epoch numbers, and never zoneless: the engine stores the string verbatim without",
+    "  checking it, so one it cannot parse deploys clean and the task then never fires.",
+    "- **`get_input`/`get_raw_input` read the whole payload**, not one named input",
+    "  (args are `{ as?, encoding?, excludeMiddleware? }` \u2014 no `name`). For a single",
+    '  input use `inp("name")`.',
+    '- **`f.password()` defaults to `access: "internal"`, so `db.get` does NOT return it.**',
+    '  A login stack that reads `ref("u.password")` after a plain `db.get` fails at runtime',
+    "  with `Unable to locate var: u.password` \u2014 the column is simply absent from the row.",
+    '  Name it in the read\'s `output` to pull it: `s.db.get({ table: users, fieldName: "email",',
+    '  fieldValue: inp("email"), output: ["id", "email", "password"], as: "u" })`, then',
+    "  `s.security.check_password`. `output` OVERRIDES column visibility \u2014 it is the only way to",
+    "  read an `internal` column, and `export()` warns when a stack reads one a `db.get` did not",
+    "  return.",
+    "- **Build regex-filter patterns with `c.regex(body, flags?)`, never `c.text`.**",
+    "  The regex filters (`regex_test`/`regex_match`/`regex_replace`/\u2026) are pattern-piped",
+    "  PHP `preg_*`: the piped value is the PATTERN and must be delimiter-wrapped. A bare",
+    '  `c.text("^[^@\\s]+@...$")` is an invalid pattern that matches *nothing* for every',
+    "  input, so a precondition on it silently rejects all values (valid ones included).",
+    '  `c.regex("^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$", "i")` wraps + escapes it for you (accepts a',
+    "  JS `RegExp` too: `c.regex(/^\u2026$/i)`), and `withFilters` throws on a bare `c.text`",
+    "  pattern pointing here \u2014 from ANY position in the chain, so a normalizer in front",
+    '  (`withFilters(c.text("^hi"), fl.trim(), fl.regex_test(...))`) is refused too; nothing',
+    "  upstream adds the delimiters. `s.expect.to_match`'s `value` is the same PATTERN slot,",
+    "  refused the same way; a `ref`/`inp` pattern is passed through untouched, either place.",
+    "  Better still, prefer a native typed input",
+    "  (`input.email({...})`) over hand-rolled validation.",
+    "- **Compose a rule set as SIBLINGS, not a folded chain.** `and(...rules)` takes any",
+    "  number of terms and encodes flat; `rules.reduce((acc, r) => and(acc, r))` nests one",
+    "  container per rule, which costs quadratic bytes (512 terms: 394 KiB flat, 21 MiB",
+    "  folded) and is refused past 128 levels. Mixed joins: `and(or(...anyOf), ...allOf)`.",
+    '- **Declare inputs with `input.<type>()`, read them with `inp("name")`.** `inp()`',
+    "  resolves ONLY against this def's own `input` block \u2014 a value produced earlier in",
+    '  the stack is `ref("var.field")`, not `inp("field")`. An undeclared name fails at',
+    "  runtime with `Unable to locate input` (`export()` warns).",
+    "- **Don't take a password through `input.password` on login \u2014 it double-hashes.**",
+    "  An `f.password()` column hashes on write, and `input.password` *also* hashes the",
+    "  submission on bind, so `s.security.check_password` compares two different hashes",
+    "  and a correct password always fails (`ok:false` on a found row). Take the submitted",
+    "  password as `input.text()` on both signup and login and pass the plaintext straight",
+    "  to `check_password` (which does the comparison hash itself).",
+    "- **Agents authenticate with env vars \u2014 never `xanots login`.** `login` blocks on a",
+    "  browser consent no agent can complete. Set `$XANO_INSTANCE_URL` + `$XANO_WORKSPACE_ID`",
+    "  + `$XANO_META_TOKEN` and run `deploy`/`release` directly: no disk, no rotation, so it",
+    "  survives repeated runs. It outranks every other credential (`--config` and",
+    "  `$XANO_REFRESH_TOKEN` included, each named on stderr when displaced), and setting SOME",
+    "  of the three is a hard error \u2014 a misspelled secret must not fall through to whatever",
+    '  credential the runner has. As a file that triple is `{ "type": "token",',
+    '  "instance_base_url": \u2026, "workspace_id": <n>, "meta_api_token": \u2026 }`. The older',
+    "  `$XANO_REFRESH_TOKEN` + `$XANO_CLIENT_ID` pair still works but ROTATES: single-use.",
+    "- **Event-driven objects fire on an EPHEMERAL, not in the sandbox.** A `task`",
+    "  (scheduled), an `mcpServer`, and every trigger \u2014 `tableTrigger` included \u2014 run normally",
+    "  on an ephemeral env, which is `deploy`'s DEFAULT destination. So test an event-driven",
+    "  design (screen-on-insert, cron cleanup, MCP tool call) by deploying it and letting it",
+    "  run.",
+    "  \u26A0 Under `--dest sandbox` they import cleanly but their stacks NEVER execute, and there",
+    "  is no way to fire one manually \u2014 an insert on a bound table does not run its",
+    "  `tableTrigger`, and the design silently does nothing. Only synchronously-invoked objects",
+    "  (queries, functions, and the agents an endpoint calls with `s.ai.agent.run`) run there.",
+    "  If you must stay on the sandbox, verify the logic out of band: factor the body into a",
+    "  `defineFunction` (or a callable `query`) and invoke it directly \u2014 a `tableTrigger` that",
+    "  screens a row on insert should delegate to a function a `query` can also call via",
+    "  `s.function.run`, and you assert against that.",
+    '- **Zero-based numeric keys make `c.obj` a LIST.** `c.obj({ "0": "a" })` evaluates to',
+    '  `["a"]`: a numeric key IS an index in the engine\'s data model, so keys that are exactly',
+    "  `0..n-1` come back as a list with HTTP 200 and no error. Write `c.array([...])` when you",
+    '  want the list, or prefix the keys (`"k0"`) when you want an object. A non-zero-based',
+    '  numeric key (`{ "2": \u2026 }`) survives as a key. Export warns.',
+    "- **To match every row, omit `where` \u2014 never pass a constant.** `where: c.bool(true)` is",
+    '  not "no filter": a bare scalar literal states no condition and the engine reads the',
+    '  resulting `context.search` as garbage, so it throws. An absent `where` is how "every',
+    '  row" is spelled. A raw `Value` `where` stays the escape hatch for a clause built',
+    '  elsewhere \u2014 `inp("clause")`, `ref("built_where")`, or `c.text("id > 0")`.',
+    "- **An `auth()`-keyed limiter collapses on any host with no caller identity \u2014 at every**",
+    '  **tier.** `s.redis.ratelimit({ key: withFilters(c.text("rl:"), fl.concat(auth("id"))) })`',
+    "  is the per-user form, but `auth()` is `null` on a public query, a task, or a function,",
+    "  and every caller then shares one bucket. Attaching it once at",
+    "  `apiGroup({ middleware })` or the workspace tier is the tempting DRY move and inherits",
+    "  the same collapse onto every member endpoint. Export warns, naming the tier.",
+    ""
+  );
+  const objectKinds = [];
+  objectKinds.push("## Object kinds", "");
+  objectKinds.push("Author with the factory, register on the Xano instance, lands under the payload key. Each line ends with a one-liner on what the primitive is.", "");
+  objectKinds.push(
+    "\u26A0 Composing a workspace from independently-authored modules: `register*` takes its defs however they arrive, but `modules.flatMap((m) => m.tables)` does NOT typecheck. `Array.prototype.flatMap` binds its element type to the FIRST element, so every later module's tables are checked against that one table's schema \u2014 the error compares two unrelated column names and mentions neither `flatMap` nor the cause. `.concat()` collapses the same way. Two spellings work: pass an array LITERAL (`registerTables([...a.tables, ...b.tables])` \u2014 spreads are fine, TypeScript infers the union across every element at once), or annotate the module array with the wide aliases `AnyTableDef` / `AnyQueryDef` / `AnyFunctionDef` / `AnyAddonDef`, exported for exactly the four def types whose generics can collapse this way. Widening the array costs nothing: the typing you need lives on the `table()`/`query()` handle you hold and pass to `s.db.*`, and is never read back off the registered array.",
+    ""
+  );
+  for (const k of m.objectKinds) {
+    if (k.subKinds && k.subKinds.length > 0) {
+      for (const sub of k.subKinds) {
+        if (sub.legacy) continue;
+        objectKinds.push(
+          `- ${k.kind} (${sub.objType}): \`${sub.authorFactory}\` \u2192 \`Xano.${k.registerMethod}\` \u2192 payload \`${k.payloadKey}\` \u2014 ${sub.description}`
+        );
+      }
+    } else {
+      objectKinds.push(`- ${k.kind}: \`${k.authorFactory}\` \u2192 \`Xano.${k.registerMethod}\` \u2192 payload \`${k.payloadKey}\` \u2014 ${k.description}`);
+    }
+  }
+  objectKinds.push("");
+  const kindsCore = [
+    "## Object def shapes",
+    "",
+    "The def-object passed to each factory. `?` = optional. `input` is keyed by",
+    "input name (`input.<type>(opts?)`); `stack` is `Statement[]` (`s.*`); `response`",
+    "is a `ResponseDef` (see **Responses** below). Object identity is `guid?` \u2014",
+    "omit it and it derives from `name` (set it to survive a rename).",
+    "",
+    "- `defineFunction({ name, guid?, description?, docs?, workspace?, input?, stack?, response?, tests? })`",
+    "- `query({ name, verb, apiGroup?, guid?, auth?, input?, stack?, response?, responseType?, apiEnabled?, disabled?, cache?, description?, docs?, tests?, example? })`",
+    '  - `verb`: `"GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD"` (required), UPPERCASE. Anything else \u2014 most often a lowercase `"post"` \u2014 makes `query()` THROW, because Xano does NOT reject it: it stores the verb as NULL, a null verb serves as GET, and the endpoint then answers on the wrong method while the one you meant 404s `Unable to locate request.`',
+    "  - `apiGroup`: an `apiGroup()` def handle (or its name) \u2014 binds by guid, stable across syncs. Raw numeric `apiGroupId?` is the escape hatch and wins if both given.",
+    '  - `auth`: `false` (no auth) or an auth-table id; `responseType`: `"standard" | "stream"` (default `standard`) \u2014 any other spelling THROWS, since Xano stores an unrecognized one as NULL and a null buffers as `standard`, so a misspelled stream quietly does not stream.',
+    '  - `name` is the endpoint PATH within the group. A `{param}` segment is a URL PATH PARAM bound to the input of the same name, and segments chain: `name: "blog/{slug}/review/{review_id}"` + `input: { slug: input.text(), review_id: input.int() }`. Read it with `inp("slug")` like any other input. Every `{param}` MUST have a matching input or `query()` THROWS \u2014 Xano treats an unbound marker as inert route text, so the endpoint would answer on the path and see nothing. A `{param}` need NOT be a whole segment (`"blog/post-{slug}"` routes fine), but its type must fit one segment (no object/list/json/file/geo/vector); there are no wildcards or patterns. `required: true` is NOT demanded (the engine\'s editor leaves path inputs unmarked). Inputs absent from the path are ordinary query-string/body params. Name charset is ONLY `A-Za-z0-9_-/{}`, max 200: a `.` (`"export.zip"`) is NOT rejected by Xano \u2014 it stores an EMPTY name that deploys clean then 404s forever, so `query()` THROWS. Use `"export_zip"` and set the extension in the response headers.',
+    '  - **Client recipe:** `q.getPath({ params: { slug: "hello" } })` \u2192 `/api:<canonical>/blog/hello` \u2014 never interpolate by hand. `getPath` percent-encodes each value (so `?`/`#`/spaces stay in their segment) and throws on what encoding cannot contain: a `/`, and a value that IS `.`/`..` (a URL parser drops those before routing \u2014 `%2e` counts \u2014 addressing a different endpoint). The keys are typed from the literal `name`, so a typo is a compile error. The HANDLE\'s `q.toSearchParams(input)` drops path params for a GET; the free `query.toSearchParams(input)` has no view of the route and keeps every key.',
+    "- `apiGroup({ name, guid?, canonical?, description?, docs?, swagger?, apiGroupEnabled?, documentation?, cors? })` \u2014 a query container; register it and bind queries to it via their `apiGroup`.",
+    "  - `cors?`: `{ mode?, allowOrigins?: string[], allowHeaders?: string[], allowCredentials?, maxAge?, allowMethods?: { get?, post?, put?, patch?, delete?, head? } }`.",
+    '    - `mode?`: `"default"` (the default) | `"custom"` | `"disabled"`, lowercase \u2014 a fourth value THROWS at export (`apiGroup()` itself does not check), because Xano neither rejects nor blanks it: it DROPS THE WHOLE API GROUP on import, so the deploy succeeds and every query in the group 404s. \u26A0 Every OTHER field applies only under `"custom"`: `"default"` serves a FIXED permissive policy (any origin, `allow-headers: *`, `allow-credentials: true`, `max-age: 86400`) and ignores the block, so setting `maxAge`/`allowCredentials`/`allowHeaders` alone changes nothing. `"disabled"` sends no CORS headers at all, so every browser call fails.',
+    '    - \u26A0 Under `"custom"`, `allowOrigins` is matched as EXACT strings (scheme+host+port, no wildcard or subdomain expansion) and `"*"` is compared as a literal origin \u2014 it matches NOTHING. An unmatched origin gets no `access-control-*` headers at all, so the call fails in the browser on a missing `access-control-allow-origin` while export, deploy and the preflight all look fine. Name each origin, or use `mode: "default"` for any-origin. `allowMethods` gates the REAL response too: a verb left off gets no CORS headers back even though its preflight passes. Export warns on an empty origin list, a `"*"` entry, and a policy with no method enabled.',
+    '- `defineFunction`/`query`/`apiGroup` above cover the queries+tables core; the four below are the "reach past that" primitives (tasks, workflow tests, middleware, tools). Agents and MCP servers are the same family and live in `llms/kinds-agent-mcp.md`. Same envelope conventions (`guid?`, `description?`, `docs?`, `tags?`, `history?`) unless noted.',
+    "- `task({ name, guid?, description?, docs?, datasource?, active?, tags?, history?, schedule?, stack?, middleware? })` \u2014 a scheduled background job (function-like `stack`, no `input`/`response`).",
+    '  - `schedule?`: a `ScheduleDef[]` (NOT a single object) \u2014 `{ startsOn, freq?, repeatEnabled?, endsOn?, endsEnabled? }`. `startsOn`/`endsOn` are **timestamp strings** validated at encode time \u2014 `"2026-01-01T00:00:00Z"`, or the space-separated `"2026-01-01 00:00:00+0000"` a pulled workspace carries \u2014 never epoch numbers, and never zoneless; `freq` is the repeat interval **in seconds** (default `86400` = daily); `endsOn` present \u21D2 the schedule has an end. `endsEnabled?` defaults to that and is recovery-only \u2014 state it to reproduce a stored schedule that remembers an end date with the gate OFF. Fires on an ephemeral; does NOT fire in the sandbox (see Gotchas).',
+    '- `workflowTest({ name, guid?, description?, docs?, datasource?, active?, tags?, stack? })` \u2014 an end-to-end test. NO `input`/`response`: `.call` something with an `as`, then assert on that var \u2014 `s.function.call({ fn, input, as: "r" })`, `s.expect.to_equal({ expr: ref("r"), value: c.int(42) })`. `s.expect.*` belongs here \u2014 it is not inert elsewhere (a failure 500s the request), so treat one in a query/function/task as a mistake to remove. `active?` defaults `true`; chain tests with `s.workflow_test.call({ workflowTest: <def handle> })`.',
+    '  - `datasource?`: **the trap.** Default `""` is an EMPTY datasource (recommended), not "no datasource". Any non-empty name makes the engine CLONE it before EVERY run \u2014 against production-sized data, slow enough to fail the run. `"live"` warns at compile time; other names don\'t.',
+    "- `middleware({ name, guid?, description?, docs?, resultStrategy?, exceptionPolicy?, tags?, history?, input?, stack?, response?, responseShape?, tests? })` \u2014 a pre/post interceptor (function-like `stack`); attach it via a host's `middleware: { pre, post }`. \u26A0 `input` ENCODES but an ATTACHED middleware never has it bound \u2014 the host request binds its own inputs, so `inp()` inside pre/post fails at runtime with `Unable to locate input` and a declared default does not stand in (`export()` warns). Read the request body with `s.util.get_all_input` instead; it yields a `{ type, vars }` envelope. `s.middleware.call` is the one path that DOES bind the declared map.",
+    '  - `resultStrategy?`: `"merge" | "replace"` (default `merge`) \u2014 how the middleware `response` folds into the host\'s.',
+    '  - `exceptionPolicy?`: `"silent" | "rethrow" | "critical"` (default `"rethrow"` \u2014 a throw ABORTS the request and surfaces the authored error/status, which is what a guard wants). `"silent"` swallows the throw and lets the request through, so a guard set to it is NOT enforced \u2014 use it only for advisory middleware. `"critical"` is `"rethrow"` plus skipping the `post` chain.',
+    "- `tool({ name, guid?, description?, instructions?, docs?, enabled?, tags?, history?, input?, stack?, response?, responseShape?, middleware? })` \u2014 a function-like operation (`input`/`stack`/`response`) that a toolset (MCP server or agent) exposes. Register it, then reference it from a toolset's `tools`.",
+    "### Responses",
+    "",
+    "The `response?` field (on functions, queries, tools, middleware, and",
+    "response-bearing triggers) maps to the stored `result[]`:",
+    "",
+    "- `ResponseDef = Value | Record<string, Value>`.",
+    '- A single `Value` \u2192 one unnamed result item: `response: ref("rows")`.',
+    '- A record \u2192 one named item per key: `response: { user: ref("u"), token: ref("t") }`.',
+    "- Omitted \u2192 empty `result[]` (no response body).",
+    "",
+    "### Expressions (`expr`)",
+    "",
+    "`expr(left, op, right)` builds the comparison used by every condition/`where`",
+    "surface \u2014 `s.conditional`/`s.while` `when` (incl. each `elif` branch), and",
+    "`db.query` `where`/`additionalWhere` (and the search triggers) \u2014 one shared tree.",
+    "",
+    "- `op`: `=`, `!=`, `>`, `<`, `>=`, `<=` (JS aliases `==` `===` `!==` are accepted and normalized).",
+    '- `left`/`right` are `Value`s \u2014 `col("x")` (a table column), `ref`, `inp`, `auth(...)`, or `c.*`.',
+    "- For the full operator set (`in`/`like`/`ilike`/`between`/`contains`/`overlaps`/`@>`/`~`/`search`/\u2026)",
+    "  use `cmp(left, op, right, { ignoreEmpty? })`; compose nested boolean logic with `and(...)`/`or(...)`.",
+    "- \u26A0 The wider `cmp` operators are DATABASE-only (`where`, table view filter, db trigger",
+    "  `search`). A RUNTIME condition \u2014 `s.conditional`/`elif`, `s.while`, `s.precondition`,",
+    "  `array.*` `if` \u2014 takes the `expr` set only; the rest are refused at build time because",
+    "  deployed they fail the request with `Invalid op: <op>` on that branch, usually a guard.",
+    '  Spell membership out: `or(expr(x, "=", a), expr(x, "=", b))`.',
+    "- A condition/`where` accepts a single `expr(...)`/`cmp(...)`, an `and()`/`or()` group, an array of",
+    "  those (ANDed), or (for `where`) a raw `Value`. `s.conditional`/`s.while`/`s.switch`, `db.query`,",
+    "  `precondition`, and the `array.*` predicates all take the same TREE shape (operators per above).",
+    "- \u26A0 `mixed(a, { or: b }, { and: c })` reproduces a container whose terms do NOT all join the",
+    "  same way \u2014 the editor allows it, so pulled workspaces contain it. **Do not author it.** The",
+    "  stored form does not record the grouping, and the two places it can appear disagree: a",
+    "  branch (`s.conditional`/`s.while`/`precondition`) folds terms strictly left to right, so",
+    "  `a OR b AND c` is `(a OR b) AND c`, while a `db.query` filter applies the engine's",
+    "  AND-before-OR precedence and selects `a OR (b AND c)`. Write `and(or(a, b), c)` or",
+    "  `or(a, and(b, c))` \u2014 each says one reading in every context. Pulls report these as",
+    "  `ambiguous-condition`.",
+    "- A **filtered** operand (`withFilters(...)`) works inline in any condition/`where` (conditional,",
+    '  while, `db.query`/addon, \u2026) \u2014 e.g. `cmp(withFilters(col("title"), fl.trim()), "=", inp("q"))`.',
+    '- e.g. `db.query({ table: posts, where: expr(col("author"), "=", auth("id")), as: "rows" })`.',
+    ""
+  ];
+  const kindsAgentMcp = [
+    "- `mcpServer({ name, guid?, description?, instructions?, docs?, enabled?, canonical?, spec?, tags?, history?, tools?, llm?, output? })` \u2014 an MCP toolset. `llm?`/`output?` are the same blocks `agent()` takes and are usually absent: an MCP server and an agent are ONE stored object distinguished by `type`, so a server that carries LLM settings can say so. Returns a handle with `getPath()`/`getUrl(baseUrl)` for the Streamable-HTTP endpoint \u2014 `getUrl` is NOT idempotent, a `baseUrl` already carrying an `/x2/mcp/<\u2026>/stream` path (an earlier result) THROWS, so resolve ONCE from the instance base URL. Fires on an ephemeral; does NOT fire in the sandbox (see Gotchas).",
+    "  - `tools?`: a `ToolsetToolEntry[]`. Pass the `tool()` HANDLES directly (`tools: [saveNote]`), like every other collection in the SDK; use the `{ tool, enabled?, auth? }` wrapper only when a tool needs `enabled: false` or per-tool `auth`. `auth` names an auth **table** (a `table({ auth: true })` handle or its name) \u2014 Xano's ONLY MCP auth surface (per-tool; there is no server-level gate). An entry that names no tool (no handle, no `id`) THROWS at export rather than emitting the `id: 0` null reference it used to; a deliberate raw `id: 0` warns and is carried through, so a pulled workspace still round-trips.",
+    "- `agent({ name, guid?, description?, docs?, enabled?, canonical?, tags?, history?, llm, tools?, output? })` \u2014 an LLM orchestrator. No top-level `instructions`/`prompt`/`spec` \u2014 the prompt lives under `llm`. Invoke from a stack with `s.ai.agent.run({ agent, args })`.",
+    '  - `llm` (REQUIRED): typed provider settings, a discriminated union on `type` (`"xano-free" | "anthropic" | "openai" | "google-genai"`). Shared fields: `systemPrompt?`, `maxSteps?` (default `5`), and `prompt?` XOR `messages?` (genuinely exclusive: both is a type error and throws \u2014 the engine stores ONE `prompt_type`, so one would be dropped); plus provider fields (`apiKey?`, `model?`, `temperature?`, `reasoningEffort?`, \u2026). String fields accept Twig placeholders \u2014 `{{ $args.x }}` for run inputs (the `args` of `s.ai.agent.run`), `{{ $env.NAME }}` for env vars.',
+    "  - `tools?`: same `ToolsetToolEntry[]` as `mcpServer` \u2014 bare `tool()` handles, or a `{ tool, enabled?, auth? }` wrapper when one needs `enabled`/`auth`.",
+    '  - `output?`: `{ schema: Record<string, input.*>, enabled? }` \u2014 structured-output schema. `schema` is a named-field record authored with the `input.*` catalog, exactly like a `defineFunction`/`query` `input:` map (the stored `structuredOutputsSchema` is the same wire shape as function inputs). e.g. `output: { schema: { priority: input.enum(["low","high"]), summary: input.text() } }`. When you pass the agent *handle* to `s.ai.agent.run({ agent })`, `.result` is typed straight from this schema \u2014 no `resultShape` witness needed (the shape is declared once). `resultShape` remains only to override that, or to type an agent referenced by bare name.',
+    '  - **Run + read recipe (`s.ai.agent.run`):** bind the run to a var (`s.ai.agent.run({ agent, args, as: "run" })`) \u2014 it produces a rich envelope, and the completion is at **`.result`**. Read one structured field with a dotted ref (`response: ref("run.result.priority")`) or the whole completion (`ref("run.result")`, typed from `output.schema`); persist it in a later step the same way (`s.set_var({ name, value: ref("run.result.summary") })`). `args` is a plain object of run inputs (`{ topic: inp("topic") }` \u2014 raw literals are fine, e.g. `{ max_steps: 3 }`) surfaced to the agent as `{{ $args.topic }}`. Tool-call / per-step data (when tools ran) rides `.toolCalls` / `.steps` on the same envelope \u2014 both optional, absent or empty when no tools executed.'
+  ];
+  const kindsRealtime = [
+    "- **Realtime** \u2014 the only three-level chain: `realtimeServer` owns `realtimeChannel`s, which own `realtimeMessage` handlers. Pass the HANDLE, not a name (a channel path is unique only within its server).",
+    "  - `realtimeServer({ name, guid?, description?, enabled?, canonical?, tags?, history? })` \u2014 the container.",
+    "    - `enabled` defaults to **false** \u2014 the one `enabled` in the SDK that does.",
+    "    - An enabled server with no active channel still refuses the handshake.",
+    "  - `realtimeChannel({ name, server, guid?, description?, active?, input?, anonymousClients?, presence?, publish?, conversation?, delivery?, rateLimit?, tags?, history? })`",
+    '    - `name` is a PATH (`"lobby"`, `"rooms/{room_id}"`); `input` types its `{param}` segments, NOT the payload. Every `{param}` MUST have a matching input, and that input must be a SCALAR and not a list (`json`/`object`/`array: true` have no URL form), or `realtimeChannel()` THROWS. `required: true` is NOT checked and is not needed \u2014 segment counts must match, so the segment is always present at join. Name charset as query (`A-Za-z0-9_-/{}`, max 200), and so is `tool`; `realtimeMessage` is NARROWER \u2014 no `/` or `{}`.',
+    "    - Matching is STRICT: a literal segment beats a param (`rooms/lobby` and `rooms/{room_id}` coexist); segment counts must be EQUAL (`rooms/{room_id}` does NOT match `rooms/42/edit`); literals are CASE-SENSITIVE; an empty segment is REJECTED, not collapsed (a leading/trailing/doubled `/` matches nothing). `getChannel()` throws on an empty or slash-bearing param for that reason.",
+    "    - An INACTIVE channel reports the same error as a nonexistent one \u2014 deactivating leaks nothing.",
+    "    - `anonymousClients` is gated TWICE: the server admits the connection, then the channel admits the join. Setting it here alone is not enough.",
+    '    - `publish?: { who?: "nobody"|"anyone"|"authenticated", direct? }` \u2014 `who` defaults to `nobody`: nobody can publish until you set it. `direct` (default false) lets a client address ANOTHER CLIENT via a frame\'s `options.socketId`, and is checked BEFORE `who`.',
+    "    - `conversation?: { enabled?, limit?, ttl? }` \u2014 the client-visible TRANSCRIPT replayed to a joiner (distinct from `history`, which is execution history). \u26A0 `limit` DEFAULTS TO 0 AND 0 MEANS OFF: `{ enabled: true }` alone records nothing and replays nothing, silently. `ttl` is an IDLE expiry of the WHOLE transcript, refreshed by every write (an active channel never ages out; a silent one loses all of it at once) \u2014 NOT a per-message age cap.",
+    '    - `delivery?: { guarantee?: "at_most_once"|"at_least_once", perRecipient? }` \u2014 `perRecipient` is independent of the guarantee, is a NO-OP unless the channel declares a `deliver` trigger, and costs a stack PER RECIPIENT PER MESSAGE. Per-viewer redaction needs BOTH HALVES \u2014 this flag AND an active `deliver` trigger bound to the channel \u2014 and with either missing the payload is delivered UNCHANGED to everyone; `export()` warns on each half alone.',
+    "    - `rateLimit?: { messagesPerMinute? }` \u2014 0 = unlimited, checked BEFORE the handler runs. A COST guardrail, not a security control: an anonymous client is bucketed per CONNECTION (reconnecting resets it), and it fails OPEN when its store is down.",
+    "  - `realtimeMessage({ name, channel, server?, guid?, description?, active?, auth?, deliverTo?, input?, middleware?, stack?, response?, responseShape?, history?, disabled?, tags? })` \u2014 the invocable unit (the realtime analogue of a query).",
+    "    - `input` types the message PAYLOAD. `server` is required only when `channel` is a bare path.",
+    '    - `deliverTo?`: `"channel"` (default) | `"sender"` | `"others"` | `"explicit"`. \u26A0 `"explicit"` still delivers to NOBODY \u2014 nothing selects recipients from inside a handler, and `s.realtime.publish` (which originates an event INTO a channel) is not a substitute.',
+    '    - Only `"channel"`/`"others"` fan out AND are written to the `conversation` transcript \u2014 a `"sender"` response is invisible to every future joiner.',
+    '  - **Both input surfaces read as ordinary inputs:** `inp("body")` for a payload field, `inp("room_id")` for the channel\'s `{room_id}`. No session lookup, no frame parsing.',
+    "    - A path param is bound ONCE at join and read from the connection thereafter, never from the frame \u2014 a sender cannot claim a room it did not join. The same values reach a channel `join`/`leave` trigger's stack.",
+    "  - `s.realtime.get_session({ as })` \u2014 the CALLER's realtime session for the current frame. FLAT shape:",
+    '    - `authenticated` bool \xB7 `client_id` text (the AUTHED ROW ID as text, `""` anonymous) \xB7 `dbo_id` int (the auth TABLE\'s id \u2014 NOT the user\'s row id; `0` anonymous \u2014 to look the caller up use `client_id`. `dbo_id` is an int in the same position and typechecks, so a gate that keys on it finds no user and refuses EVERYONE) \xB7 `socket_id` int (transport id) \xB7 `channel` text (resolved path, `""` in a server trigger) \xB7 `params` object (bound path params, `{}` when none \u2014 `ref("session.params.room_id")`) \xB7 `extras` object \xB7 `opened_at` decimal.',
+    "    - Works in a realtime MESSAGE stack and in CHANNEL and SERVER trigger stacks; off that path it degrades to an anonymous session.",
+    '    - For a path param prefer `inp("room_id")`. Reach for the session when you need the CONNECTION (identity/extras) \u2014 "who is this sender" on an anonymous-client channel.',
+    "    - \u26A0 THREE UNRELATED THINGS ARE CALLED A CLIENT ID: `session.client_id` (app-facing identity), `session.socket_id` (transport), and a frame's `options.client_id` (the at_least_once CURSOR handle). Conflating the first and last breaks at_least_once for anonymous clients.",
+    "  - `s.realtime.publish({ server, channel, data, message?, authTable?, authId? })` \u2014 the PUSH direction: originate a server-authored event onto a channel from ANY stack, no client frame first.",
+    "    - `server` is the handle or its NAME (resolved by name, not guid); `channel` is the FILLED-IN path (`channel.getChannel({ room_id: 42 })`), never the template \u2014 a constant still carrying `{param}` THROWS at author time, and a constant `server`/`channel` naming nothing this workspace registers WARNS at export.",
+    '    - A PER-ROW path whose id is only known at runtime is built as a value, not with `getChannel()` (which needs the id at author time): `withFilters(c.text("rooms/"), fl.concat(ref("room.id")))`, or `s.set_var` + `s.text.prepend`. A computed `channel`/`server` \u2014 a `ref`/`inp`, or a constant carrying a filter chain \u2014 is left alone by the export check.',
+    "    - DELIVERY-ONLY \u2014 fanned out as-is; does NOT invoke a `realtimeMessage()` handler even when `message` names one (a channel `deliver` trigger still runs).",
+    "    - SERVER-AUTHORITATIVE \u2014 bypasses `publish.who`, which governs CLIENTS. Authorize in your own stack.",
+    "    - \u26A0 FAIL-SOFT \u2014 a missing/disabled server or dead bus is swallowed engine-side, so a mis-targeted publish is SILENT with no result to check.",
+    "    - `authTable`/`authId` are ASSERTED attribution on the frame \u2014 not a credential, nothing validates them.",
+    "  - **Client recipe (derive, never hardcode):**",
+    '    - `server.getUrl(baseUrl)` \u2192 `wss://<host>/ws/<canonical>` \u2014 accepts the `https://\u2026` instance base URL and normalizes the scheme. `channel.getChannel({ room_id: 42 })` \u2192 `"rooms/42"`, the path that goes in a frame\'s `channel` field. Both throw rather than guess. A canonical is minted by `xanots export <entry> --lock`.',
+    "    - Auth is a bearer token passed as the websocket SUBPROTOCOL: `new WebSocket(url, token)`. No token = an anonymous client, admitted only where `anonymousClients: true`.",
+    '    - Frames are JSON `{ action: "join"|"leave"|"broadcast"|"ack"|"ping"|"presence", channel, type?: <message name>, payload?, options?, id? }`. You must `join` before you may `broadcast`, and the server\'s context is ready only a moment after `open` \u2014 an immediate first frame is refused.',
+    "    - `options` is `{ socketId?, client_id?, channel? }` \u2014 `socketId` addresses another client directly (needs `publish.direct`), `client_id` is the at-least-once cursor handle, and `options.channel` WINS over a top-level `channel`.",
+    '    - \u26A0 KEEP THE SOCKET ALIVE: an idle connection is REAPED after ~10 minutes. A LISTEN-ONLY client (a feed or dashboard that joins and rarely publishes) MUST send `{ action: "ping" }` (answered `pong`) or any frame periodically or it silently drops.',
+    "    - Server frames: `join` (ack `{ joined: true, params }`, + `cursor`/`resumed` on at_least_once) \xB7 `message` \xB7 `replay` \xB7 `broadcast` \xB7 `presence_full`|`presence_join`|`presence_leave` \xB7 `conversation_start`|`conversation_end` (replayed frames flagged `conversation: true`) \xB7 `pong` \xB7 `ack` \xB7 `error`.",
+    "    - \u26A0 `broadcast` is a RECEIPT to the sender, not a delivery confirmation: `payload.delivered_local` counts recipients on the ANSWERING NODE ONLY, not the channel. It also carries `id` on at_least_once and `dropped: true` when the handler returned null.",
+    "    - `error` carries `payload.message`, plus `code`/`limit`/`retry_after` when rate limited. `rate_limited` is the ONLY code \u2014 do NOT switch on `code`.",
+    "    - An `error` is a per-frame refusal, NOT a disconnect \u2014 EXCEPT a failed handshake and a REFUSED `connect` trigger, which each send one and then CLOSE with code 4401.",
+    "  - **Tenant instances (isolated DB):** a tenant's realtime objects live in the TENANT's database, so BOTH halves of a client must name the tenant.",
+    "    - Socket: `server.getUrl(base, { tenant })` \u2192 `/ws/<tenant>:<canonical>`. \u26A0 A bare canonical on a tenant host resolves against the INSTANCE workspace instead.",
+    "    - That colon form is PECULIAR TO THE SOCKET. Every other tenant URL gives the tenant its OWN segment \u2014 the HTTP half of the same client is `https://<host>/tenant/<tenant>/api:<canonical>/\u2026`. NO request header is required for either.",
+    "    - Because the shapes differ, `getUrl` TRANSLATES a tenant base URL instead of concatenating: pass the `https://<host>/tenant/<name>` that `sandbox details` prints (and that deploy injects as `window.XANO_HOST`) and the tenant is LIFTED into the socket form. So `getUrl(window.XANO_HOST)` needs no `{ tenant }`, and a CONFLICTING `{ tenant }` alongside it throws.",
+    "    - \u26A0 `getUrl`/`socketUrl` are NOT idempotent \u2014 a `baseUrl` that already carries a `/ws/<\u2026>` path (an earlier result of either) THROWS. Resolve ONCE from the http(s) base; pass that result to `new WebSocket`, never back in as a base.",
+    "    - Still pass `{ tenant }` explicitly for a tenant on its OWN DOMAIN \u2014 the hostname carries it for HTTP, but there is nothing in the URL for the socket to lift.",
+    "    - \u26A0 Tokens are tenant-scoped (audience `<tenant>:<license>`, not the bare license), so one minted through the instance workspace is REJECTED by a tenant's realtime server \u2014 authenticate and dial through the same tenant.",
+    "  - **Presence frames** (a `presence: true` channel only):",
+    "    - `presence_full` carries `payload.members` \u2014 an ARRAY holding the WHOLE roster, including the receiving client. `presence_join`/`presence_leave` carry a single `payload.member`.",
+    "    - A member is `{ id, dbo_id, authenticated, extras, joined_at }`: `id` the auth row id as a string (`\"\"` anonymous), `dbo_id` the auth table's id (`0` anonymous), `extras` the connection's extras object, `joined_at` epoch SECONDS.",
+    "    - Render from `presence_full`, then apply the deltas. The roster counts MEMBERS, not connections (refcounted per identity \u2014 a second tab fires no second `presence_join`).",
+    "    - Join order: `join` ack \u2192 `presence_full` \u2192 (others get `presence_join`) \u2192 conversation replay \u2192 `replay` frames.",
+    '    - A joined client can re-request the snapshot any time with `{ action: "presence", channel }`, answered to the SENDER only. A socket that never joined is REFUSED \u2014 the roster is not readable without membership.',
+    "  - **Conversation frames \u2014 the transcript hydrates the client, so DO NOT build a hydration endpoint.**",
+    '    - On a `conversation` channel the replay is PUSHED automatically at join, unasked: `conversation_start` (`payload.count`) \u2192 the last `limit` messages, each a normal `action: "message"` frame carrying its ORIGINAL `type` and `payload` plus `conversation: true` and the original `ts` \u2192 `conversation_end`.',
+    "    - So the client needs NO fetch, no `GET /messages`, and no table read to paint the initial view. Render `message` frames identically either way; the backfill paints itself.",
+    "    - \u26A0 `{ enabled: true }` ALONE IS A NO-OP: `limit` defaults to 0, and 0 means RETAIN NONE (not retain everything), so the transcript is never written and never replayed, with no error. ALWAYS PASS `limit`.",
+    "    - The POST-HANDLER broadcast payload IS the stored transcript row \u2014 a handler must broadcast everything the UI needs to render a past message (author name, id, `created_at`). Nothing else is replayed.",
+    '    - Only `deliverTo` `"channel"`/`"others"` are RECORDED, so a `"sender"` response is invisible to every future joiner by construction.',
+    "    - The transcript is a capped ring (`limit`, `ttl`), not storage. Persist to a table only for durability, search, or reads BEYOND that window \u2014 never merely to hydrate a joiner.",
+    '  - **`delivery.guarantee: "at_least_once"` is a CLIENT CONTRACT, not just a channel setting.**',
+    '    - The client must ACK what it receives \u2014 `{ action: "ack", channel, id }`, confirmed by `{ action: "ack", channel, payload: { cursor } }`.',
+    "    - \u26A0 An ANONYMOUS client must ALSO send a durable `options.client_id` in its JOIN frame (once; later acks need not repeat it). WITHOUT one it has no cursor, its acks are SILENTLY IGNORED, and it degrades to at_most_once. An AUTHENTICATED client is keyed by identity and needs no `client_id`.",
+    "    - The missed gap arrives after join as `replay` frames, oldest-first, each with an `id` to ack.",
+    '    - DISTINCT from the conversation transcript: `conversation_*` is the SHARED "what was said before I arrived", `replay` is the PER-CLIENT "what I missed while disconnected". Both may be on.',
+    "    - How far back `replay` reaches is sized by `conversation.ttl` (here a REAL per-message age cut, and it BEATS `limit`), else `conversation.limit`, else 1000 \u2014 even on a channel with no transcript enabled.",
+    "  - **What a message handler RETURNS decides delivery, and the failure directions are NOT symmetric.**",
+    "    - A returned value fans out per `deliverTo` and becomes the transcript row.",
+    "    - Returning NULL delivers NOTHING \u2014 the supported way to veto a message (the sender is told `dropped: true`).",
+    "    - A payload REJECTED by the declared `input` also delivers nothing,; the detail goes ONLY to the sender.",
+    "    - \u26A0 But a handler that CRASHES FAILS OPEN: the sender's ORIGINAL, UNVALIDATED payload is broadcast to the channel unchanged. A handler doing redaction or authorization must NOT be the only thing between client input and subscribers.",
+    ""
+  ];
+  const triggers = [
+    "### Triggers",
+    "",
+    "**A trigger's `stack` is a callback \u2014 `stack: (t) => [...]`, not the plain",
+    "`stack: []` array that `defineFunction`/`query`/`task` use.** That's the one",
+    "shape that doesn't carry over from the other kinds: a trigger has no",
+    "user-declared `input`, so its inputs are **implied by type** (fixed by Xano,",
+    "not editable) and arrive through the typed **stack handle** `t` \u2014 you can't",
+    "reference them without it. (Response-bearing types take `response: (t) =>",
+    "ResponseDef` too.) `t` exposes exactly that trigger type's inputs; a wrong",
+    "name is a compile error, not a runtime surprise. The seven trigger types are",
+    "distinct root factories (not a namespace): `{tableTrigger, realtimeServerTrigger,",
+    "realtimeChannelTrigger, mcpServerTrigger, agentTrigger, workspaceTrigger,",
+    "errorTrigger}({ name, guid?, description?, active?, tags?, ... })`.",
+    "",
+    '- `tableTrigger({ name, table?, datasources?, actions?: {insert?,update?,delete?,truncate?}, stack })` \u2014 database/table trigger. `t.new` / `t.old` are the row **after** / **before** the change; `t.action` (`insert|update|delete|truncate`), `t.datasource`. Bind `table` to a `table()` handle and `t.new("col")` / `t.old("col")` are typed to that row (misspelled column = compile error). Nullability follows the enabled actions: insert \u2192 `old` is null, delete \u2192 `new` is null, update \u2192 both, truncate \u2192 neither. Config-only (no response).',
+    "- `realtimeServerTrigger({ name, realtimeServer, actions?: {connect?,disconnect?}, stack?, response?, responseShape? })` \u2014 realtime SERVER lifecycle (a client connecting to / disconnecting from the server, not a message). Inputs: `t.action` (`connect|disconnect`), `t.realtime_server`, `t.client`. Bind `realtimeServer` to a `realtimeServer()` handle (or its name). `connect` GATES the connection \u2014 a denial sends an `error` and CLOSES the socket with code 4401 before it is ever ready, so it is a real front door, not an observer; same return shape as a channel `join` (`{ allowed: c.bool(true) }` or any truthy value admits, EMPTY/FALSY DENIES \u2014 INCLUDING a gating trigger with NO `response`, which returns nothing and so refuses every client). A CRASH DENIES too \u2014 the transport seeds a deny and keeps it on a throw. Both failure modes lock the door, so plan for a self-inflicted LOCKOUT (an unguarded drill into a null `db.get` raises \u2192 everyone refused), not a breach. Gating is OPT-IN: a server with no `connect` trigger accepts every connection. `disconnect` is OBSERVATIONAL (return ignored, throws swallowed \u2014 cleanup must always complete). Both are SERVER-scoped, so `s.realtime.get_session` works but carries no channel path and no bound params.",
+    '- `realtimeChannelTrigger({ name, channel, actions?: {join?,leave?,deliver?}, stack?, response?, responseShape? })` \u2014 realtime CHANNEL lifecycle. Inputs: `t.action` (`join|leave|deliver`), `t.channel`, `t.client`. Bind `channel` to a `realtimeChannel()` handle \u2014 a bare path is NOT accepted (it is unique only within its server). The three actions have DIFFERENT postures, and the posture decides what the stack should return: `join` GATES the join (it runs BEFORE the client becomes a member, so a denial means it never sees a fan-out) \u2014 return `{ allowed: c.bool(true) }` (optional `reason` reaches the client) or any truthy value to admit, and an EMPTY OR FALSY RETURN DENIES, so a stack that just falls through \u2014 or a gating trigger with NO `response` \u2014 refuses everyone, and a CRASH DENIES too. That is the inverse of a normal message (a crashing message still delivers) and of `deliver` below (a gate that fails OPEN). `join`/`leave` bind the channel\'s typed path params as INPUTS, so `inp("room_id")` resolves and the gate decides per room; a SERVER connect/disconnect has no channel, the one place a path param cannot be read; `leave` is OBSERVATIONAL (return ignored, throws swallowed); `deliver` GATES delivery PER RECIPIENT \u2014 the per-viewer redaction tool and the most expensive action here (a stack per recipient per message), and it needs `delivery.perRecipient` on the channel to run at all \u2014 BOTH HALVES are required, so a `deliver` trigger on a channel without the flag NEVER RUNS and every subscriber receives the UNREDACTED payload (no error, no log line); `export()` warns on each half alone. **`deliver`\'s RETURN VALUES DO NOT READ LIKE A FILTER:** ONLY an explicit NULL drops the message for that recipient; an OBJECT replaces that recipient\'s payload; ANYTHING ELSE \u2014 INCLUDING `false`, `0`, `""` \u2014 DELIVERS IT UNCHANGED, as does a crash. So `return false` from a yes/no redaction check SENDS the message it was written to suppress \u2014 return null instead. The delivered payload arrives NESTED, so read `inp("payload").<field>`, and `t.client` is the SENDER while `s.realtime.get_session` describes the RECIPIENT this run is for.',
+    '- `mcpServerTrigger({ name, mcpServer, stack?, response?, responseShape? })` / `agentTrigger({ name, agent, stack?, response?, responseShape? })` \u2014 toolset connection. Bind with the `mcpServer()`/`agent()` def handle (or its name) \u2014 it resolves to the toolset guid at export. Raw numeric `objId` is the escape hatch, rarely right: ids are assigned at import, so a handle passed to `objId` is a type error, and binding nothing deploys a trigger that never fires. Inputs: `t.toolset` (`t.toolset("name")`), `t.tools`. Response-bearing; the default stack copies `toolset`/`tools` into vars and returns them.',
+    "- `workspaceTrigger({ name, actions?: {branch_live?,branch_merge?,branch_new?}, stack? })` \u2014 branch lifecycle. Inputs: `t.to_branch`, `t.from_branch`, `t.action`. Config-only.",
+    '- `errorTrigger({ name, stack? })` \u2014 error-signature trigger. Inputs: `t.event` (`new|regression|fixed`), `t.id`, `t.signature`, `t.error` (`t.error("code")`/`t.error("message")`), `t.caller`, `t.statement`, `t.actor`, `t.count`, `t.first_seen`, `t.last_seen`, `t.fixed_at`. Config-only.',
+    ""
+  ];
+  const filters = [];
+  const fields = [];
+  const values = [];
+  values.push("## Values", "");
+  for (const v of m.values.constructors) {
+    if (v.legacy) continue;
+    values.push(`- \`${v.name}${v.signature}\` \u2014 ${v.description}`);
+  }
+  values.push("", `Tags: ${m.values.tags.join(", ")}.`, "");
+  fields.push("## Fields", "");
+  fields.push(
+    "Author table columns + function/API inputs with the typed catalog: `f.<type>(opts?)`",
+    "for columns, `input.<type>(opts?)` for inputs. Common opts: `required`, `nullable`,",
+    "`default`, `description`.",
+    "**`nullable` defaults PER TYPE, matching the engine's own column-creation API**: `true`",
+    "for `f.vector`, `f.uuid`, every `f.geo.*` and every file type (`f.image`/`f.video`/",
+    "`f.audio`/`f.attachment`), `false` for everything else (text, int, decimal, bool, email,",
+    "enum, json, object, password, date, tableRef). Pass `nullable` explicitly to override \u2014",
+    "e.g. `f.geo.polygon({ nullable: false })`. This is why `f.vector(8)` deploys: the engine",
+    "turns an empty default into SQL NULL only for a nullable column, so a non-null vector",
+    "would reach PostgreSQL as `vector(8) not null default ''` and fail to create.",
+    "**`f.geo.*` values are `{ type, data }`, not GeoJSON.** The same shape goes in and comes",
+    'back: `{ type: "point", data: { lng, lat } }`, `{ type: "poly", data: [{ lng, lat }, \u2026] }`',
+    "\u2014 `type` is the engine's abbreviation, and a polygon ring is closed for you. Raw WKT text",
+    '(`c.text("POINT(1 2)")`) is accepted on write too, but a read never returns one.',
+    "`methods` is a bind-time validator/transform pipeline whose",
+    'valid names depend on the field type (below) \u2014 pass bare names (`"trim"`), the',
+    'colon-form with args (`"min:8"`), or `{ name, arg }` for anything not listed.',
+    "`f.json({children})` declares the nested shape stored INSIDE a json column \u2014 an ARRAY of",
+    "`{name, type, methods?, children?}`, order-significant, distinct from the `FieldMap` that",
+    "`f.object` takes positionally. Omit it for an unstructured json column.",
+    "`f.enum(values)`/`f.vector(size)`/`f.object(children)`/`f.tableRef(table)` take a",
+    "positional payload before opts \u2014 and still accept the standard `FieldOptions` after it",
+    "(`f.enum([])`/`input.enum([])` are accepted, because the engine stores an enum whose",
+    "options were never filled in \u2014 that is a pulled-workspace shape, not one to author; it",
+    "brands the column `never`, which `InferRow` surfaces at read time as `undefined` \u2014 so",
+    "code written against `never` is dead in a way `undefined` is not.)",
+    "(e.g. `f.tableRef(users, { required: true })` \u2014 only `min`/`max` are listed as tableRef",
+    "methods below, but `required`/`nullable`/`description`/\u2026 apply like any field.)",
+    "An **OPTIONAL foreign key wants a `0` sentinel, not `nullable: true`.** `f.tableRef` stores",
+    "an `int`, and a null in it is unqueryable: `null` is never a legal `fieldValue`/`id`, so",
+    "`s.db.get`/`edit`/`del` on that column answer HTTP 400 `Missing param: field_value` rather",
+    "than matching nothing. Declare `f.tableRef(users, { required: true, default: 0 })` for",
+    '"not set yet" \u2014 `s.db.get({ fieldName: "driver", fieldValue: c.int(0) })` matches no row and',
+    "binds `null`, which is the answer the null was reaching for. `export()` warns on a literal",
+    "`c.null()` in that slot.",
+    "An `f.vector(size)` column is SEARCHED through `s.db.query`'s `eval` pipeline, not through",
+    'any `SearchOp`: give the table `index: [{ type: "vector", fields: [{ name: "embedding", op:',
+    '"vector_cosine_ops" }] }]`, then rank with a distance filter + a sort on its alias (see',
+    "`s.db.query` \u2192 `eval`). Without that pairing the column stores and indexes but nothing",
+    "queries it.",
+    "`{ array: true }` makes any `f.*` scalar a **list column** \u2014 `f.text({ array: true })`",
+    "surfaces as `string[]` in `InferRow<typeof table>` (the column analogue of `input.list`).",
+    "A **column `default` must stay within the BMP** \u2014 a 4-byte character (codepoint > U+FFFF,",
+    "e.g. an emoji) is mangled into invalid UTF-8 by the engine's default pipeline and is rejected",
+    "at export rather than 500ing at deploy (Postgres `22021`); BMP defaults (accents, `\u20AC`, most",
+    "CJK) are fine, or put the value on an `input.<type>({ default })`, applied at runtime bind.",
+    "`input.*` mirrors `f.*` \u2014 every column type below is",
+    "a legal input (scalars, files `input.image/video/audio/attachment`, `input.geo.*`,",
+    "`input.vector(size)`, `input.tableRef(table)`, `input.object(children)`), plus",
+    "`input.dbLink(table)` is the odd one: ONE entry that EXPANDS into one input per",
+    'COLUMN of the linked table, so read them by column name (`inp("email")`), never by',
+    'the entry\'s own name. `hidden: ["created_at"]` drops columns from that expansion.',
+    "`input.list(element)` for arrays \u2014 wrap any element constructor, e.g.",
+    "`input.list(input.text())` or `input.list(input.object({ id: f.int() }))`. Prefer the",
+    "typed forms over `input.json()` when the shape is known.",
+    "**Typed inputs validate/coerce on bind, before your stack runs** \u2014 so reach for the",
+    "specific type instead of hand-rolling checks. `input.email({ required: true })` rejects a",
+    'malformed address with a 400 (and trims; add `methods: ["lower"]` to downcase) \u2014 no',
+    "`regex_matches` needed; `input.int`/`input.decimal`/`input.uuid`/`input.enum([...])`/`input.date`",
+    "likewise reject or coerce bad input at the boundary. Drop to `input.text` + `s.precondition`",
+    "only for rules no type expresses.",
+    "\u26A0 `input.url` is NOT one of them \u2014 there is no engine `url` type, so it stores as `text`",
+    "and validates NOTHING: a `javascript:`/`data:` URL type-checks, imports, and binds. It",
+    "names intent and carries the `text` methods, nothing more. When the value gets navigated",
+    "to, check the scheme in the stack. It is INPUT ONLY \u2014 there is no `f.url` column.",
+    '\u26A0 `s.precondition`\'s `error` must be a TAGGED value \u2014 `c.text("\u2026")`, not a bare string.',
+    'The engine falls back to the generic "Precondition failed." whenever it reads an empty or',
+    "non-scalar message, and a bare string lands there, so the client never sees your text. The",
+    "`error_type` \u2192 HTTP status mapping is correct either way; only the message is lost. The bare",
+    "form stays accepted so a pulled workspace round-trips, not as a spelling to choose.",
+    `\`error_type\` IS how a stack sets a response status: ${preconditionStatusLine()}.`,
+    "Normalizing transforms run on bind too \u2014 put `trim`/`lower`/`upper` on the input's `methods`",
+    'so `inp("name")` reads already-normalized; don\'t reroll `var $x = inp("name")|trim` in the stack.',
+    ""
+  );
+  for (const ft of m.fieldTypes) {
+    const stored = ft.stored !== ft.name.replace(/^geo\./, "") ? ` (stored \`${ft.stored}\`)` : "";
+    const methods = ft.methods.length ? ` \u2014 methods: ${ft.methods.join(", ")}` : "";
+    const ns = ft.inputOnly ? "input" : "f";
+    const only = ft.inputOnly ? " \u2014 INPUT ONLY (no `f.` form)" : "";
+    fields.push(`- \`${ns}.${ft.name}\`${stored}${methods}${only}`);
+  }
+  fields.push("");
+  filters.push("## Filters", "");
+  filters.push(
+    "Attach to a value with `withFilters(v, fl.name(...))` \u2014 the value `filters[]`",
+    "pipeline. Filters are passed spread (canonical); the array form",
+    "`withFilters(v, [fl.a(), fl.b()])` is also accepted. Every filter is typed:",
+    "the ones below carry named args, and the rest take NO arguments \u2014 call them",
+    "`fl.<name>()`, and passing an argument is a compile error.",
+    "A typed filter's declared argument list is an EXACT count, not a floor: passing more",
+    "than it lists THROWS, in the type and at runtime. The extra argument used to ride into",
+    "the filter's arg list, where the engine either ignores it or fails opaquely on a live",
+    'endpoint. `filter("name", \u2026)` is the untyped escape for a filter the catalog',
+    "under-declares. Seven declared filters are exceptions the engine really does take more from, so they",
+    "stay variadic: `concat` (trailing separator), `index_by` (trailing list flag), `get` (trailing variable",
+    "map), `array_merge` and `array_merge_recursive` (any number of arrays), `jwe_encode` and",
+    "`jwe_decode`. To send more than a zero-argument filter's `()` accepts, use the same",
+    '`filter("name", \u2026)` escape. A filter with NO declared list takes nothing and is emitted',
+    "`()` \u2014 except the variadic few listed under the catalog, which take arguments the",
+    "catalog never declared and so are not arity-checked at all.",
+    "A typed filter also accepts one object of NAMED arguments (`fl.add({ value: 1 })`); a key",
+    "the filter does not declare throws rather than being dropped.",
+    "A bare JS **scalar** \u2014 string, number or boolean \u2014 is accepted in ANY `fl.*` argument and",
+    'wrapped as the constant you would have written by hand (`fl.get("a.b", 0)` encodes',
+    'identically to `fl.get(c.text("a.b"), c.int(0))`). An object or array must still be built',
+    "with `c.obj`/`c.array`. The arg types below name each argument's ENGINE type, not the JS",
+    "type you may pass.",
+    "Read-modify-write a column from its current value with the pipeline: to increment",
+    "a counter you MUST `db.get` the row first, then pipe its bound value \u2014",
+    '`col("clicks")` does NOT resolve to the stored value inside a `db.edit` `row`',
+    "(it is `null`, so `fl.add(1)` computes `null + 1` and the engine aborts):",
+    '`s.db.get({ table, fieldValue, as: "current" })` then',
+    '`s.db.edit({ table, fieldValue, row: { clicks: withFilters(ref("current.clicks"), fl.add(c.int(1))) } })`.',
+    "\u26A0 This read-modify-write is NOT atomic \u2014 two concurrent writers can both read the",
+    "same value and one increment is lost. There is no dedicated atomic-increment",
+    "statement, and one CANNOT be synthesized in the SDK (it would compile to this same",
+    "`get` + `edit` pair). For a **concurrency-safe** counter, do the arithmetic in the",
+    "database with a single `s.db.direct_query` UPDATE (`SET clicks = clicks + 1 WHERE \u2026`),",
+    "which the DB applies atomically. Reserve the pipeline form for low-contention counters",
+    "where a rare lost update is acceptable.",
+    "\u26A0 `direct_query` needs the table's PHYSICAL Postgres name, which the typed surface",
+    "does NOT expose: the engine derives a physical name from workspace + table ids (of the",
+    "form `x<workspace_id>_<table_id>`, e.g. `x6_203970`), ids assigned at import \u2014 not knowable",
+    "from a `table()` def (identity is a name + guid, not the numeric id), and `sql_name`",
+    "persists empty. So the safe counter drops out of the typed surface: hardcode",
+    "the physical name after inspecting the deployed table. A typed atomic path needs an",
+    "engine change.",
+    ""
+  );
+  const argFilters = m.filters.filter((fl) => fl.args?.length);
+  for (const fl of argFilters) {
+    const sig = (fl.args ?? []).map((a) => {
+      const type = a.enum?.length ? a.enum.map((m2) => JSON.stringify(m2)).join("|") : a.type;
+      return `${a.name}${a.optional ? "?" : ""}: ${type}`;
+    }).join(", ");
+    const ret = fl.result ? `: ${fl.result}` : "";
+    const note = Object.hasOwn(FILTER_NOTES, fl.name) ? FILTER_NOTES[fl.name] : void 0;
+    filters.push(`- \`${fl.fl}(${sig})${ret}\`${note ? ` \u2014 ${note}` : ""}`);
+  }
+  const zeroArg = m.filters.filter((fl) => !fl.args?.length && !fl.variadic).map((fl) => fl.name);
+  const variadic = m.filters.filter((fl) => fl.variadic).map((fl) => fl.name);
+  filters.push(
+    "",
+    `Zero-argument filters \u2014 call as \`fl.<name>()\`; an argument is a compile error: ${zeroArg.join(", ")}.`,
+    "",
+    `Variadic filters \u2014 they take arguments, but no declared list, so the count is not checked: ${variadic.join(", ")}.`,
+    ""
+  );
+  const lambda = renderLambdaSection();
+  lines.push("## Statements", "");
+  lines.push(
+    "Reachable through the `s` namespace: `s.<path>({...})`. Declarative statements",
+    "take one typed args object (field names match the engine); every surface's field",
+    "signature is in `llms/statements-catalog.md`. Specials (`[special]`) are",
+    "hand-authored: control flow is below, and the rest are in the `llms/statements-*`",
+    "topic files this doc's navigation names.",
+    "Wrap an `input`-routed `value` field in `ignored(...)` to store it but SKIP it at",
+    "  runtime \u2014 the engine records `<name>:ignore` and the parameter falls back to its",
+    "  default. Not the same as an empty value, and not the same as omitting the field",
+    "  (which stores no entry at all). Mostly seen on a pulled workspace. A field written",
+    "  into `context` instead (the `s.math.*`/`s.text.append` mutation family) has no slot",
+    "  for the flag and THROWS rather than dropping it.",
+    "Fields marked `value` take a `Value` (`c.*`/`ref`/`inp`); `comparison` takes an",
+    "`expr(...)`. A `\u2192 as: <type>` suffix names what the statement's `as:` output var",
+    "holds (curated, not exhaustive \u2014 absence means read the `[output]` flag and prose).",
+    ""
+  );
+  lines.push(
+    "### Specials \u2014 authored signatures",
+    "",
+    "Control flow & blocks (each nests a sub-stack; block specials name it `body`):",
+    "",
+    "- `s.set_var(name, value)` \xB7 `s.update_var(name, value)` \xB7 `s.return(value)` \xB7 `s.comment(text)` \u2014 positional.",
+    '- **Every** statement takes `disabled?`/`description?` \u2014 annotations on the stack item, not args: `disabled: true` is Xano\'s "disable step" (kept in the stack, skipped at runtime), `description` the note beside it. Inline on object-arg factories; a trailing object on the positional ones (`s.set_var("x", v, { disabled: true })`).',
+    '- **Statements with an `as`** also take `asFilters?` \u2014 `fl.*` filters on the RESULT as it binds, in order, same slot as `disabled`: `s.set_var("x", v, { asFilters: [fl.trim(), fl.lower()] })`. Saves a follow-up `set_var`. Throws without an `as`. The bound variable is RETYPED by the chain (`db.query` + `[fl.count()]` \u2192 `number`); filters whose result the engine declares as `any` (`get`, `set`, `json_decode`, \u2026) fold to `unknown`.',
+    "- `s.conditional({ when, then, elif?, else? })` \u2014 if/elif/else. `when` is a condition (`expr`/`cmp`/`and`/`or`); `elif` is an ordered `[{ when, then }]` (each an else-if branch); `then`/`else` are `Statement[]`.",
+    "- `s.for({ as, count, body })` \u2014 **count-bounded** loop (`as` is the index), NOT from/to.",
+    "- `s.foreach({ as, list, body })` \u2014 iterate `list`; `as` is the current item.",
+    "- `s.while({ when, body })` \u2014 `when` is a condition (`expr`/`cmp`/`and`/`or`).",
+    "- `s.switch({ on, cases: [{ when, body, break? }], default? })` \u2014 multi-way branch on a subject `Value` `on`; each `case`'s `when` is a literal `Value` matched against `on` (NOT a comparison \u2014 use `s.conditional` for `<`/`>`/ranges). \u26A0 **Omitting `break: true` FALLS THROUGH** \u2014 the matched case also runs every LATER case body. Type-checks clean; only `export --strict` catches it.",
+    "- `s.try_catch({ try, catch?, finally? })` \u2014 three `Statement[]` blocks.",
+    "- `s.group(body)` / `s.util.post_process(body)` \u2014 take a `Statement[]` **positionally**.",
+    "- `s.foreach_break()` / `s.foreach_continue()` / `s.foreach_remove()` \u2014 nullary loop control.",
+    "- `s.expect.to_throw({ body, exception? })` \u2014 `body` is the statements expected to raise.",
+    ""
+  );
+  const stmtData = [
+    "Array blocks (an `if`/`transform` is applied per item):",
+    "",
+    '- `s.array.map({ source, as?, transform? })` \u2014 `transform` is either a per-item `Value` expression (each item maps to that value) or a **record of values** (each item maps to an object with those keys), or a list of `{ key, value }` pairs, for a key computed per item or two rows sharing one. Use `ref("$this")` for the item and `ref("$index")` for its position. These are THIS statement\'s own bindings, in a value expression \u2014 not the JavaScript lambda contract (see **Lambda bodies**), which binds a different set per surface and is written with `lam.fn`.',
+    "- `s.array.union({ source, with?, as?, transform? })` \u2014 set-union two arrays.",
+    "",
+    "DB reads/writes (`table` is a def handle or name; `fieldName` defaults to the",
+    "primary key `id`):",
+    "",
+    "- `s.db.get({ table, fieldName?, fieldValue, lock?, output?, as? })` \u2014 one row by field match; `output` restricts returned columns (and overrides column visibility \u2014 it can pull `internal` columns like a password hash).",
+    "- `s.db.get_by_id({ table, id, output?, addon?, tableAlias?, as? })` \u2014 get by primary key. Takes `id`, NOT `fieldName`/`fieldValue`; binds the row or `null` like `db.get`. Both spellings are live in pulled workspaces.",
+    "- `s.db.has({ table, fieldName?, fieldValue, as? })` \u2014 existence test.",
+    "- `s.db.del({ table, fieldName?, fieldValue, as? })` \u2014 delete by field match.",
+    "- `s.db.add({ table, row?, data?, output?, as? })` \u2014 insert; `row` is a partial keyed by column.",
+    '  - A row CELL takes a tagged `Value`, a nested object of sub-keys, or a bare JS literal typed against that column: `row: { is_hidden: true, notes: "\u2026" }` encodes exactly as `{ is_hidden: c.bool(true), notes: c.text("\u2026") }`. The tag comes from the COLUMN, not the literal \u2014 `10` on an `f.decimal()` column is `const:decimal`, not `const:int` \u2014 so a literal contradicting its column is a compile error on a `f.*`-schema table (`{ is_hidden: "yes" }` on an `f.bool()` column) and throws at encode on a raw-`ColumnDef[]` one. An `f.enum()` column keeps its member union. A column with no literal form \u2014 obj/json/list/geo/vector/file \u2014 still needs `c.obj`/`c.array`.',
+    "  - `null` is accepted on EVERY column, including ones that refuse every other literal, and encodes `const:null` \u2014 a write OF null, not the same as omitting the key (omitted takes the column's type default on `add`: `[]` for a list, `{}` for obj/json, else `null`; on `edit` it is left untouched). A column's `nullable` is not consulted; the engine refuses a null it forbids.",
+    "  - An `f.password()` cell takes the PLAINTEXT \u2014 the column hashes on write, so a pre-hashed value, or a hashing filter on the cell, stores a hash of a hash that `security.check_password` can never match.",
+    "- `s.db.edit({ table, fieldName?, fieldValue, row?, data?, output?, as? })` \u2014 update by field match.",
+    "- `s.db.patch({ table, fieldName?, fieldValue, data, output?, as? })` \u2014 merge a partial (`data` is an object value).",
+    "  On these three, `output` restricts the columns of the RETURNED row only \u2014 it does not change",
+    "  what is written. Not offered on `db.del`/`db.has` (their result is a scalar) or on",
+    "  `db.add_or_edit` (no output envelope).",
+    "- `s.db.add_or_edit({ table, fieldName?, fieldValue, row?, data?, as? })` \u2014 upsert.",
+    "- `s.db.query({ table, where?, additionalWhere?, bind?, sort?, paging?, external?, returnType?, distinct?, eval?, output?, lock?, addon?, as? })` \u2014 search.",
+    "  - `where` / `additionalWhere` \u2014 `expr(...)`, an `expr[]` (ANDed), or a raw `Value`. Rides `context.search`.",
+    "    - \u26A0 `ignoreEmpty` DROPS the predicate when the operand is empty \u2014 it does not match zero rows. On an `in` comparison an empty list therefore returns the UNFILTERED set, so never use it to scope rows to a permitted-id list: an empty list of permissions returns everything.",
+    "    - For the full operator set use `cmp(left, op, right, { ignoreEmpty? })` \u2014 `op`: `in`/`not in`/`like`/`ilike`/`between`/`contains`/`includes`/`overlaps`/`@>`/`~`/`search`/\u2026 plus the `expr` comparisons. Database-only \u2014 a runtime condition takes the `expr` set only.",
+    "    - Compose nested boolean logic with `and(...)` / `or(...)` groups (also available on `addon()` `where`).",
+    "    - An operand may be a bare value (`col`/`inp`/`ref`/`auth`/`c.*`) OR a **filtered** value (`withFilters(...)`) inline \u2014 the engine compiles the string and arithmetic filters (`trim`, `concat`, `upper`, `lower`, \u2026) into the SQL.",
+    "    - \u26A0 The REQUEST-TIME timestamp filters have no SQL form and kill the request with a bare fatal naming nothing: `epochms_transform`, `epochms_add_ms`, `epochms_add_secs`, `epochms_date`, `epochms_from_format`. For a relative cutoff use the SQL-side family instead (`epochms_add_day`, `epochms_sub_month`, `epochms_year`, \u2026) or compute it in an earlier `s.set_var` and `ref()` that. `export --strict` reports it; a bare `c.now()` operand is always fine.",
+    '  - `bind: [{ table, as?, join?, where? }]` \u2014 joins (`context.bind[]`). `join` defaults to `"inner"`. `as` defaults to the table name; two joins to the same table need distinct aliases.',
+    '    - \u26A0 In `where`/`sort`/`eval` a JOINED column takes a dotted path (`col("team_row.id")`); THIS query\'s own columns stay **bare** (`col("team")`). Qualifying your own by table name needs `tableAlias` (same rule as `aggregate`) \u2014 without it the engine reads the operand as text and 400s `ParseError: Invalid value for param` naming the OTHER operand, so it throws at export instead.',
+    '    - `bind: [{ table: team, as: "team_row", join: "left", where: expr(col("team"), "=", col("team_row.id")) }]`',
+    '  - `returnType` \u2014 `"list"` (default) | `"single"` | `"count"` | `"exists"` | `"stream"` | `"aggregate"`. Drives `context.return.type` AND the `InferResponse` shape: `count`\u2192`number`, `exists`\u2192`boolean`, `single`\u2192`Row|null`, `stream`\u2192`Row[]` (pageable, no envelope), `list`\u2192`Row[]`/envelope, `aggregate`\u2192rows keyed by the `aggregate.group`/`eval` aliases. \u26A0 A bare `count` of ZERO serializes as an EMPTY body, not `0` \u2014 a client parsing JSON gets a parse error on the one result it most needs to handle. Wrap it: `response: { count: ref("n") }`.',
+    '  - `eval: [{ name, as, filters? }]` \u2014 computed columns (`context.eval[]`). Each `as` grafts onto the row as an `unknown` key in `InferResponse`; shadowing a real column throws. Write `name` **bare** (`"embedding"`) \u2014 it is alias-qualified on emit exactly like `aggregate` (a bare eval name is `Unsupported param format` at runtime), and the statement declares the alias it used. An `as` alias is `sort`able in the SAME query.',
+    "    - An `eval`/`sort`/`where` filter pipeline compiles to **SQL**, so it resolves a DIFFERENT registry than `fl.*` (which runs in the request): the vector family, geo `distance`/`within`/`covers`, `search_rank`, the aggregators. Exported as `QUERY_EXPRESSION_FILTERS`/`VECTOR_FILTERS`.",
+    '    - **Vector similarity search** \u2014 the ONLY way to query an `f.vector` column (no `SearchOp` does distance). `eval: [{ name: "embedding", as: "distance", filters: [{ name: "vector_cos_distance", arg: [inp("q")] }] }]` + `sort: [{ sortBy: "distance", dir: "asc" }]` ranks in the DATABASE over the column\'s index. Match the filter to the index `op` (`vector_cos_distance`\u2194`vector_cosine_ops`, `vector_l2_distance`\u2194`vector_l2_ops`, `vector_l1_distance`\u2194`vector_l1_ops`, `vector_inner_product`\u2194`vector_ip_ops`); `vector_cos_similarity` is the inverse, so sort it `desc`. The same filter on a `where` operand cuts off BY distance instead of by row count.',
+    '  - `aggregate: { group?, eval?, sort?, paging? }` (with `returnType:"aggregate"`) builds `context.return.aggregate`. `group`/`eval` are `{ name, as, filters? }`, an aggregator like `sum`/`count` riding `filters`. Some aggregators resolve ONLY here, not in a runtime value pipeline: `count_distinct`, `median`, `to_list`/`to_distinct_list` (each with `_asc`/`_desc`), and `vector_distance`.',
+    '    - \u26A0 Write each `name` as a **bare** column (`"status"`). It is alias-qualified to `"<alias>.status"` on emit \u2014 the engine rejects an unqualified column in an aggregate with `Unsupported param format`. An already-dotted `name` (a `bind`ed/joined column) passes through.',
+    "    - The alias it qualifies WITH is `tableAlias` when you set one, otherwise the table's name \u2014 and the statement DECLARES that alias (`dbo.as`) so the qualified name resolves. Nothing to do by hand; a bare `name` is the form to write.",
+    '  - `sort: [{ sortBy: <col>, dir?: "asc"|"desc"|"rand" }]` and `paging: { page?, per_page?, offset?, totals?, metadata?, search?, sort? }` ride `context.return.list`.',
+    "    - \u26A0 `paging` with a page/per_page/offset field and `metadata` on (the DEFAULT) wraps the result in an envelope `{ items: Row[], curPage, nextPage, prevPage, offset, perPage, itemsReceived }` \u2014 plus `itemsTotal`/`pageTotal` when `totals: true` \u2014 instead of a bare `Row[]`. `InferResponse` reflects it. Pass `metadata: false` to keep the bare array.",
+    "    - Read `nextPage` (`number|null`) as the typed has-next signal.",
+    '    - **Input-bound paging:** `page`/`per_page`/`offset` also accept a `Value` (`inp("page")`), riding `context.simpleExternal` while the static block stays the engine gate (`enabled:true`). `paging.search`/`sort` are `Value` dynamic overrides.',
+    "    - A `search`/`sort`-only `paging` (no numeric field) does NOT paginate.",
+    "  - `external: { value, permissions? }` \u2014 the classic whole-config blob (forces the gate on). It falls back to input-bound `paging` when it resolves empty, so supplying both is valid.",
+    '  - `distinct` \u2014 `"auto"` (default) | `"yes"` | `"no"`, riding `context.return.<list|stream>.distinct`.',
+    "- `s.db.truncate({ table, reset?, as? })` \xB7 `s.db.schema({ table, path, as? })`.",
+    '- `s.db.direct_query({ sql, responseType?, args?, parser?, as? })` \u2014 `sql` is a **raw string** (not a `Value`); binds go in `args: Value[]`. `parser: "template_engine"` renders the body as a template first \u2014 how a query interpolates a column or table name a bound arg cannot carry; omit it for the default.',
+    "- `s.db.external.<engine>.direct_query({ sql, connectionString, responseType?, args?, parser?, as? })` \u2014 same shape against an EXTERNAL database; `<engine>` is `postgres`/`mysql`/`mssql`/`oracle`/`snowflake`. `connectionString` is a `Value` \u2014 reach for `env(...)`, not a literal \u2014 stored as `context.connection_string_flex`. A bare string stores the older `context.connection_string` instead (an env-var name unless it looks like a URL); each form round-trips as itself.",
+    "- `s.db.transaction({ body, as? })` \u2014 run a `Statement[]` atomically. `as` binds whatever the block returned.",
+    "- `s.db.bulk.add({ table, items, allowIdField?, as? })` / `s.db.bulk.update` / `s.db.bulk.patch` \u2014 `items` is an array `Value`.",
+    "  - \u26A0 `bulk.add` **drops `id` on every row unless `allowIdField: true`** (silently, next sequence value instead) \u2014 the opposite of `seed`, where `id` pins. Rows referenced by a foreign key need `allowIdField: true`; literal `items` carrying `id` without it throw. `bulk.update`/`patch` keep `id` (their match key).",
+    '  - \u26A0 **`bulk.update` is a whole-row REPLACE: every column an item OMITS is zeroed** (`""`/`0`/`null`), HTTP 200, no error \u2014 `{ id: 7, status: "done" }` blanks the rest of row 7. **Use `s.db.bulk.patch`** for the partial write "update these rows" means. `export()` warns on a STATIC `items` missing columns (`--strict` fails); a `ref`/`inp` `items` is uninspectable.',
+    "- `s.db.bulk.delete({ table, where?, allRows?, as? })` \u2014 deletes rows by a `context.search` filter. `where` is the same surface as `s.db.query` (`expr(...)`/`cmp(...)`, `and(...)`/`or(...)` groups, an array of those ANDed, or a raw `Value`) and encodes through the identical `{expression:[\u2026]}` search shape. \u26A0 A filter that constrains nothing deletes **every** row, so a missing or empty `where` **throws**: pass the filter, or `allRows: true` for a deliberate wipe (both together also throw). `allRows` emits the empty search the engine requires and returns the deleted count; reach for `s.db.truncate({ table, reset: true })` when the id sequence should restart too.",
+    ""
+  ];
+  const stmtRuntime = [
+    "Runtime behavior (what the `as:` output holds, and misses):",
+    "",
+    "- `db.get` binds **`null`** when no row matches (it does NOT throw) \u2014 so the output is `InferRow<typeof table> | null`; null-check it. On a hit it binds the **full row**. (`db.has` is the boolean existence test.)",
+    "- `db.edit` binds the **full, post-mutation row** (the freshly-written values, not the pre-edit ones). `db.add` binds the **full inserted row**, including the auto-assigned `id` and `created_at`. So `InferRow<typeof table>` is the right response type for those two. `db.del` **binds `null`** \u2014 the engine deletes the row and returns no value, so don't return the `as` var expecting the deleted row.",
+    "- Unlike `db.get`, `db.edit` and `db.del` **throw** `NotFound` (HTTP 404) when no row matches the field. `db.add` throws on a unique-constraint violation.",
+    "- **`InferResponse<typeof query>`** derives an endpoint's response type (read-side round trip, no codegen). It resolves object-literal responses to those keys; a `response: ref(\"x\")` returning a variable bound by a TOP-LEVEL db op on a `table()` resolves to that op's result:",
+    "  | statement | resolves to | on a miss |",
+    "  |---|---|---|",
+    "  | `db.add` / `db.edit` / `db.patch` / `db.add_or_edit` | `Row` (the full written row, non-nullable) | throws \u2014 `NotFound`/404 for `edit`/`patch`, a unique-constraint error for `add`; `add_or_edit` upserts and never misses |",
+    "  | `db.get` | `Row \\| null` | binds `null` rather than throwing |",
+    "  | `db.query` / `db.bulk.patch` | `Row[]` | \u2014 |",
+    "  | `db.has` | `boolean` | \u2014 |",
+    "  | `db.bulk.delete` | `number` (count) | \u2014 |",
+    "  | `db.del`, `db.bulk.add`/`bulk.update`, raw `direct_query` | `unknown` (the engine leaves them untyped) | \u2014 |",
+    '  - A `get`/`query` `output: [...]` selection narrows to a `Pick` (still `| null` for `get`). A dotted `ref("row.col")` into a `db.get` row projects that column carrying the `| null` (\u2192 `Col | null`).',
+    "  - A value reshaped by a filter/lambda, or a variable built by control flow / `set_var`, also resolves to `unknown`.",
+    '  - A CALL binds the TARGET\'s response type: `s.function.call`/`s.function.run`/`s.api.call`/`s.tool.call` given a def HANDLE brand their `as` with `InferResponse` of the target, so `ref("out.field")` types to that field. What the target resolves to is what propagates \u2014 declare `responseShape` on the TARGET to fix every caller at once. A target named by STRING has no def to read and stays `unknown`, as does an async `s.function.run` (it binds a job handle, not the result).',
+    '  - \u26A0 In an object-literal response the KEYS are always known, but a VALUE is typed only when it traces to a binding \u2014 a `ref`, or a `ref` under `withFilters`. A CONSTANT does not trace: `response: { success: c.bool(true), hello: c.text("hi") }` derives `{ success: unknown, hello: unknown }`, NOT `{ success: boolean, hello: string }`. Same for an `inp` outside a trace. Only a reference carries a type the derivation can follow. Declare `responseShape` when a client needs those keys typed.',
+    '  - A NESTED member resolves to any depth by these same rules, in either spelling \u2014 `{ user: obj({ id: ref("row.id") }) }` and the raw literal `{ user: { id: ref("row.id") } }` both derive `{ user: { id: Col | null } }`. A raw scalar member types itself (`{ count: 3 }` \u2192 `number`).',
+    "  - Runs on every response-bearing kind \u2014 `query`, `defineFunction`, `realtimeMessage`, `tool`, `middleware`, and the response-bearing triggers \u2014 each of which also accepts `responseShape`. A trigger builds its stack and response through CALLBACKS (`stack: (t) => [...]`), and the trace follows through them.",
+    "  - Close any `unknown` by declaring `responseShape` on the def (`responseShape: null as InferRow<typeof t> | null`) \u2014 the declaration ALWAYS overrides derivation. It is available on EVERY kind listed above, `query` included.",
+    "  - The shapes that never derive, and the one line that closes each: rows built in `s.lambda` (JS is opaque to the walk) \u2192 `responseShape: [] as Row[]`; a var assigned across `s.conditional`/`s.switch` branches \u2192 `responseShape` for the union you meant; a call whose target is named by STRING, or an async `s.function.run` \u2192 give the TARGET a `responseShape` (a handle then carries it) or declare it here. Reach for `responseShape` as the FIRST move on these, not after fighting the derivation.",
+    "  - \u26A0 A RUNTIME guard does not narrow the STATIC type. A `s.precondition` (or a conditional) proving a `db.get` row non-null leaves `InferResponse` at `Row | null`, because the walk reads the stack's shape and not its control flow \u2014 the `| null` is correct about the derivation and stale about your stack. Declare `responseShape` to drop it rather than asserting at every call site.",
+    '  - \u26A0 A `resultStrategy: "replace"` middleware attached `post` reshapes the endpoint\'s output at runtime, which the static walk cannot see. Declare `responseShape` when a post middleware rewrites the response.',
+    "  - \u26A0 **Spreading a `Statement[]` helper into a stack kills the whole walk.** The trace needs the stack's TUPLE type, so `...myHelper()` where the helper returns `Statement[]` widens it and EVERY `as` in that stack \u2014 including ones declared after the spread \u2014 stops resolving. The response then types as `StackTupleWidened`, whose name says so. Fix: return `statements(s.a(...), s.b(...))` from the helper (a const-generic identity export \u2014 the tuple survives the spread). A helper that builds its array in a LOOP cannot be a tuple; declare `responseShape` there.",
+    "- **Addons** enrich returned rows. `db.query`/`get`/`add`/`edit`/`patch` accept `addon: [{ addon, as, input?, output?, children? }]`; `db.add_or_edit`/`del`/`has`/`truncate` take no `addon`.",
+    '  - `addon` is the target (name or def handle). `as` is the destination on the row \u2014 a bare alias (`"_user"`) or a dotted `offset.alias`, authored relative to a row. Under a metadata paging envelope the `items[]` offset is prefixed automatically; writing it yourself is tolerated and not double-prefixed.',
+    "  - `input` maps addon inputs \u2014 bind a parent-row column with `out(col)`. `output` restricts addon columns. `children` nests addons.",
+    '  - An addon is a single table-bound db query, NOT a statement stack: `addon({ name, table, tableAlias?, where?, sort?, output: [cols], cardinality?: "single"|"list"|"count"|"exists"|"aggregate", group?, eval?, input?, context? })`, registered via `registerAddons([...])`.',
+    "    - `table` auto-fills the `context.dbo` binding. \u26A0 Never author `table: null` \u2014 that is a BROKEN table-less addon returning nothing; `codegen` emits it only for an already-broken pulled object.",
+    '    - `tableAlias` is its SQL alias (`context.dbo.as`), qualifying `where`/`sort` columns (`col("merchant.id")`).',
+    '    - `where`/`sort` take the same surface as `s.db.query` and encode `context.search`/`context.sort`. `where` is the predicate binding the addon to the parent row \u2014 `expr(col("id"), "=", inp("user_id"))`.',
+    '    - `cardinality` shapes the result (`context.return.type`, omitted for the `"list"` default). Rarer context (`eval`/`bind`/`lock`) stays raw `context` passthrough.',
+    "  - Attaching a typed `addon({ table, output })` handle merges its alias (the last `as` segment) onto the row in `InferResponse`: `{cols}` for `single`, `{cols}[]` for `list`, `number` for `count`, `boolean` for `exists`, and for `aggregate` an array keyed by the `group`/`eval` aliases (`unknown` values; `unknown` when neither is declared).",
+    "  - An attachment-level `output` narrows an object/array graft further. A bare-NAME reference grafts `unknown` \u2014 narrow it at the call site.",
+    "  - \u26A0 An alias that shadows an existing column on the queried table throws at build time; rename with a `_` prefix.",
+    "- **Middleware attachment** runs a reusable `middleware({...})` before/after a host's own stack. Attach with the host's `middleware: { pre, post }` field on `query`/`function`/`task`/`tool`/`apiGroup` (NOT triggers): each phase is an ordered list of middleware refs (def handle or name), or `{ middleware, active: false }` to keep an entry disabled. Providing a phase **overrides** it (sets the stored `pre_customize`/`post_customize` flag); omitting a phase **inherits** the parent tier's chain \u2014 the engine resolves Query \u2192 API Group \u2192 Workspace at request time (override, not merge; the API-Group tier applies to queries \u2014 functions/tasks/tools have no API-group binding and inherit straight from the workspace). Prefer a def handle over a bare name when the middleware pins an explicit `guid`. `pre: middleware.clear()` (an empty list) overrides with nothing \u2014 stop inheriting. Workspace-level defaults are the terminal tier: `workspaceConfig({ middleware: { query: { pre }, function, task, tool } })` emits the flat `{host}_{phase}` map (no `_customize` flags) \u2014 setting it replaces the whole workspace map, so unlisted hosts are cleared; omit the field to leave existing workspace middleware untouched. Distinct from `s.middleware.call` (inline invoke).",
+    '- **Middleware request context.** A `pre` middleware runs **after** auth resolution, so `auth()` is available inside the middleware when the host is authenticated (its `auth` names an auth table); on a public host `auth()` is `null`. This matters for the canonical use \u2014 a rate limit keyed by `auth("id")`: on an authenticated endpoint the bucket is per-user, but attach the same middleware to a public endpoint and every anonymous caller keys under the same `null` id (one shared bucket), silently. To catch that, `export()` **warns** (never blocks) when a middleware whose stack references `auth()` is directly attached to a host where `auth()` may be null \u2014 a `query` with no auth table, a `task` (scheduled, never authenticated), or a `function`/`tool` (whose auth is caller-dependent). An authenticated query (its own `auth` table set) is skipped. The check is direct-attachment only; a middleware reaching a public query via API-group/workspace tier inheritance is not caught.',
+    '- **Rate-limit recipe (the canonical middleware).** Per-user rate limiting is the most common middleware. Author it with `s.redis.ratelimit` and a **composite key** built via the filter chain \u2014 `"prefix" + auth("id")` does not exist, you build the key: `middleware({ name: "write_rl", exceptionPolicy: "rethrow", stack: [ s.redis.ratelimit({ key: withFilters(c.text("rl:write:"), fl.concat(auth("id"))), max: c.int(10), ttl: c.int(30), error: c.text("Too fast.") }) ] })`. `exceptionPolicy` defaults to `"rethrow"`, which is what makes a tripped limit abort with HTTP 429; `"silent"` would let the over-limit request through. Attach it with `middleware: { pre: [writeRl] }` on an **authenticated** host (its `auth` set) so `auth("id")` keys per-user; on a public host `auth("id")` is null and every caller shares one bucket (`export()` warns \u2014 see request context above). **Shared-bucket rule:** co-attaching one middleware object to N hosts means all N share the *same* key \u21D2 *one* counter \u2014 `max: 10` is a global per-user budget across them, not 10-per-host. Vary the key (fold in the host/action name) for an independent limit per host.',
+    '- **Middleware `exceptionPolicy`** governs what a **throw** in the middleware stack does to the request (XanoTS passes the value through; the Xano engine interprets it). `"rethrow"` is the **default** \u2014 the throw aborts the request and surfaces the authored `error`/status (a tripped `s.redis.ratelimit` \u2192 HTTP 429); the `post` chain still runs. `"silent"` swallows the throw, so a guard set to it is **not enforced** \u2014 advisory middleware only. `"critical"` is `"rethrow"` plus skipping the `post` chain. The only difference between `rethrow` and `critical` is whether `post` runs \u2014 no status or logging change.',
+    "",
+    '- **Request history** controls per-object execution capture (the request/task/trigger debugger). Authored as a single scalar `history` field on any primitive: `false` off, `true` on at the default capture depth, a number = capture depth (how many statement executions are recorded per history record \u2014 NOT record retention), `"all"` unlimited. **Omit `history` to inherit** \u2014 the engine resolves object \u2192 container \u2192 workspace at request time (a query inherits from its API group, a tool from its toolset envelope, everything else straight from the workspace). Any authored value stops inheriting for that object. Per-kind defaults (when inheriting): query/task/tool capture ON, function/trigger/middleware OFF; default depth 100. Container tiers are authorable too \u2014 `apiGroup({ history })` sets the `query_*` default its queries inherit, and an agent/mcp_server/toolset `history` sets the `tool_*` default its tools inherit. Workspace-level defaults are the terminal tier: `workspaceConfig({ history: { query, function, task, tool, trigger, middleware } })` emits the flat `{objType}_enabled`/`{objType}_limit` map (no inherit flag) \u2014 setting it is wholesale (unlisted types fall back to their engine default), so declare every default you want to keep; omit the field to leave existing workspace history untouched.',
+    "",
+    '- **Workspace environment variables** set a tenant\'s env vars through the workspace object: `workspaceConfig({ env: { STRIPE_KEY: process.env.STRIPE_KEY!, APP_BASE_URL: "https://\u2026" } })`. Author them as a name\u2192value MAP. Read a var back with `env("NAME")` (\u2192 `$env.NAME`), which compiles to tag "setting" with the plain name. Values are SECRETS: prefer sourcing from `process.env` over committing literals, and don\'t commit a compiled bundle with real values. `deploy` REPLACES the tenant\'s env with the declared map; `release` (merge) is ADD-ONLY \u2014 it creates missing keys but does NOT update or remove existing ones, so changing a value in code and releasing leaves the live value unchanged. Omit `env` to leave existing env untouched. The separate `settings` field is a plain object.',
+    ""
+  ];
+  const stmtCalls = [
+    "Auth & calls:",
+    "",
+    "- `s.security.create_auth_token({ table, id, extras?, expiration?, as? })` \u2014 `extras` defaults to `{}`, `expiration` to `86400`s (`0` = never).",
+    "- `s.security.create_guid({ as? })` \u2014 bind a fresh GUID string. Takes nothing else.",
+    "- `s.function.run({ fn, input?, as?, runtime? })` / `s.function.call({ fn, input?, as? })` \u2014 run another function; `input` is keyed by the target's input names.",
+    '  - `runtime?` runs it in the BACKGROUND: `{ mode: "async-shared" }` or `{ mode: "async-dedicated", cpu?, memory?, timeout?, maxRetry? }` (resources read at dedicated only). An async call DOES NOT return the result \u2014 it dispatches and continues, so `as` binds nothing; collect with `s.await({ ids })`. Omit for a normal call. Same block on `s.ai.agent.run`.',
+    '- `s.api.call({ api, input?, headers?, auth?, as? })` \u2014 invoke an endpoint. `headers` REPLACES the request headers the callee sees and takes the same shapes as `s.api.request`\'s \u2014 a `{ "Name": value }` record (values may be tagged), a `string[]` of `"Name: value"` lines, or one `Value`. `auth` is `{ token, ignoreExpiration? }`: `token` must be a BARE STRING \u2014 a tagged `Value` deploys clean and then fails the run with `Param: token - Text filter requires an integer, float, string or boolean value`, since the engine stores that slot as plain text and never evaluates it. Neither slot authenticates the call today; see `llms/tests.md` for what a workflow-test run actually sees. WORKFLOW-TEST ONLY (see Gotchas in `llms.txt`) \u2014 elsewhere it deploys clean and 500s the first real request.',
+    '- `s.api.request({ url?, method?, params?, headers?, timeout?, follow_location?, verify_host?, verify_peer?, ca_certificate?, certificate?, certificate_pass?, private_key?, private_key_pass?, description?, output?, as? })` \u2014 external HTTP request (`mvp:api_request`). Ergonomic types, each also accepting a dynamic `Value`: `method` suggests the 7 verbs (GET/POST/PUT/DELETE/HEAD/OPTIONS/PATCH), `params` a plain JSON object **or** a FLAT record whose values are tagged `Value`s (`{ count: ref("count") }`, each lifted via a `set` filter \u2014 the same record-of-values shape `response: { key: value }` takes); a tagged value NESTED inside an object or array THROWS at encode, so wrap a structured body in `obj({...})`, which encodes any depth as one `const:expr2` (\u2192 query string for GET/HEAD/OPTIONS, body otherwise), `headers` a `{ "Name": value }` record whose values may be tagged (`{ "x-api-key": env("KEY") }`, each pair joined to a `"Name: value"` line) **or** a `string[]` of full header lines \u2014 prefer a header over a `?key=` query param for a credential \u2014 a URL travels into access logs, proxies and `Referer`. \u26A0 Neither spelling is envelope-safe: the `as` envelope\'s `request` half mirrors `url`, `params` AND `headers`, so never return it raw from a credentialed request \u2014 read `response.result`. A NAME outside the header-token charset is refused, and a LITERAL value carrying a newline is refused; a value may hold `:` and spaces (`Bearer a: b` is a valid value). A TAGGED value cannot be checked at build time, so strip CRLF from caller-controlled input before this slot. Literal pairs lead the emitted array and computed ones follow, so the wire order is not the record\'s key order, `timeout` a `number` in seconds (1\u201386400), and `follow_location`/`verify_host`/`verify_peer` booleans. `description` (Settings tab) and `output` filters (Output tab) ride the envelope. SSL cert interdependencies (certificate\u2194private_key, ca_certificate\u2192verify_peer) are checked at build time when statically provable, else by the engine at runtime. The `as` result is typed as the `{request, response}` envelope (`response.status: number`, `response.result: unknown`), so `InferResponse` resolves a `ref` to it. Same typed result on `webflow.request` and `microservice.request`.',
+    "- `s.stream.from_request({ url?, method?, \u2026tls, as? })` \u2014 streaming external HTTP request (`mvp:streaming_api_request`); same typed field surface as `s.api.request` (no description/output envelope).",
+    "- `s.webflow.request({ path?, method?, \u2026tls, as? })` \u2014 Webflow API request (`mvp:connect_webflow_api_request`); like `s.api.request` but addressed by `path` (host is engine-supplied).",
+    "- `s.task.call` / `s.tool.call` / `s.trigger.call` / `s.middleware.call` / `s.addon.call` \u2014 same `{ <target>, input?, as? }` shape against the named kind. `s.task.call` and `s.trigger.call` are WORKFLOW-TEST ONLY (see Gotchas in `llms.txt`); `s.tool.call`, `s.middleware.call` and `s.addon.call` run from any stack.",
+    "- `s.action.call({ action, package?, input?, as? })` / `s.action.package.call(\u2026)` \u2014 invoke a marketplace action; `package` is its slug.",
+    "- `s.cloud.job({ image?, command?, args?, secret?, template?, await?, as? })` \u2014 launch a containerized job. \u26A0 `await` is SECONDS (default 60), not a boolean.",
+    "- `s.cloud.job.status({ id, as? })` \xB7 `s.cloud.job.await({ ids, timeout, as? })` \u2014 poll one job, or block on several (`ids` a list `Value`, `timeout` in seconds; both required).",
+    "",
+    "Microservices (the `microservice()` def and the statement that calls it):",
+    "",
+    '- `s.microservice.request({ host, path, port?, method?, params?, headers?, timeout?, follow_location?, as? })` \u2014 in-cluster microservice call (`mvp:microservice_request`); no TLS fields. ONLY `host`+`path` required; the rest default to the engine\'s values (`GET`/`{}`/`[]`/`10`/`true`), always emitted. Pass the `microservice()` DEF as `host` \u2014 it binds by NAME (how the engine resolves it), so a rename fixes every call site and the port is checked before deploy. `port?` folds into `host` as `"name:port"`: a def exposing ONE `servicePort` resolves automatically, SEVERAL requires it. A raw `"name:port"` string works, unvalidated, and is the only way to reach an instance-level microservice. `tenantDeploy: "manual"` on the def imports the row without starting the workload.',
+    "- `s.workflow_test.call({ workflowTest, datasource?, as? })` \u2014 run another workflow test from inside one, which is the only place it runs (see Gotchas in `llms.txt`). The odd one out: NO `input` (a workflow test takes none), and it carries `datasource?` instead \u2014 same clone caveat as the kind's own field.",
+    ""
+  ];
+  const groups = /* @__PURE__ */ new Map();
+  for (const s of m.statements) {
+    if (s.legacy) continue;
+    const ns = s.sPath.includes(".") ? s.sPath.slice(0, s.sPath.indexOf(".")) : "(top-level)";
+    (groups.get(ns) ?? groups.set(ns, []).get(ns)).push(s);
+  }
+  const stmtCatalog = [];
+  for (const ns of [...groups.keys()].sort()) {
+    stmtCatalog.push(`### ${ns}`, "");
+    const note = NAMESPACE_NOTES[ns];
+    if (note) stmtCatalog.push(note, "");
+    for (const s of groups.get(ns)) {
+      const call = `s.${s.sPath}`;
+      const flags = [s.declarative ? null : "special", s.registered ? null : "unregistered", s.output ? "output" : null].filter(Boolean).join(", ");
+      const flagSuffix = flags ? ` [${flags}]` : "";
+      const resultSuffix = s.result ? ` \u2192 ${s.result.name}: ${s.result.type}${s.result.note ? ` (${s.result.note})` : ""}` : "";
+      if (s.fields) {
+        const args = s.fields.map((f) => fieldLine(f, s.sPath)).join("; ");
+        stmtCatalog.push(`- \`${call}({ ${args} })\`${flagSuffix}${resultSuffix}`);
+      } else {
+        stmtCatalog.push(`- \`${call}\`${flagSuffix}${resultSuffix}`);
+      }
+    }
+    stmtCatalog.push("");
+  }
+  const legacy = [];
+  const legacyValues = m.values.constructors.filter((v) => v.legacy);
+  const legacyStatements = m.statements.filter((s) => s.legacy);
+  const legacyFactories = m.objectKinds.flatMap((k) => (k.subKinds ?? []).filter((sub) => sub.legacy));
+  if (legacyValues.length + legacyStatements.length + legacyFactories.length + SUPERSEDED_STATEMENTS.size + DECODE_ONLY_STATEMENTS.size > 0) {
+    legacy.push(
+      // The heading the topic file drops in favor of its own title; kept so the
+      // block reads as a section wherever it is rendered from.
+      "## Legacy",
+      "",
+      "Older paradigms this SDK still supports and still emits when it decodes an existing",
+      "workspace. **Do not author these.** They are listed by name only so you recognize them",
+      'in pulled code rather than "fixing" them; each line names what to use instead.',
+      "",
+      "Names overlap across the split deliberately \u2014 the engine reused words like",
+      '"realtime" and "channel" for both generations. A name matching is NOT evidence that',
+      "two things are the same object; check which list it came from.",
+      ""
+    );
+    for (const v of legacyValues) legacy.push(`- \`${v.name}\` \u2014 ${v.description}`);
+    for (const f of legacyFactories) legacy.push(`- \`${f.authorFactory}()\` \u2014 ${f.description}`);
+    for (const s of legacyStatements) {
+      legacy.push(`- \`s.${s.sPath}\` \u2014 ${LEGACY_SURFACES[s.surface]}`);
+    }
+    const retired = [...SUPERSEDED_STATEMENTS.entries()];
+    if (retired.length > 0) {
+      legacy.push("");
+      legacy.push(
+        "Retired statement VERSIONS \u2014 no `s.` surface exists. Pulled code shows them as",
+        '`raw({ name: "\u2026" })` and they keep running as stored, so leave them; author the',
+        "replacement only for NEW code. Never swap one for the other \u2014 each version broke the last.",
+        ""
+      );
+      for (const [stored, successor] of retired) {
+        legacy.push(successor ? `- \`${stored}\` \u2192 \`${successor}\`` : `- \`${stored}\` \u2014 retired, no replacement`);
+      }
+    }
+    const decodeOnly = [...DECODE_ONLY_STATEMENTS.entries()];
+    if (decodeOnly.length > 0) {
+      legacy.push("");
+      legacy.push(
+        "Statements the engine writes but will NOT import back \u2014 no `s.` surface exists, and",
+        "unlike the retired versions above these must be FIXED, not left alone. Pulled code shows",
+        'them as `raw({ name: "\u2026" })`; `export()` refuses any bundle that still contains one.',
+        ""
+      );
+      for (const [stored, reason] of decodeOnly) legacy.push(`- \`${stored}\` \u2014 ${reason}.`);
+    }
+    legacy.push("");
+  }
+  legacy.push(
+    "## Reading a pulled tree",
+    "",
+    "`codegen` emits objects as FACTORY calls (`table({...})`, `query({...})`, \u2026) \u2014 the form",
+    "you author by hand \u2014 so inference survives the round trip.",
+    'Three shapes read differently and must not be "fixed": a trigger no factory expresses',
+    "(the realtime types, or a non-default `history`) stays `{...} satisfies TriggerDef`; a",
+    "statement the catalog cannot model round-trips verbatim through `raw()`",
+    "(`@xanots/sdk/codegen`); and an object ALREADY EMPTY upstream decodes to a def with",
+    "no `stack`, reported as `empty-source` \u2014 faithful, not a decode failure. \u26A0 Workspace env",
+    "var VALUES ride inline in `xano/workspace.ts`, so treat a pulled tree as secret-bearing.",
+    ""
+  );
+  return {
+    router: lines,
+    legacy,
+    objectKinds,
+    kindsCore,
+    kindsAgentMcp,
+    kindsRealtime,
+    triggers,
+    stmtData,
+    stmtRuntime,
+    stmtCalls,
+    stmtCatalog,
+    values,
+    fields,
+    filters,
+    lambda,
+    tests: renderTestsSection()
+  };
+}
+var LLMS_TXT = "llms.txt";
+var LLMS_FULL_TXT = "llms-full.txt";
+function renderTopic(t) {
+  const body = [...t.body];
+  if (t.dropLeadingHeading) {
+    body.shift();
+    while (body.length > 0 && body[0] === "") body.shift();
+  }
+  while (body.length > 0 && body[body.length - 1] === "") body.pop();
+  return [`# ${t.title}`, "", `> ${t.readWhen}`, "", ...body, ""].join("\n");
+}
+function renderDocs(m) {
+  const s = renderSections(m);
+  const topics = [
+    {
+      path: "llms/object-kinds.md",
+      title: "Object kinds",
+      readWhen: "Read when you need the full catalog of authorable primitives \u2014 which factory builds each, which register method takes it, and which payload key it lands under. Read it too when a `register*` call will not typecheck because the array was built by `.flatMap()`/`.concat()` across modules.",
+      body: s.objectKinds,
+      dropLeadingHeading: true
+    },
+    {
+      path: "llms/kinds-core.md",
+      title: "Core def shapes",
+      readWhen: "Read when authoring a function, query, api group, task, workflow test, middleware, or tool \u2014 and for the `response` and `expr` shapes every one of them uses.",
+      body: s.kindsCore,
+      dropLeadingHeading: true
+    },
+    {
+      path: "llms/tests.md",
+      title: "Saved unit tests, assertions, and mocks",
+      readWhen: "Read when authoring a `workflowTest()` stack, when a query/function/middleware carries `tests`, when a statement should mock a value, or when running a deployed environment's tests.",
+      body: s.tests,
+      dropLeadingHeading: true
+    },
+    {
+      path: "llms/kinds-agent-mcp.md",
+      title: "Agent and MCP def shapes",
+      readWhen: "Read when the workspace defines an `agent()` or an `mcpServer()`.",
+      body: s.kindsAgentMcp
+    },
+    {
+      path: "llms/kinds-realtime.md",
+      title: "Realtime def shapes",
+      readWhen: "Read when the workspace defines a `realtimeServer()`, `realtimeChannel()`, or `realtimeMessage()` handler.",
+      body: s.kindsRealtime
+    },
+    {
+      path: "llms/triggers.md",
+      title: "Triggers",
+      readWhen: "Read when authoring any trigger. A trigger's `stack` is a callback rather than the plain array every other kind takes, so the shape does not carry over.",
+      body: s.triggers,
+      dropLeadingHeading: true
+    },
+    {
+      path: "llms/statements-data.md",
+      title: "Array and database statements",
+      readWhen: "Read when the stack reads or writes rows (`s.db.*`), or transforms an array in place (`s.array.map`, `s.array.union`).",
+      body: s.stmtData
+    },
+    {
+      path: "llms/statements-runtime.md",
+      title: "Statement runtime behavior",
+      readWhen: "Read when you need to know what a statement's `as:` output actually holds, or why a bound variable is not the shape you expected.",
+      body: s.stmtRuntime
+    },
+    {
+      path: "llms/statements-calls.md",
+      title: "Auth, cross-object calls, and microservices",
+      readWhen: "Read when the stack authenticates, calls another object (`s.function.run`, `s.api.request`, `s.tool.call`), or reaches a microservice.",
+      body: s.stmtCalls
+    },
+    {
+      path: "llms/values.md",
+      title: "Value catalog",
+      readWhen: "Read when you need a literal, a reference, or a tag you have not used before \u2014 `c.*`, `ref`, `inp`, `auth`, `col`, and what each one encodes to.",
+      body: s.values,
+      dropLeadingHeading: true
+    },
+    {
+      path: "llms/fields.md",
+      title: "Column and input types",
+      readWhen: "Read when declaring a table column (`f.*`) or a function/query input (`input.*`) \u2014 a type's options and accessor methods, and the `s.precondition` error/status contract that rides the same catalog.",
+      body: s.fields,
+      dropLeadingHeading: true
+    },
+    {
+      path: "llms/filters.md",
+      title: "Filter catalog",
+      readWhen: "Read when piping a value through `fl.*` \u2014 the full catalog with each filter's argument types.",
+      body: s.filters,
+      dropLeadingHeading: true
+    },
+    {
+      path: "llms/lambda.md",
+      title: "Lambda bodies (JavaScript)",
+      readWhen: "Read when writing a JavaScript body, or weighing whether to reach for one at all \u2014 `lam.fn`, `fl.lambda`, `fl.reduce`, `s.lambda`. Lambda workers are a bounded shared resource, each surface binds a different set of identifiers, and the hazards are not guessable.",
+      body: s.lambda,
+      dropLeadingHeading: true
+    },
+    {
+      path: "llms/legacy.md",
+      title: "Legacy paradigms and retired statements",
+      readWhen: 'Read when the code was PULLED from an existing Xano instance rather than authored here \u2014 how a codegen\'d tree reads and the three shapes in it that must not be "fixed", plus a `raw({ name: "mvp:\u2026" })` statement, a `realtimeTrigger()`, or any name the catalogs do not list. None of the retired names are authorable for new code.',
+      body: s.legacy,
+      dropLeadingHeading: true
+    },
+    {
+      path: "llms/statements-catalog.md",
+      title: "Statement catalog",
+      readWhen: "Read for the field signature of a specific statement \u2014 every surface, grouped by `s.*` namespace. Look here after the control-flow core in the router does not cover what you need.",
+      body: s.stmtCatalog
+    }
+  ];
+  const nav = [
+    "## Topic files",
+    "",
+    "Each line is a condition on the task. Open the files whose condition matches and",
+    "skip the rest \u2014 paths are relative to this file (`node_modules/@xanots/sdk/` once",
+    "installed), so they resolve with a plain file read and always match the version you",
+    `have. \`${LLMS_FULL_TXT}\` is this file and every one below concatenated \u2014 for a reader`,
+    "that wants one fetch, not for an agent that can open the two files it needs.",
+    "",
+    ...topics.map((t) => `- [${t.title}](${t.path}): ${t.readWhen}`),
+    ""
+  ];
+  const slot = s.router.indexOf(NAVIGATION_SLOT);
+  if (slot === -1) throw new Error(`the router lost its ${NAVIGATION_SLOT} placeholder`);
+  const router = [...s.router.slice(0, slot), ...nav, ...s.router.slice(slot + 1)];
+  const docs = /* @__PURE__ */ new Map([[LLMS_TXT, router.join("\n")]]);
+  for (const t of topics) docs.set(t.path, renderTopic(t));
+  docs.set(
+    LLMS_FULL_TXT,
+    [docs.get(LLMS_TXT) ?? "", ...topics.map((t) => docs.get(t.path) ?? "")].join("\n")
+  );
+  return docs;
+}
+function renderLlmsTxt(m) {
+  const txt = renderDocs(m).get(LLMS_TXT);
+  if (txt === void 0) throw new Error(`renderDocs emitted no ${LLMS_TXT}`);
+  return txt;
+}
+export {
+  FIELD_METHODS,
+  FILTER_NAMES,
+  GENERATED_SPECS,
+  GENERATED_STATEMENT_NAMES,
+  IMPLEMENTED_STATEMENTS,
+  LLMS_TXT,
+  LOCK_VERSION,
+  PAYLOAD_ARRAY_KEYS,
+  QUERY_EXPRESSION_FILTERS,
+  REFERENCEABLE_KINDS,
+  STATEMENT_SURFACES,
+  TOTAL_OBJECT_KINDS,
+  TOTAL_STATEMENTS,
+  VECTOR_FILTERS,
+  WORKSPACE_KEY,
+  addonKind,
+  adoptFromBundle,
+  agentKind,
+  apiGroupKind,
+  buildBundle,
+  buildManifest,
+  buildMiddlewareBlock,
+  buildWorkspaceHistory,
+  calcSignatureJson,
+  channelPathParams,
+  createLockContext,
+  declaredServicePorts,
+  deriveGuid,
+  emptyLock,
+  encodeAddon,
+  encodeAgent,
+  encodeApiGroup,
+  encodeColumn,
+  encodeContainerHistory,
+  encodeFromSpec,
+  encodeFunction,
+  encodeHistory,
+  encodeIndex,
+  encodeMcpServer,
+  encodeMicroservice,
+  encodeMiddleware,
+  encodeMiddlewareEntry,
+  encodeMiddlewareList,
+  encodeObject,
+  encodeQuery,
+  encodeRealtimeChannel,
+  encodeRealtimeMessage,
+  encodeRealtimeServer,
+  encodeResponse,
+  encodeSchedule,
+  encodeStatement,
+  encodeTable,
+  encodeTask,
+  encodeTool,
+  encodeToolRefs,
+  encodeToolsetBase,
+  encodeTrigger,
+  encodeView,
+  encodeWorkflowTest,
+  encodeWorkspaceConfig,
+  functionKind,
+  generated as generatedStatements,
+  getKind,
+  getLockedCanonical,
+  getLockedGuid,
+  getStatementFactory,
+  isLockSeeded,
+  isQueryExpressionFilter,
+  isRegisteredKind,
+  isRegisteredStatement,
+  lockKey,
+  mcpServerKind,
+  mergeObserved,
+  microserviceKind,
+  middlewareKind,
+  mintCanonical,
+  parseLock,
+  phpJsonEncode,
+  queryKind,
+  realtimeChannelGuid,
+  realtimeChannelKind,
+  realtimeMessageGuid,
+  realtimeMessageKind,
+  realtimeServerKind,
+  recordObserved,
+  registerKind,
+  registerSpec,
+  registeredKinds,
+  renameLockEntry,
+  renderDocs,
+  renderLlmsTxt,
+  resolveAuthRef,
+  resolvePayloadKey,
+  resolveRealtimeServerCanonical,
+  resolveRef,
+  resolveToolsetCanonical,
+  sPathOf,
+  serializeBundle,
+  serializeLock,
+  tableKind,
+  taskKind,
+  toNestedFields,
+  toolKind,
+  triggerKind,
+  validateLockModel,
+  workflowTestKind,
+  workspaceKind
+};
+//# sourceMappingURL=internal.js.map