@xanots/sdk 0.0.11 → 0.0.12

package/dist/{test-command-YAZLKLGQ.js → test-command-YCAR4O35.js}

@@ -4,25 +4,25 @@ import {
 } from "./chunk-NUQCEOKA.js";
 import {
   resolveMetaTarget
-} from "./chunk-ZQ2PKR6R.js";
+} from "./chunk-RQ3FXV4K.js";
 import "./chunk-K5IOND4K.js";
 import {
   getAccessToken
-} from "./chunk-QKM4U5UK.js";
+} from "./chunk-TJS2AF5Y.js";
 import "./chunk-FE5I6S6N.js";
 import {
   fetchOrExplain,
   httpFailure,
   serverMessage
-} from "./chunk-3IGNIP6R.js";
+} from "./chunk-NDP7OUPS.js";
 import {
   parseEnvSelector,
   unknownEnv
-} from "./chunk-CTD5ZCV6.js";
+} from "./chunk-7WRJPKGK.js";
 import {
   UsageError,
   unknownSubcommand
-} from "./chunk-F6CYJ7TN.js";
+} from "./chunk-Z2ZIE5CO.js";
 import "./chunk-GNPVYOPB.js";
 import {
   blank,
@@ -32,7 +32,7 @@ import {
   success,
   warn
 } from "./chunk-EZG76F7R.js";
-import "./chunk-DIA7CT7J.js";
+import "./chunk-V5Y7D4LH.js";
 
 // src/deploy/tests.ts
 var TIMEOUT_MS = 12e4;
@@ -397,4 +397,4 @@ export {
   runSuite,
   runTestCommand
 };
-//# sourceMappingURL=test-command-YAZLKLGQ.js.map
+//# sourceMappingURL=test-command-YCAR4O35.js.map

package/dist/{upgrade-command-BN3EHAOI.js → upgrade-command-GYEIMJBG.js}

@@ -3,30 +3,29 @@ import {
 } from "./chunk-ERQZFWIW.js";
 import {
   refreshAgentFiles
-} from "./chunk-JGCWTCA7.js";
+} from "./chunk-2VTJSI6X.js";
 import {
   isMachineOutput,
   writeJson
 } from "./chunk-NUQCEOKA.js";
-import "./chunk-KA6G2L7U.js";
+import "./chunk-VK26K7AY.js";
 import {
   runNpm
 } from "./chunk-ZSYZTGJH.js";
 import {
   sdkDep
-} from "./chunk-ANUDXFEX.js";
-import "./chunk-Q77KNEUL.js";
+} from "./chunk-RQNMTDXD.js";
 import {
   checkForUpgrade,
   detectInstallMode,
   registryUrl,
   suppressUpdateNotice,
   upgradeCommand
-} from "./chunk-22TKBSDV.js";
-import "./chunk-RCT7UX7B.js";
-import "./chunk-CTD5ZCV6.js";
-import "./chunk-XEOX6AM7.js";
-import "./chunk-F6CYJ7TN.js";
+} from "./chunk-AG5GCZDD.js";
+import "./chunk-XT3XQ4PF.js";
+import "./chunk-7WRJPKGK.js";
+import "./chunk-3LQGF2WS.js";
+import "./chunk-Z2ZIE5CO.js";
 import "./chunk-GNPVYOPB.js";
 import {
   blank,
@@ -36,12 +35,12 @@ import {
   success,
   warn
 } from "./chunk-EZG76F7R.js";
-import "./chunk-OWGCOGKK.js";
-import "./chunk-DIA7CT7J.js";
-import "./chunk-QK7ZQJLP.js";
-import "./chunk-WHOJWOSV.js";
-import "./chunk-VAF6A3YD.js";
-import "./chunk-5XZ744TS.js";
+import "./chunk-QYSQ3UDO.js";
+import "./chunk-V5Y7D4LH.js";
+import "./chunk-N74KDCBD.js";
+import "./chunk-EETVJZAZ.js";
+import "./chunk-XWFRNJMQ.js";
+import "./chunk-2ZCUO2UG.js";
 import "./chunk-OHX6MIUZ.js";
 
 // src/emit/upgrade-command.ts
@@ -176,4 +175,4 @@ function messageOf(err) {
 export {
   runUpgradeCommand
 };
-//# sourceMappingURL=upgrade-command-BN3EHAOI.js.map
+//# sourceMappingURL=upgrade-command-GYEIMJBG.js.map

package/dist/{workspace-2COHDBM3.js → workspace-33KHFLX3.js}

@@ -1,6 +1,6 @@
 import {
   fetchReadOrExplain
-} from "./chunk-3IGNIP6R.js";
+} from "./chunk-NDP7OUPS.js";
 
 // src/deploy/workspace.ts
 var RESOLVE_TIMEOUT_MS = 3e4;
@@ -46,4 +46,4 @@ ${text}`);
 export {
   resolveScopedWorkspaceId
 };
-//# sourceMappingURL=workspace-2COHDBM3.js.map
+//# sourceMappingURL=workspace-33KHFLX3.js.map

package/dist/{workspace-command-MNK7Y7MQ.js → workspace-command-2ZTGT26W.js}

@@ -11,41 +11,39 @@ import {
 } from "./chunk-NUQCEOKA.js";
 import {
   fetchWorkspaceBundle
-} from "./chunk-HYBN4H3F.js";
-import "./chunk-ZQ2PKR6R.js";
+} from "./chunk-PLE5QQOZ.js";
+import "./chunk-RQ3FXV4K.js";
 import "./chunk-K5IOND4K.js";
 import {
   ENV_WORKSPACE,
   getAccessToken
-} from "./chunk-QKM4U5UK.js";
+} from "./chunk-TJS2AF5Y.js";
 import "./chunk-FE5I6S6N.js";
-import "./chunk-7ZYW652H.js";
+import "./chunk-YHS6VVLJ.js";
 import "./chunk-ZUTSMMAG.js";
 import "./chunk-X4DVXBFY.js";
 import {
   fetchOrExplain,
   httpFailure
-} from "./chunk-3IGNIP6R.js";
-import "./chunk-4IF54NU5.js";
-import "./chunk-KA6G2L7U.js";
+} from "./chunk-NDP7OUPS.js";
+import "./chunk-VPAWRBK5.js";
+import "./chunk-VK26K7AY.js";
 import "./chunk-ZSYZTGJH.js";
-import "./chunk-G4EJMQLD.js";
-import "./chunk-LU7TRWMC.js";
-import "./chunk-YBC3IKMF.js";
-import "./chunk-ANUDXFEX.js";
-import "./chunk-Q77KNEUL.js";
-import "./chunk-BSK7ELHU.js";
-import "./chunk-UOZMSF4C.js";
+import "./chunk-YX22LKQE.js";
+import "./chunk-6VNRMKFJ.js";
+import "./chunk-RQNMTDXD.js";
+import "./chunk-PR7OXHGZ.js";
+import "./chunk-GSP2BY4F.js";
 import "./chunk-EHP3WPEG.js";
-import "./chunk-3INK4Y4E.js";
-import "./chunk-BC2C5GVI.js";
-import "./chunk-RCT7UX7B.js";
-import "./chunk-CTD5ZCV6.js";
-import "./chunk-XEOX6AM7.js";
+import "./chunk-AE3PDSDS.js";
+import "./chunk-DCMANKMX.js";
+import "./chunk-XT3XQ4PF.js";
+import "./chunk-7WRJPKGK.js";
+import "./chunk-3LQGF2WS.js";
 import {
   removedSubcommand,
   unknownSubcommand
-} from "./chunk-F6CYJ7TN.js";
+} from "./chunk-Z2ZIE5CO.js";
 import "./chunk-GNPVYOPB.js";
 import {
   formatFields,
@@ -53,12 +51,12 @@ import {
   step,
   success
 } from "./chunk-EZG76F7R.js";
-import "./chunk-OWGCOGKK.js";
-import "./chunk-DIA7CT7J.js";
-import "./chunk-QK7ZQJLP.js";
-import "./chunk-WHOJWOSV.js";
-import "./chunk-VAF6A3YD.js";
-import "./chunk-5XZ744TS.js";
+import "./chunk-QYSQ3UDO.js";
+import "./chunk-V5Y7D4LH.js";
+import "./chunk-N74KDCBD.js";
+import "./chunk-EETVJZAZ.js";
+import "./chunk-XWFRNJMQ.js";
+import "./chunk-2ZCUO2UG.js";
 import "./chunk-OHX6MIUZ.js";
 
 // src/emit/workspace-command.ts
@@ -72,7 +70,7 @@ async function runWorkspaceCommand(args) {
     case "export":
       return runExport(args);
     case "branch": {
-      const { runBranchCommand } = await import("./branch-commands-2BLOC2GR.js");
+      const { runBranchCommand } = await import("./branch-commands-5KMPAAZV.js");
       return runBranchCommand(args);
     }
     case "deploy":
@@ -162,4 +160,4 @@ async function runExport(args) {
 export {
   runWorkspaceCommand
 };
-//# sourceMappingURL=workspace-command-MNK7Y7MQ.js.map
+//# sourceMappingURL=workspace-command-2ZTGT26W.js.map

package/dist/{workspace-export-DURY5WYL.js → workspace-export-MLYTYZS5.js}

@@ -1,10 +1,10 @@
 import {
   exportWorkspaceBundle
-} from "./chunk-7ZYW652H.js";
+} from "./chunk-YHS6VVLJ.js";
 import "./chunk-ZUTSMMAG.js";
 import "./chunk-X4DVXBFY.js";
-import "./chunk-3IGNIP6R.js";
+import "./chunk-NDP7OUPS.js";
 export {
   exportWorkspaceBundle
 };
-//# sourceMappingURL=workspace-export-DURY5WYL.js.map
+//# sourceMappingURL=workspace-export-MLYTYZS5.js.map

package/dist/{xdo-BjJj5W_E.d.ts → xdo-ODuJklk6.d.ts}

@@ -1,5 +1,5 @@
 /**
- * The shared tagged-value primitive (KTD-2). Every place a function references
+ * The shared tagged-value primitive. Every place a function references
  * data — input bindings, statement context, response — uses this `{value, tag,
  * filters}` shape. Built and tested once here, reused everywhere.
  */
@@ -10,7 +10,7 @@ type Value = TaggedValue;
  * A {@link Value} that also carries, **at the type level only**, the name of the
  * stack variable it references (`ref("user")` → `RefValue<"user">`). The `__ref`
  * carrier is phantom — never present at runtime — and required (not optional) so
- * `InferResponse`'s trace (U5) matches only real refs, never a plain `Value`.
+ * `InferResponse`'s trace matches only real refs, never a plain `Value`.
  * Because it is a subtype of `Value`, every existing `ref(...)` use — filter
  * args, `db.query` `where`, response fields — keeps type-checking unchanged.
  */
@@ -41,7 +41,7 @@ type FilteredValue<Base = unknown, Chain extends readonly unknown[] = readonly u
  * an editor's hover distinguishes a pattern from the text beside it.
  *
  * It is deliberately NOT used to restrict `s.expect.to_match` or the `fl.regex_*`
- * pattern slot, which is what issue #213 proposed. A nominal restriction there
+ * pattern slot. A nominal restriction there
  * would have to reject `Value`, and `inp()`, `env()`, `auth()` and `sys.*` all
  * return exactly `Value` — the same type `c.text` does — so it would reject every
  * DYNAMIC pattern along with the broken constant ones. The enforcement is instead
@@ -63,15 +63,15 @@ type FlattenFilters<Fs extends readonly unknown[]> = Fs extends readonly [
  * *statically rejected* where it would silently fail at runtime: inside a
  * `db.edit`/`db.add` `row`, `{tag:"col"}` does not resolve to the row's stored
  * value — it evaluates to `null`, so a following `fl.add(1)` computes `null + 1`
- * and the engine aborts ("Numbers are required for mathematical operations",
- * issue #32). `col()` is only meaningful in a `db.query` `where`/view expression.
+ * and the engine aborts ("Numbers are required for mathematical operations").
+ * `col()` is only meaningful in a `db.query` `where`/view expression.
  */
 type ColValue = Value & {
     readonly __col: true;
 };
 /**
  * The error branch surfaced when a tagged {@link Value} is nested inside a
- * `c.obj`/`c.array` literal (issue #42). The long message is the *property key*
+ * `c.obj`/`c.array` literal. The long message is the *property key*
  * so TypeScript prints it verbatim in the "property … is missing" diagnostic; a
  * `Value` has no such key, so intersecting it here makes the offending position
  * fail to type-check. The runtime guard ({@link assertPlainJson}) carries the
@@ -107,7 +107,7 @@ type BlankTag = Exclude<Extract<Tag, `const${string}`>, "const" | "const:obj">;
 /**
  * Tags {@link c.null} can spell — the two the engine stores a `"null"` value
  * under. `const:null` is the plain one; `const:obj` is the object-typed null a
- * `db.*` statement's `@meta` slot carries (issue #151).
+ * `db.*` statement's `@meta` slot carries.
  *
  * Listed rather than derived: a `"null"` value under any OTHER constant tag is
  * unobserved, and inventing spellings for it would offer an authoring form for
@@ -141,7 +141,7 @@ declare const c: {
      * A `number` that is not an integer, or is past `Number.MAX_SAFE_INTEGER`,
      * **throws**: by the time such a literal reaches here its precision is already
      * gone, so encoding it would write a value the caller did not type. The throw
-     * names the string form. (issue #153)
+     * names the string form.
      */
     int(n: number | bigint | string): Value;
     /**
@@ -181,7 +181,7 @@ declare const c: {
      * null** the engine writes into a `db.*` statement's `@meta` slot —
      * `c.null("const:obj")` → `{tag:"const:obj", value:"null"}`, 16 of them across
      * eight ordinary queries in the survey corpus, which had no spelling and came
-     * back as `rawValue` (issue #151).
+     * back as `rawValue`.
      *
      * ⚠ Not the same bytes as `c.obj(null)`, which is the BLANK object
      * (`value: ""`). Both evaluate to null — the engine JSON-decodes the stored
@@ -195,7 +195,7 @@ declare const c: {
      * (`fl.regex_test`/`regex_match`/`regex_replace`/…). Xano runs PHP `preg_*`, so
      * the pattern MUST be delimiter-wrapped — a bare `c.text("^…$")` is an invalid
      * PCRE and the filter then matches *nothing* for every input, so a precondition
-     * built on it silently rejects all values (issue #128). This wraps the raw
+     * built on it silently rejects all values. This wraps the raw
      * pattern in `/…/`, escapes any interior `/`, and appends `flags`, so the result
      * is always valid; `withFilters` rejects a bare `c.text` pattern and points here.
      *
@@ -216,8 +216,13 @@ declare const c: {
      * `text("now") |to_epoch_ms` chain; both evaluate to the same epoch-ms number
      * on a live engine, and both persist verbatim, but the native tag is what the
      * editor writes and needs no filter to get there. Chain math onto it as usual:
-     * `withFilters(c.now(), fl.epochms_add_ms(c.int(-maxAgeMs)))`. (issues #120,
-     * #145)
+     * `withFilters(c.now(), fl.epochms_add_ms(c.int(-maxAgeMs)))`.
+     *
+     * Inside an `obj()` the tag is flattened into an expression string, where the
+     * identifier `now` alone is the STRING "now" — so `obj()` writes the
+     * `now|to_epochms` coercion that restores this tag's meaning. A `c.now()` used
+     * as a FILTER ARGUMENT there is refused: the coercion cannot be written in
+     * that position. Hoist it with `s.set_var` and `ref()` it.
      */
     now(): Value;
     /**
@@ -226,7 +231,6 @@ declare const c: {
      * compile error and throws at runtime — it would serialize as internal
      * representation the engine can't decode. For a computed/multi-key object
      * response use a record of values (`response: { key: value }`), not `c.obj`.
-     * See issue #42.
      *
      * Called with no argument it is the **empty object**, `{}` — the same default
      * the editor gives a new object variable, and the only empty form current
@@ -243,7 +247,7 @@ declare const c: {
      * same bytes instead of being quietly re-pointed at `{}`.
      *
      * A **populated** object is stored the way the editor stores one: an empty
-     * `{}` base carrying one `set` filter per key (issue #248). It is NOT a
+     * `{}` base carrying one `set` filter per key. It is NOT a
      * populated JSON string — that form fails the request at runtime, see
      * {@link objSetFilters}.
      *
@@ -257,7 +261,7 @@ declare const c: {
     /**
      * Array constant → JSON-string value with `tag:"const:array"`. Takes **plain
      * JSON literals only** — like {@link obj}, a nested tagged value is a compile
-     * error and throws at runtime. See issue #42.
+     * error and throws at runtime.
      */
     array<const T extends readonly unknown[]>(a: T & RejectValues<T>): Value;
     /**
@@ -308,7 +312,7 @@ interface RefOptions {
      * compiles to the raw var path `$owner.user_id`, which the engine resolves in
      * a single lookup — so when the base var `owner` is null (e.g. a `db.get` that
      * matched no row), it raises a runtime `ERROR_FATAL` "Unable to locate var"
-     * (HTTP 500) instead of yielding null (issue #47).
+     * (HTTP 500) instead of yielding null.
      *
      * With `safe: true` the path compiles through the `get` filter
      * (`$owner|get:"user_id"`), which walks the remaining path and resolves to
@@ -324,7 +328,7 @@ interface RefOptions {
  *
  * Pass `{ safe: true }` to make a *nested* path null-safe: `ref("owner.user_id",
  * { safe: true })` resolves to null instead of 500ing when the base `owner` is
- * null (issue #47) — the intent-revealing opt-in for drilling into a `db.get`
+ * null — the intent-revealing opt-in for drilling into a `db.get`
  * result that may not exist.
  *
  * Picking a reference helper (these are easy to mix up):
@@ -339,7 +343,7 @@ declare function ref<const Name extends string>(name: Name, opts?: RefOptions):
 /**
  * The second parameter every non-`ref` reference creator declares, so that
  * passing `{ safe: true }` to one is a COMPILE error whose expected type is the
- * explanation (issue #80).
+ * explanation.
  *
  * `safe` was silently dropped before this: the creators took one parameter, so
  * JavaScript discarded the extra argument and TypeScript never saw it. An
@@ -353,7 +357,7 @@ declare function inp(name: string, opts?: SafeIsRefOnly): Value;
  * Reference a table **column**: `{tag:"col", value}` (used in `db.query` `where` +
  * table views). See {@link ref} for the full picker. The return is branded
  * {@link ColValue} so it is a *compile error* to pass `col()` into a `db.edit`/
- * `db.add` `row` — where it would resolve to `null` at runtime (issue #32).
+ * `db.add` `row` — where it would resolve to `null` at runtime.
  */
 declare function col(name: string, opts?: SafeIsRefOnly): ColValue;
 /**
@@ -422,7 +426,7 @@ type ToolsetPath = "token" | "params" | `params.${string}`;
  * - `toolset("params.tenant")` — one parameter out of that object.
  *
  * Only bound while a tool runs under its toolset; anywhere else it reads empty
- * (issue #152).
+ *.
  */
 declare function toolset(path: ToolsetPath, opts?: SafeIsRefOnly): Value;
 /**
@@ -745,7 +749,7 @@ declare function test(def: TestDef): TestDef;
  * The SDK emits only authored fields. Server/auto-generated keys (`id`,
  * `created_at`, `_xsid`, `@guid`, `@index`, `guid`, `_draft`, `stack_id`, …)
  * are generated by the engine on import and are NEVER emitted here; the test
- * normalizer (U6) strips them from the fixture before comparison.
+ * normalizer strips them from the fixture before comparison.
  */
 /**
  * Xano tagged-value tags (verified against the Xano engine). The runtime
@@ -779,7 +783,7 @@ interface FilterXdo<N extends string = string> {
      * Required here until now, which made a pulled workspace fail its own
      * type-check: codegen emits a stored filter verbatim when no `fl.*` form
      * reproduces it, and a verbatim emit of a filter stored without the key does
-     * not have it (issue #134). Writing `disabled: false` in would have been the
+     * not have it. Writing `disabled: false` in would have been the
      * other repair, and it is the wrong one — it ADDS a key the engine did not
      * store, so the re-encode would no longer match the stored bytes and the value
      * would degrade further rather than round-trip.
@@ -810,7 +814,7 @@ interface MethodXdo {
 }
 /**
  * A field-bearing entry — the shape shared by function/query inputs and table
- * columns (KTD-6). In the persisted form the two are byte-identical: both use
+ * columns. In the persisted form the two are byte-identical: both use
  * `customize:{}`, numeric `market_item` ids, an `_xsid` placeholder, and a
  * present `description`. (The older parser generation emitted `customize:""` /
  * string ids for inputs; the live `mvp_query`/`mvp_dbo` rows show they converge.)

package/guides/authoring.md

@@ -137,6 +137,13 @@ auto-assigned `id`/`created_at`, `s.db.del` binds `null`, and `edit`/`del` **thr
   the engine reads the operand as a text literal and fails at runtime with a parse error
   naming the *other* operand, so `db.query` rejects that spelling at export instead.
 
+- **A join adds no columns to the returned row.** With or without a `bind`, a row is the
+  queried table's columns — which is what `InferResponse` types, so there is no `row.author`
+  to read. To bring a joined column back, project it with an `eval` whose `name` is the dotted
+  path: `eval: [{ name: "author.name", as: "author_name" }]` puts `author_name` on the row and
+  on the inferred type. A *bare* name there fails at runtime (it qualifies to the base table),
+  and a dotted joined column in `output` is dropped with no error.
+
 - **Paging changes the response shape.** Supplying `paging` with metadata on (the default)
   returns a **paging envelope** — `{ items, curPage, nextPage, prevPage, offset, perPage,
   itemsReceived }`, plus totals when `totals: true` — instead of a bare `Row[]`, and
@@ -194,8 +201,10 @@ auto-assigned `id`/`created_at`, `s.db.del` binds `null`, and `edit`/`del` **thr
   `lower`, and the `epochms_add_day` / `epochms_sub_month` family). The request-time timestamp
   filters do not — `epochms_transform`, `epochms_add_ms`, `epochms_add_secs`, `epochms_date`,
   `epochms_from_format` — and the engine doesn't degrade gracefully: the request dies with a
-  bare fatal naming nothing. For a relative cutoff, use the SQL-side spelling or compute it in
-  an earlier `s.set_var` and `ref()` that. `export()` warns; a bare `c.now()` is always fine.
+  bare fatal naming nothing. For a relative cutoff, use the SQL-side spelling — by raw name,
+  since `fl.*` carries no builder for that family: `filter("epochms_add_day", …)` or the raw
+  `{ name, arg }` form — or compute it in an earlier `s.set_var` and `ref()` that. `export()`
+  warns; a bare `c.now()` is always fine.
 - **A `s.switch` case without `break: true` falls through.** The engine's default is
   fallthrough, so a matched case also runs every *later* case body — and the `default` block
   too. Whatever those bodies write gets written two or three times, at HTTP 200, with `tsc`

package/guides/typed-frontend.md

@@ -157,10 +157,10 @@ also pulls whatever its `stack` builds — the `s.*`/`c.*` factory *calls* run a
 to construct the def, so they can't be tree-shaken out. Types are free (`InferInput`/
 `InferRow` erase to nothing — use `import type`). That cost is a **floor**, not a function of
 how lean the def is. Measured on a Vite lib build against the published package: one
-`apiGroup` + one empty `query`, imported for a single `getPath()`, is **289 kB minified
-(57 kB gzipped)** against 56 B for a hand-written path string. A realistic def — two
+`apiGroup` + one empty `query`, imported for a single `getPath()`, is **267 kB minified
+(65 kB gzipped)** against 56 B for a hand-written path string. A realistic def — two
 tables, a foreign key, a typed input, a `db.query` with a `where` and a sort, plus a
-second endpoint — measures 290 kB. That 1 kB spread is the point: the floor is the SDK
+second endpoint — measures 269 kB. That 2 kB spread is the point: the floor is the SDK
 runtime itself, so splitting modules or simplifying a def does not move it, and the cost
 is paid by importing any def at all.
 
@@ -172,7 +172,7 @@ xanots routes ./xano/index.ts --emit xano/routes.gen.ts
 ```
 
 The emitted file is plain data plus one interpolator and imports nothing at all — the same
-app builds to 1.3 kB, a 214x saving, with no SDK code in the output. Route names and their `{param}` keys are still checked at compile
+app builds to 1.3 kB, a ~200x saving, with no SDK code in the output. Route names and their `{param}` keys are still checked at compile
 time, so a backend rename is a compile error rather than a 404:
 
 ```ts

package/llms/statements-data.md

@@ -34,13 +34,14 @@ primary key `id`):
     - ⚠ `like`/`ilike` take the operand as the PATTERN, verbatim: a bare term matches only an exact whole-string equal, and the endpoint answers HTTP 200 with zero rows — nothing reports a problem, so a search box that matches nothing ships. For substring matching use `includes`/`not includes`, which wrap the operand in `%…%` themselves and match case-INSENSITIVELY. Prefer them over a hand-built `"%" + term + "%"`, which is non-empty even for an empty term and so defeats `ignoreEmpty`; `includes` composes with it. `contains`/`@>`/`overlaps` are JSON/array containment, not text — on a text column they 400 `ParseError: Invalid value for param`.
     - 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 — the engine compiles the string and arithmetic filters (`trim`, `concat`, `upper`, `lower`, …) into the SQL.
-    - ⚠ 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`, …) or compute it in an earlier `s.set_var` and `ref()` that. `export --strict` reports it; a bare `c.now()` operand is always fine.
+    - ⚠ 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`, …) — by raw name, since `fl.*` has no builder for them — 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? }]` — joins (`context.bind[]`). `join` defaults to `"inner"`. `as` defaults to the table name; two joins to the same table need distinct aliases.
     - ⚠ 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`) — 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")) }]`
+    - ⚠ A join does NOT put the joined table's columns on the returned row — with or without a `bind`, a row is the QUERIED table's columns, which is what `InferResponse` types. There is no `row.team_row`. To read a joined column, PROJECT it with an `eval` whose `name` is the dotted path: `eval: [{ name: "team_row.name", as: "team_name" }]` puts `team_name` on the row and on the inferred type. A bare `name` there is `Unsupported parameter reference` at runtime (it qualifies to the base table), and a dotted joined column in `output` is dropped with no error.
   - `returnType` — `"list"` (default) | `"single"` | `"count"` | `"exists"` | `"stream"` | `"aggregate"`. Drives `context.return.type` AND the `InferResponse` shape: `count`→`number`, `exists`→`boolean`, `single`→`Row|null`, `stream`→`Row[]` (pageable, no envelope), `list`→`Row[]`/envelope, `aggregate`→rows keyed by the `aggregate.group`/`eval` aliases. ⚠ A bare `count` of ZERO serializes as an EMPTY body, not `0` — 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? }]` — 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"`) — 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`.
+    - 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. ⚠ `fl.*` carries NO builder for these — reach them by raw name, `filter("epochms_add_day", …)` or the `{ name, arg }` form. The name lists are `QUERY_EXPRESSION_FILTERS`/`VECTOR_FILTERS` on `@xanots/sdk/internal`.
     - **Vector similarity search** — 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`↔`vector_cosine_ops`, `vector_l2_distance`↔`vector_l2_ops`, `vector_l1_distance`↔`vector_l1_ops`, `vector_inner_product`↔`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`.
     - ⚠ Write each `name` as a **bare** column (`"status"`). It is alias-qualified to `"<alias>.status"` on emit — the engine rejects an unqualified column in an aggregate with `Unsupported param format`. An already-dotted `name` (a `bind`ed/joined column) passes through.

package/llms/values.md

@@ -12,7 +12,7 @@
 - `c.array(a: Json[]) => Value` — Array constant (JSON string) → tag "const:array". Plain JSON literals only — a nested tagged value is rejected, same as c.obj.
 - `c.expression(source: string) => Value` — Xano Expression Engine source, passed through VERBATIM → tag "const:expr2". The string IS the expression: c.expression('"Hi, " ~ $input.name'), c.expression("$var.price * $var.qty"). ⚠️ NOT VALIDATED — 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) — prefer ref/inp/col, withFilters+fl.*, and obj() (which BUILDS a checked expression). Not the expr() condition builder.
 - `c.now() => Value` — Current time as epoch-ms — 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.
-- `obj(fields: Record<string, Value | nested>) => ObjValue<typeof fields>` — 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([...])` — reach for the bare form, it is shorter. 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 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 — build those in a prior step and ref() them. Use for e.g. s.ai.agent.run args.
+- `obj(fields: Record<string, Value | nested>) => ObjValue<typeof fields>` — 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.
 - `ref(name: string, opts?: { safe?: boolean }) => Value` — Reference a stack variable → tag "var". Pass { safe: true } for null-safe nested access — 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.
 - `inp(name: string) => Value` — Reference a function/endpoint input → tag "input". Resolves ONLY against the `input` block of the def it sits in — 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 — 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`).
 - `col(name: string) => Value` — Reference a table column → tag "col".

package/llms-full.txt

@@ -1,4 +1,4 @@
-# xanots v0.0.11
+# xanots v0.0.12
 
 > TypeScript SDK that compiles a typed Xano workspace into the importable packageExport JSON bundle.
 
@@ -16,27 +16,26 @@ caller, `c.*` a constant — resolved at request time; JS operators over them do
 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).
-Not authorable here: branch, market_item, realtime_channel, run.job, run.service, tablemap — these cannot be authored and do not survive a pull; see `coverage.objectKinds.unmodeled` in `manifest.json`.
+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
-below — open the one whose condition matches the task, and skip the rest. For
-exhaustive per-entry detail in NEITHER — a statement's full field schema with engine
-defaults, a filter's complete argument list, the engine `storedName` mapping — do a
-TARGETED lookup in the shipped `manifest.json` (a program imports it as
-`@xanots/sdk/manifest.json`, which Node ESM needs `with { type: "json" }` on;
-grep or `jq` the one entry you need;
-it is ~65k tokens, so never read it whole). Its top-level keys are `name`, `version`, `description`, `coverage`, `values`, `objectKinds`, `fieldTypes`, `statements`, `filters`, `cli`, `cliGlobalFlags`. `statements` and `filters` are ARRAYS, not maps — SELECT, do not index:
+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
+lookup in the shipped `manifest.json` (a program imports it as
+`@xanots/sdk/manifest.json`, needing `with { type: "json" }` in Node ESM;
+it is ~60k tokens, so never read it whole). Its top-level keys are `name`, `version`, `description`, `coverage`, `values`, `objectKinds`, `fieldTypes`, `statements`, `filters`, `cli`, `cliGlobalFlags`. `statements` and `filters` are ARRAYS, not maps — SELECT, do not index:
   jq '.statements[] | select(.sPath=="db.get")' manifest.json
   jq '.filters[]    | select(.name=="json_decode")' manifest.json
+⚠ `fields` is null on the 65 `declarative: false` statements (`db.get`, …): typed wrappers whose arguments are the factory's `.d.ts` signature. Null ≠ missing.
 Select a statement on `sPath` (the `s.*` path you write), NOT `surface` (the XanoScript term): 24 of 214 differ — `var`→`set_var`, `break`→`foreach_break`, `foreach.remove`→`foreach_remove`, and every `expect.*`.
 
 ## Topic files
 
-Each line is a condition on the task. Open the files whose condition matches and
-skip the rest — paths are relative to this file (`node_modules/@xanots/sdk/` once
-installed), so a 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.
+Paths are relative to this file (`node_modules/@xanots/sdk/` once installed), so a
+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.
 - [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.
@@ -336,9 +335,9 @@ Non-obvious authoring rules:
   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 — **~289 kB minified (~57 kB gzipped)** for the FIRST def; splitting modules
+  ⚠ 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 def, or a much richer
-  one, adds ~1 kB — so reducing what a def does will not reduce it.
+  one, adds ~2 kB — so reducing what a def does will not reduce 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("blog/{slug}", { slug })`,
   `channelPath("rooms/{room_id}", { room_id })`, `socketUrl("chat", baseUrl)` (tenant base
@@ -815,13 +814,14 @@ primary key `id`):
     - ⚠ `like`/`ilike` take the operand as the PATTERN, verbatim: a bare term matches only an exact whole-string equal, and the endpoint answers HTTP 200 with zero rows — nothing reports a problem, so a search box that matches nothing ships. For substring matching use `includes`/`not includes`, which wrap the operand in `%…%` themselves and match case-INSENSITIVELY. Prefer them over a hand-built `"%" + term + "%"`, which is non-empty even for an empty term and so defeats `ignoreEmpty`; `includes` composes with it. `contains`/`@>`/`overlaps` are JSON/array containment, not text — on a text column they 400 `ParseError: Invalid value for param`.
     - 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 — the engine compiles the string and arithmetic filters (`trim`, `concat`, `upper`, `lower`, …) into the SQL.
-    - ⚠ 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`, …) or compute it in an earlier `s.set_var` and `ref()` that. `export --strict` reports it; a bare `c.now()` operand is always fine.
+    - ⚠ 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`, …) — by raw name, since `fl.*` has no builder for them — 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? }]` — joins (`context.bind[]`). `join` defaults to `"inner"`. `as` defaults to the table name; two joins to the same table need distinct aliases.
     - ⚠ 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`) — 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")) }]`
+    - ⚠ A join does NOT put the joined table's columns on the returned row — with or without a `bind`, a row is the QUERIED table's columns, which is what `InferResponse` types. There is no `row.team_row`. To read a joined column, PROJECT it with an `eval` whose `name` is the dotted path: `eval: [{ name: "team_row.name", as: "team_name" }]` puts `team_name` on the row and on the inferred type. A bare `name` there is `Unsupported parameter reference` at runtime (it qualifies to the base table), and a dotted joined column in `output` is dropped with no error.
   - `returnType` — `"list"` (default) | `"single"` | `"count"` | `"exists"` | `"stream"` | `"aggregate"`. Drives `context.return.type` AND the `InferResponse` shape: `count`→`number`, `exists`→`boolean`, `single`→`Row|null`, `stream`→`Row[]` (pageable, no envelope), `list`→`Row[]`/envelope, `aggregate`→rows keyed by the `aggregate.group`/`eval` aliases. ⚠ A bare `count` of ZERO serializes as an EMPTY body, not `0` — 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? }]` — 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"`) — 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`.
+    - 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. ⚠ `fl.*` carries NO builder for these — reach them by raw name, `filter("epochms_add_day", …)` or the `{ name, arg }` form. The name lists are `QUERY_EXPRESSION_FILTERS`/`VECTOR_FILTERS` on `@xanots/sdk/internal`.
     - **Vector similarity search** — 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`↔`vector_cosine_ops`, `vector_l2_distance`↔`vector_l2_ops`, `vector_l1_distance`↔`vector_l1_ops`, `vector_inner_product`↔`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`.
     - ⚠ Write each `name` as a **bare** column (`"status"`). It is alias-qualified to `"<alias>.status"` on emit — the engine rejects an unqualified column in an aggregate with `Unsupported param format`. An already-dotted `name` (a `bind`ed/joined column) passes through.
@@ -939,7 +939,7 @@ Microservices (the `microservice()` def and the statement that calls it):
 - `c.array(a: Json[]) => Value` — Array constant (JSON string) → tag "const:array". Plain JSON literals only — a nested tagged value is rejected, same as c.obj.
 - `c.expression(source: string) => Value` — Xano Expression Engine source, passed through VERBATIM → tag "const:expr2". The string IS the expression: c.expression('"Hi, " ~ $input.name'), c.expression("$var.price * $var.qty"). ⚠️ NOT VALIDATED — 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) — prefer ref/inp/col, withFilters+fl.*, and obj() (which BUILDS a checked expression). Not the expr() condition builder.
 - `c.now() => Value` — Current time as epoch-ms — 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.
-- `obj(fields: Record<string, Value | nested>) => ObjValue<typeof fields>` — 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([...])` — reach for the bare form, it is shorter. 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 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 — build those in a prior step and ref() them. Use for e.g. s.ai.agent.run args.
+- `obj(fields: Record<string, Value | nested>) => ObjValue<typeof fields>` — 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.
 - `ref(name: string, opts?: { safe?: boolean }) => Value` — Reference a stack variable → tag "var". Pass { safe: true } for null-safe nested access — 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.
 - `inp(name: string) => Value` — Reference a function/endpoint input → tag "input". Resolves ONLY against the `input` block of the def it sits in — 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 — 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`).
 - `col(name: string) => Value` — Reference a table column → tag "col".