@xanots/sdk 0.0.13 → 0.0.14

package/llms.txt

@@ -1,4 +1,4 @@
-# xanots v0.0.13
+# xanots v0.0.14
 
 > TypeScript SDK that compiles a typed Xano workspace into the importable packageExport JSON bundle.
 
@@ -15,11 +15,11 @@ TAGGED value — `ref("x")` a stack variable, `inp("x")` an input, `auth("id")`
 caller, `c.*` a constant — resolved at request time; JS operators over them do not
 compute (see Gotchas). Requests share no memory — state persists in tables or redis.
 
-Coverage: object kinds 25/31, statement surfaces 214/214, filters 226 (226 typed).
+Authorable: statement surfaces 214/214, filters 226 (226 typed).
 Not authorable here: branch, market_item, realtime_channel, run.job, run.service, tablemap — these cannot be authored and do not survive a pull; reasons in `coverage.objectKinds.unmodeled`.
 
 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
+every cross-cutting gotcha, and control flow. Per-surface detail lives in the topic files listed
 below — open the one whose condition matches the task, skip the rest. For
 exhaustive per-entry detail in NEITHER — a statement's field schema with engine
 defaults, a filter's full argument list, the `storedName` mapping — do a TARGETED
@@ -37,23 +37,25 @@ Paths are relative to this file (`node_modules/@xanots/sdk/` once installed), so
 plain file read resolves them at the version you have.
 `llms-full.txt` is everything concatenated — one fetch for a reader that cannot open files.
 
-- [Object kinds](llms/object-kinds.md): Read when deciding WHAT to build — every authorable primitive (tables, endpoints, functions, tasks, agents, MCP, realtime, microservices, …), what each is, and which factory + register method build it. Read it too when a `register*` call will not typecheck because the array was built by `.flatMap()`/`.concat()` across modules.
+- [Object kinds](llms/object-kinds.md): Read when deciding WHAT to build — every authorable primitive, what each is, and which factory + register method builds it. Also when `register*` will not typecheck an array built by `.flatMap()`/`.concat()`.
 - [Core def shapes](llms/kinds-core.md): Read when authoring a function, query, api group, task, workflow test, middleware, or tool — and for the `response` and `expr` shapes every one of them uses.
-- [Saved unit tests, assertions, and mocks](llms/tests.md): 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.
+- [Consuming defs from a client](llms/client.md): Read when a frontend imports a def (`getPath()`/`InferResponse`) or calls the deployed backend — what the import costs, `window.XANO_HOST`, local dev, file URLs, and a Node spot-check.
+- [Error index](llms/errors.md): Read when a request, test, build, or pull fails with a message you did not write — the string, its cause, and where the fix is.
+- [Saved unit tests, assertions, and mocks](llms/tests.md): Read when authoring a `workflowTest()` stack, when a query/function/middleware carries `tests`, when a statement needs a `mock`, or when running a deployed environment's tests.
 - [Agent and MCP def shapes](llms/kinds-agent-mcp.md): Read when the workspace defines an `agent()` or an `mcpServer()`.
-- [Knowledge def shape](llms/kinds-knowledge.md): Read when the workspace defines a `knowledge()` item — the markdown its AI agents read.
+- [Knowledge def shape](llms/kinds-knowledge.md): Read when the workspace defines a `knowledge()` item for its AI agents.
 - [Realtime def shapes](llms/kinds-realtime.md): Read when the workspace defines a `realtimeServer()`, `realtimeChannel()`, or `realtimeMessage()` handler.
 - [Triggers](llms/triggers.md): 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.
 - [Array and database statements](llms/statements-data.md): Read when the stack reads or writes rows (`s.db.*`), or transforms an array in place (`s.array.map`, `s.array.union`).
-- [Statement runtime behavior](llms/statements-runtime.md): 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.
+- [Statement runtime behavior](llms/statements-runtime.md): Read when you need to know what a statement's `as:` output holds, or why a bound variable is not the shape expected.
 - [Auth, cross-object calls, and microservices](llms/statements-calls.md): Read when the stack authenticates (the signup/login/token recipe is here), calls another object (`s.function.run`, `s.api.request`, `s.tool.call`), sends email (`s.util.send_email`), or reaches a microservice.
 - [Value catalog](llms/values.md): Read when you need a literal, a reference, or a tag you have not used before — `c.*`, `ref`, `inp`, `auth`, `col`, and what each one encodes to.
-- [Column and input types](llms/fields.md): Read when declaring a table column (`f.*`) or a function/query input (`input.*`) — a type's options and accessor methods, and the `s.precondition` error/status contract that rides the same catalog.
+- [Column and input types](llms/fields.md): Read when declaring a table column (`f.*`) or a function/query input (`input.*`) — a type's options and methods, and the `s.precondition` error/status contract. Also `table({ seed })` rows and `use_xdo`.
 - [Filter catalog](llms/filters.md): Read when piping a value through `fl.*` — the full catalog with each filter's argument types.
-- [Lambda bodies (JavaScript)](llms/lambda.md): Read when writing a JavaScript body, or weighing whether to reach for one at all — `lam.fn`, `fl.lambda`, `fl.reduce`, `s.lambda`. Lambda workers are a bounded shared resource, and each surface binds a different set of identifiers.
+- [Lambda bodies (JavaScript)](llms/lambda.md): Read when writing a JavaScript body, or weighing whether to reach for one at all — `lam.fn`, `fl.lambda`, `fl.reduce`, `s.lambda`; each surface binds a different set of identifiers.
 - [Lock file](llms/lock.md): Read when a `xano.lock` exists or should — renaming/pruning/importing identities, seeding the lock programmatically, or asking which commands write it.
-- [Legacy paradigms and retired statements](llms/legacy.md): Read when the code was PULLED from an existing Xano instance rather than authored here — how a codegen'd tree reads and the three shapes in it that must not be "fixed", plus a `raw({ name: "mvp:…" })` statement, a `realtimeTrigger()`, or any name the catalogs do not list.
-- [Statement catalog](llms/statements-catalog.md): Read for the field signature of a specific statement — every surface, grouped by `s.*` namespace. Look here after the control-flow core in the router does not cover what you need.
+- [Legacy paradigms and retired statements](llms/legacy.md): Read when the code was PULLED from an existing Xano instance — how a codegen'd tree reads, the shapes in it that must not be "fixed", and any `raw({ name: "mvp:…" })`, `realtimeTrigger()`, or name the catalogs do not list.
+- [Statement catalog](llms/statements-catalog.md): Read for the field signature of a specific statement — every surface, grouped by `s.*` namespace.
 
 ## Quickstart
 
@@ -125,6 +127,8 @@ operand, a `ref()` nothing binds). Each has a legitimate use, so each only warns
 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.
+Before calling the work done: `npm run typecheck`, `xanots export <entry> --strict`,
+`xanots deploy <entry>`, then `xanots test run-all` against what deployed.
 
 Identity: object guids derive from `(type, name)` — a query's from `(api group,
 verb, name)` — so renames change identity.
@@ -170,90 +174,89 @@ production workspace, but confirm with the user before the first run.
 
 **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`) — without it the var reads as undefined, the
-host falls back to '', and every call 404s off the dev server.
-⚠ It is INJECTED in bracket form — `window["XANO_HOST"]="…"` — so verifying a deploy
-by grepping `window.XANO_HOST` matches nothing and reads as a failed inject. Grep the
-bare `XANO_HOST` token.
-⚠ `xanots preflight` 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 }`. ⚠ Do NOT use its `url`: on a tenant-scoped environment that field
-addresses the instance host WITHOUT the `/tenant/<name>` segment and 404s, silently —
-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.
-⚠ A static host serves these files verbatim, so everything injected is PUBLIC — base
+so the frontend needs no rebuild to target an env. How to read it, local dev, verifying
+the inject, and displaying a stored file: `llms/client.md`.
+⚠ A static host serves its files verbatim, so everything injected is PUBLIC — base
 URLs and publishable keys only, never secrets. Secrets go in backend env, read
 server-side via `env(name)`.
+⚠ `xanots preflight` ignores the deploy login and reads `XANO_VALIDATE_INSTANCE` /
+`XANO_VALIDATE_TOKEN` (+ optional `XANO_VALIDATE_WORKSPACE_ID`) from the environment.
 
 **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 — it covers what you must know to AUTHOR a workspace.
-**Recommended style:** reach statements through the `s` namespace
-(`s.db.add`, `s.math.add`, …) — one discoverable, tab-completable surface. The
-flat factory aliases (`dbAdd`, `dbQuery`, `setVar`, `mathAdd`, …) are exported
-and identical in output; prefer `s.*` in new code so examples stay consistent.
+**Style:** reach statements through the `s` namespace (`s.db.add`, `s.math.add`, …).
+The flat aliases (`dbAdd`, `setVar`, …) are identical in output; prefer `s.*`.
 
 ## Gotchas
 
 Non-obvious authoring rules:
 
+### Values and references
+
 - **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.
+- **Foreign key is `f.tableRef(table)`, not `ref`.** `ref(name)` references a
+  stack variable (a value); `f.tableRef` is the column constructor.
 - **Tagged values are DATA — a JS template literal cannot compose them.** `${ref(...)}`
   (or `"a" + ref(...)`) stringifies the tag object at BUILD time: ``c.text(`Hi ${ref("u.name")}`)``
   type-checks and encodes the literal text `Hi [object Object]`, served verbatim.
   `export()` warns; `--strict` fails. Compose at RUNTIME:
   `withFilters(c.text("Hi "), fl.concat(ref("u.name")))`, an `obj({...})`/record member,
   or `c.expression('"Hi, " ~ $var.u.name')`.
-- **`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>` — 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 — 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 — 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 — no per-member `s.set_var` hoist needed.
-  ⚠ EXPRESSION and `obj()` operands ONLY — 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 — 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.
-  ⚠ 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 —
-  `export()` warns on a `ref()` whose base segment no `as` in that stack binds, with a
-  did-you-mean; fix the name instead.
+- **Declare inputs with `input.<type>()`, read them with `inp("name")`.** `inp()`
+  resolves ONLY against this def's own `input` block — 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).
+- **`get_input`/`get_raw_input` read the whole payload**, not one named input
+  (args are `{ as?, encoding?, excludeMiddleware? }` — no `name`). For a single
+  input use `inp("name")`.
+- **To match every row, omit `where` — 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 — `inp("clause")`, `ref("built_where")`, or `c.text("id > 0")`.
+
+### Tables and columns
+
+- **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 — `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>`.
+- **A column named `run` is reserved.** The table deploys and reads back fine, then
+  EVERY `s.db.add` into it 400s — at any column type, with or without a value — and
+  the error names the column while complaining about the VALUE. Use `run_id`. Exact,
+  case-sensitive, one name: `Run`/`runs`/`run_id` are fine. `--strict` fails on it.
+- **Self-referencing tables** need the bare-name form: inside `tweets`'s own
+  schema, write `f.tableRef("tweets", { type: "int" })` — the `const tweets`
+  handle isn't assigned yet, so the handle form throws "used before declaration".
+- **Seed a table's starting rows with `table({ seed })`.** Rows typed against the
+  schema, inline (`seed: [{ name: "…" }]`) or from a file (`seedFile("./seed.json",
+  import.meta.url)`). Only `deploy` ships them, and a re-deploy re-seeds cleanly. Never
+  put secrets in `seed`. Row shape, `id` pinning, and the file rules: `llms/fields.md`.
+- **`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` — 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 — it is the only way to
+  read an `internal` column, and `export()` warns when a stack reads one a `db.get` did not
+  return.
+- **Don't take a password through `input.password` on login — 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). `export()` warns.
+
+### Reading and writing rows
+
 - **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`
@@ -267,44 +270,73 @@ Non-obvious authoring rules:
   check-in — 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.
-- **A column named `run` is reserved.** The table deploys and reads back fine, then
-  EVERY `s.db.add` into it 400s — at any column type, with or without a value — and
-  the error names the column while complaining about the VALUE. Use `run_id`. Exact,
-  case-sensitive, one name: `Run`/`runs`/`run_id` are fine. `--strict` fails on it.
-- **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 — `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`) — inline (`seed: [{ name: "…" }]`), 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 — 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. ⚠ 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 — 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 — mixing explicit and
-  omitted `id` throws. A `system:false` PK is the author's to supply. Pinning is
-  `seed`-only — `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" })` — the `const tweets`
-  handle isn't assigned yet, so the handle form throws "used before declaration".
+- **Drilling into a maybe-null `db.get` result 500s — use `ref(path, { safe: true })`.**
+  `db.get` binds `null` on a no-match, but a nested `ref("owner.user_id")` raises a runtime
+  "Unable to locate var" (HTTP 500) when `owner` is null — an ownership guard throws instead
+  of failing cleanly. Two correct shapes:
+  - Guard existence first — `s.precondition({ expr: expr(ref("owner"), "!=", c.null()),
+    error_type: "notfound", error: c.text("Not found.") })` — then drill WITHOUT `safe`.
+  - Or drill null-safe inside an EXPRESSION or `obj()` operand:
+    `expr(ref("owner.user_id", { safe: true }), "=", auth("id"))` yields `null` (the guard
+    reads `false`) instead of 500ing. Works inside `obj({...})` too — no `s.set_var` hoist needed.
+  ⚠ EXPRESSION and `obj()` operands ONLY — never a `db.*` match argument. `null` is not a
+  legal `fieldValue`/`id`, so a chained get (fetch the child row, then its parent to check
+  the owner) fails with HTTP 400 `Missing param: field_value` one statement BEFORE the guard.
+  There guarding existence first is MANDATORY. `export()` warns on a safe ref in that position.
+  ⚠ That is for a base that EXISTS and may be null. If the base binds nothing at all (a typo),
+  `{ safe: true }` buries the bug as a silent `null` — `export()` warns with a did-you-mean;
+  fix the name instead.
+
+### Stacks and calls
+
+- **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: <Value>, body }`), not from/to. See the
+  authored signatures in `llms/statements-data.md`.
+- **`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>` — 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`.
+- **A helper returning `Statement[]` widens the stack and kills `InferResponse`.**
+  Spreading `...requireX()` where the helper is typed `Statement[]` drops the stack's TUPLE
+  type, so EVERY `ref()`/`as` in that stack — even ones after the spread — resolves to
+  `unknown` and the response types as `StackTupleWidened`. Nothing fails at the helper; it
+  surfaces where the response is consumed, often a frontend typecheck. Fix: return
+  `statements(s.a(...), s.b(...))` — its tuple survives the spread. A helper that builds
+  its array in a LOOP cannot be a tuple; declare `responseShape` on the query there.
+- **Build regex-filter patterns with `c.regex(body, flags?)`, never `c.text`.**
+  The regex filters (`regex_test`/`regex_match`/`regex_replace`/…) are PHP `preg_*`: the
+  piped value is the PATTERN and must be delimiter-wrapped, and the ARGUMENT is the subject.
+  Correct: `withFilters(c.regex(/^[a-z-]+$/i), fl.regex_test(inp("slug")))`.
+  - A bare `c.text("^…$")` is an invalid pattern that matches *nothing* for every input,
+    so a precondition on it silently rejects all values. `c.regex(body, "i")` wraps +
+    escapes it for you (a JS `RegExp` too: `c.regex(/^…$/i)`).
+  - Reversed — subject piped, pattern in the argument — reads correctly, type-checks, and
+    answers false for EVERY input, so an `if (matches) reject` guard admits what it refuses.
+  - Build time refuses both: `withFilters` throws on a bare `c.text` pattern from ANY position
+    in the chain (a normalizer in front of the regex filter is refused too; nothing upstream
+    adds the delimiters) and on a pattern found in the subject slot; `s.expect.to_match` is the
+    same PATTERN slot, refused both ways; a `ref`/`inp` pattern is passed through untouched.
+    `export()` warns on a reversed pair in stored bytes.
+  - Better still: a native typed input (`input.email`) over hand-rolled validation.
+- **An `auth()`-keyed limiter collapses on any host with no caller identity — 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.
+
+### Identity, build, and deploy
+
 - **Same-name siblings collide — queries excepted: their identity carries group + verb.**
   Guids derive from `(type, name)`, so two functions (or tables, toolsets, …) sharing
   a name derive ONE guid and `export()` throws — give them DISTINCT names. A QUERY
@@ -315,137 +347,34 @@ Non-obvious authoring rules:
   is NOT a lasting fix: a lock entry cannot hold two guids, so `export --lock`
   refuses the pair (`export()` warns even unlocked); it 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 — a thunk (`() => import("./seed.json")`) or `seedFile()` — 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 (a frontend imports defs from it for
-  `getPath()`/`InferInput`).
-  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.
-  READING a bundle back is `@xanots/sdk/bundle` — a statement walker (`2.if.0` paths),
-  a structural hash, `mvp:*` catalog, `tableRefOf`.
-- **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.
-  ⚠ A FLOOR — **~267 kB minified (~65 kB gzipped)** for the FIRST def; splitting modules
-  never removes it. The floor is the RUNTIME, not the def: a second or much richer def
-  adds ~2 kB, so trimming a def does not shrink it.
-  Fix: `xanots routes <entry> --emit xano/routes.gen.ts` (`paths` is an accepted alias) — verbs, paths, and sockets as
-  plain data importing NOTHING, still compile-checked: `routePath("GET 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.
+- **`export()` vs `emitBundle()` vs `writeBundle()`:** `export()` returns the bundle object,
+  `emitBundle()` the pretty JSON string, `writeBundle(app, path)` writes it to disk. 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 — a thunk (`() => import("./seed.json")`) or `seedFile()` — is
+  checked only by the `xanots export`/`deploy` CLI path. Seed rows are never emitted into
+  the bundle either way; only `deploy` ships them.
+  - Entry points: the `node:fs` writers (`writeBundle`/`writeArtifact`) and lock-file I/O
+    import from `@xanots/sdk/node`, NOT the browser-safe `@xanots/sdk` entry (a frontend
+    imports defs from it for `getPath()`/`InferInput`). `@xanots/sdk/internal` is the
+    compiler machinery, never needed to author. READING a bundle back is `@xanots/sdk/bundle`
+    — a statement walker (`2.if.0` paths), a structural hash, `mvp:*` catalog, `tableRefOf`.
 - **Intra-workspace imports use `.js` specifiers** (`../tables/links.js`), not
   extensionless — 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** — not `tsx -e "import …"`
-  (its CJS-preparse mis-resolves the package `exports` map → 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 —
-  including ones declared after the spread — 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(...))` — 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: <Value>, 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 — no server-level gate); `agent({...})` carries a
-  typed `llm` block — 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 — `"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? }` — 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` — 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 — 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`/…) are pattern-piped
-  PHP `preg_*`: the piped value is the PATTERN and must be delimiter-wrapped, and the
-  ARGUMENT is the subject. A bare `c.text("^…$")` is an invalid pattern that matches
-  *nothing* for every input, so a precondition on it silently rejects all values.
-  `c.regex(body, "i")` wraps + escapes it for you (a JS `RegExp` too: `c.regex(/^…$/i)`).
-  Reversed — subject piped, pattern in the argument — reads correctly, type-checks, and
-  answers false for EVERY input, so an `if (matches) reject` guard admits what it
-  refuses. `withFilters` throws on a bare `c.text` pattern from ANY position in
-  the chain (a normalizer in front of the regex filter is refused too; nothing upstream
-  adds the delimiters) and on a pattern found in the subject slot; `s.expect.to_match`
-  is the same PATTERN slot, refused both ways; a `ref`/`inp` pattern is passed through untouched.
-  `export()` warns on a reversed pair in stored bytes. Better still:
-  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 — 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 — 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). `export()` warns.
 - **Agents authenticate with env vars — 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 — a misspelled secret must not fall through to whatever
-  credential the runner has. As a file that triple is `{ "type": "token",
-  "instance_base_url": …, "workspace_id": <n>, "meta_api_token": … }`. The older
-  `$XANO_REFRESH_TOKEN` + `$XANO_CLIENT_ID` pair still works but ROTATES: single-use.
+  browser consent no agent can complete. Set all three of `$XANO_INSTANCE_URL`,
+  `$XANO_WORKSPACE_ID`, `$XANO_META_TOKEN` and run `deploy`/`release` directly: no disk, no
+  rotation, so it survives repeated runs.
+  - The triple outranks every other credential (`--config` and `$XANO_REFRESH_TOKEN` included,
+    each named on stderr when displaced). Setting SOME of the three is a hard error, so a
+    misspelled secret cannot fall through to whatever credential the runner has.
+  - As a file: `{ "type": "token", "instance_base_url": …, "workspace_id": <n>,
+    "meta_api_token": … }`. The older `$XANO_REFRESH_TOKEN` + `$XANO_CLIENT_ID` pair still
+    works but ROTATES: single-use.
 - **Event-driven objects fire on an EPHEMERAL.** A `task` (scheduled), an `mcpServer`,
   and every trigger — `tableTrigger` included — run normally on an ephemeral env, which
   is where `deploy` sends them. So test an event-driven design (screen-on-insert, cron
   cleanup, MCP tool call) by deploying it and letting it run.
-- **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": … }`) survives as a key. Export warns.
-- **To match every row, omit `where` — 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 — `inp("clause")`, `ref("built_where")`, or `c.text("id > 0")`.
-- **An `auth()`-keyed limiter collapses on any host with no caller identity — 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.
 
 ## Statements
 

package/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "xanots",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "description": "TypeScript SDK that compiles a typed Xano workspace into the importable packageExport JSON bundle.",
   "coverage": {
     "objectKinds": {
@@ -77,7 +77,7 @@
       {
         "name": "c.obj",
         "signature": "(o?: Json | null) => Value",
-        "description": "Object constant → tag \"const:obj\". A populated one stores an empty {} carrying one `set` filter per key — 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.\"). ⚠ 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\":…} survives as a key) — that is the platform, not this encoding. No argument = the empty object {} — 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 — a nested tagged value (inp/ref/auth/c.*) is rejected; for a computed object response use a record of values, not c.obj."
+        "description": "Object constant → tag \"const:obj\". A populated one stores an empty {} carrying one `set` filter per key — 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.\"). ⚠ 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\":…} survives as a key) — that is the platform, not this encoding. Write c.array([...]) for a list, or prefix the keys (\"k0\") for an object; `export()` warns. No argument = the empty object {} — 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 — 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",
@@ -103,7 +103,7 @@
       {
         "name": "obj",
         "signature": "(fields: Record<string, Value | nested>) => ObjValue<typeof fields>",
-        "description": "Dynamic object value → 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 — 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 — 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 — `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. A constant record or list has two spellings that both work and render identically: bare (`{ a: 1 }`, `[]`) or `c.obj(...)`/`c.array([...])` — prefer the bare form. 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. The legacy blank `c.obj(null)` is refused here (it evaluates to null, not {}) — write c.null() or c.obj(). Still rejected: a filter ARGUMENT that carries its own chain or is a c.now() (a trailing | binds to the whole value, not one argument, and c.now() needs one), a DISABLED filter (an expression string cannot record that), and the output/response/toolset/reg tags — build those in a prior step and ref() them. Use for e.g. s.ai.agent.run args."
+        "description": "Dynamic object value → 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 — and each member may carry a FILTER CHAIN (withFilters + fl.*), which renders as the expression pipe `$var.row|get:\"a.b\"`. A null-safe ref(path, { safe: true }) works inside an obj() member directly. The member record rides the return type, so InferResponse resolves each member the way it resolves a top-level response key — `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. A constant record or list has two spellings that both work and render identically: bare (`{ a: 1 }`, `[]`) or `c.obj(...)`/`c.array([...])` — prefer the bare form. 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. The legacy blank `c.obj(null)` is refused here (it evaluates to null, not {}) — write c.null() or c.obj(). Still rejected: a filter ARGUMENT that carries its own chain or is a c.now() (a trailing | binds to the whole value, not one argument, and c.now() needs one), a DISABLED filter (an expression string cannot record that), and the output/response/toolset/reg tags — build those in a prior step and ref() them. Use for e.g. s.ai.agent.run args."
       },
       {
         "name": "ref",
@@ -309,7 +309,7 @@
       "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 — `\"live\"` warns at compile time.",
+      "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 is the clone trap described in `llms/kinds-core.md`.",
       "registerMethod": "registerWorkflowTests",
       "registered": true
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xanots/sdk",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "description": "XanoTS — your Xano backend as TypeScript. `xanots deploy` ships your typed workspace (and an optional static frontend) to a live, auto-expiring ephemeral environment and prints its URL. init → deploy → URL.",
   "keywords": [
     "xanots",