@xanots/sdk 0.0.11 → 0.0.13

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-A75DOIUH.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-2AY3PKF4.js";
+import "./chunk-RLI6XD4O.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-MEFMTICH.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-A75DOIUH.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-YELP47SJ.js}

@@ -11,41 +11,39 @@ import {
 } from "./chunk-NUQCEOKA.js";
 import {
   fetchWorkspaceBundle
-} from "./chunk-HYBN4H3F.js";
-import "./chunk-ZQ2PKR6R.js";
+} from "./chunk-SS2V2QOG.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-S3DOJOW4.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-BYQHCCYU.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-RLI6XD4O.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-MEFMTICH.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-YELP47SJ.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,15 +172,32 @@ 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
-time, so a backend rename is a compile error rather than a 404:
+app builds to 1.3 kB, a ~200x saving, with no SDK code in the output. Route keys and their
+`{param}` names are still checked at compile time, so a backend rename is a compile error
+rather than a 404:
 
 ```ts
 import { routePath, ROUTES } from "../xano/routes.gen";
 
-fetch(BASE + routePath("blog/{slug}", { slug }), { method: ROUTES["blog/{slug}"].verb });
+fetch(BASE + routePath("GET blog/{slug}", { slug }), {
+  method: ROUTES["GET blog/{slug}"].verb,
+});
+```
+
+A route key is `"<VERB> <name>"`, which is the endpoint identity the engine itself uses —
+so verb-differentiated siblings are ordinary, and a REST-shaped group emits without
+renaming anything:
+
+```ts
+routePath("GET listings");                  // list
+routePath("POST listings");                 // create
+routePath("PATCH listings/{id}", { id });   // update
 ```
 
+The verb comes first so the key is stable: adding a `POST` sibling never renames the `GET`
+that was already there. Two api groups holding the same verb AND name is the one shape a
+single manifest cannot express, and the emit fails naming both rather than picking one.
+
 Realtime is in the same file when the workspace has any: `socketUrl(server, baseUrl)` for the
 websocket URL and `channelPath(channel, params)` for the path a frame's `channel` field takes,
 both keyed and `{param}`-checked exactly like the routes. `socketUrl` is the equivalent of

package/llms/kinds-realtime.md

@@ -20,11 +20,11 @@
     - `deliverTo?`: `"channel"` (default) | `"sender"` | `"others"` | `"explicit"`. ⚠ `"explicit"` still delivers to NOBODY — nothing selects recipients from inside a handler, and `s.realtime.publish` (which originates an event INTO a channel) is not a substitute.
     - Only `"channel"`/`"others"` fan out AND are written to the `conversation` transcript — a `"sender"` response is invisible to every future joiner.
   - **Both input surfaces read as ordinary inputs:** `inp("body")` for a payload field, `inp("room_id")` for the channel's `{room_id}`. No session lookup, no frame parsing.
-    - A path param is bound ONCE at join and read from the connection thereafter, never from the frame — a sender cannot claim a room it did not join. The same values reach a channel `join`/`leave` trigger's stack.
+    - A path param is bound ONCE at join and read from the connection thereafter, never from the frame — a sender cannot claim a room it did not join.
   - `s.realtime.get_session({ as })` — the CALLER's realtime session for the current frame. FLAT shape:
     - `authenticated` bool · `client_id` text (the AUTHED ROW ID as text, `""` anonymous) · `dbo_id` int (the auth TABLE's id — NOT the user's row id; `0` anonymous — to look the caller up use `client_id`. `dbo_id` is an int in the same position and typechecks, so a gate that keys on it finds no user and refuses EVERYONE) · `socket_id` int (transport id) · `channel` text (resolved path, `""` in a server trigger) · `params` object (bound path params, `{}` when none — `ref("session.params.room_id")`) · `extras` object · `opened_at` decimal.
     - Works in a realtime MESSAGE stack and in CHANNEL and SERVER trigger stacks; off that path it degrades to an anonymous session.
-    - For a path param prefer `inp("room_id")`. Reach for the session when you need the CONNECTION (identity/extras) — "who is this sender" on an anonymous-client channel.
+    - For a path param prefer `inp("room_id")` in a MESSAGE; a lifecycle TRIGGER has only the session. Reach for the session when you need the CONNECTION (identity/extras) — "who is this sender" on an anonymous-client channel.
     - ⚠ THREE UNRELATED THINGS ARE CALLED A CLIENT ID: `session.client_id` (app-facing identity), `session.socket_id` (transport), and a frame's `options.client_id` (the at_least_once CURSOR handle). Conflating the first and last breaks at_least_once for anonymous clients.
   - `s.realtime.publish({ server, channel, data, message?, authTable?, authId? })` — the PUSH direction: originate a server-authored event onto a channel from ANY stack, no client frame first.
     - `server` is the handle or its NAME (resolved by name, not guid); `channel` is the FILLED-IN path (`channel.getChannel({ room_id: 42 })`), never the template — a constant still carrying `{param}` THROWS at author time, and a constant `server`/`channel` naming nothing this workspace registers WARNS at export.

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/tests.md

@@ -42,7 +42,7 @@ The run is isolated in ways that make a correct test fail for reasons the failur
 
 - The run uses an EMPTY datasource, so **no `table({ seed })` rows exist while it runs** and every `db` read misses. A test that buys seeded row 1 fails with its own precondition message, which reads as a wrong id rather than an empty database. Create what the test needs INSIDE the test — typically a `defineFunction` fixture the stack calls first.
 - `s.api.call` does NOT raise when the endpoint answers with an error. It BINDS the error envelope (`{code, message}`) to its `as` and carries on, so a later `s.expect.to_be_defined({ expr: ref("r.field") })` reports the ASSERTION while the real failure was the call, four statements up. Assert on the envelope — `s.expect.to_contain({ expr: ref("r.code"), value: c.text("ERROR_CODE_INPUT_ERROR") })` — when a call may fail. `s.function.run` raises instead; the two disagree.
-- `s.expect.to_throw({ body, exception? })` runs `body` in an ISOLATED var stack, so a variable bound EARLIER in the test is not visible inside it — bind what the body needs inside the body. `exception` is a `Value` whose text the raised message must CONTAIN (`c.text("already exists")`, not a bare string); omit it to accept any error.
+- `s.expect.to_throw({ body, exception? })` runs `body` in an ISOLATED var stack, so a variable bound EARLIER in the test is not visible inside it — bind what the body needs inside the body. An outer one raises `Missing var entry: <name>` there, which the test reports as `to_throw` not matching (`export()` warns). `exception` is a `Value` whose text the raised message must CONTAIN (`c.text("already exists")`, not a bare string); omit it to accept any error.
 - `s.expect.to_throw` catches such a call only when the error carries a MESSAGE. `ERROR_CODE_ACCESS_DENIED` arrives with an empty one, so `to_throw` around an auth-refused call reports `to_throw failed - response is ok` — which reads as a broken auth gate on a gate that works.
 - An endpoint's `auth` gate is NOT enforced on `s.api.call`. A `query({ auth: users })` runs anyway and fails only where its stack dereferences `auth(...)`. A stack that never touches `auth(...)` runs unauthenticated and passes.
 - Neither `auth.token` nor an `Authorization` entry in `headers` authenticates the call — a token that answers 200 over real HTTP is refused here. To cover auth-gated logic, move the body into a `defineFunction` taking the user id and `s.function.call` that; the gate itself is not reachable from a workflow test.

package/llms/triggers.md

@@ -15,8 +15,8 @@ realtimeChannelTrigger, mcpServerTrigger, agentTrigger, workspaceTrigger,
 errorTrigger}({ name, guid?, description?, active?, tags?, ... })`.
 
 - `tableTrigger({ name, table?, datasources?, actions?: {insert?,update?,delete?,truncate?}, stack })` — database/table trigger. `t.new` / `t.old` are the row **after** / **before** the change; `t.action` (`insert|update|delete|truncate`), `t.datasource`. Bind `table` to a `table()` handle and `t.new("col")` / `t.old("col")` are typed to that row (misspelled column = compile error). Nullability follows the enabled actions: insert → `old` is null, delete → `new` is null, update → both, truncate → neither. Config-only (no response).
-- `realtimeServerTrigger({ name, realtimeServer, actions?: {connect?,disconnect?}, stack?, response?, responseShape? })` — realtime SERVER lifecycle (a client connecting to / disconnecting from the server, not a message). Inputs: `t.action` (`connect|disconnect`), `t.realtime_server`, `t.client`. Bind `realtimeServer` to a `realtimeServer()` handle (or its name). `connect` GATES the connection — a denial sends an `error` and CLOSES the socket with code 4401 before it is ever ready, so it is a real front door, not an observer; same return shape as a channel `join` (`{ allowed: c.bool(true) }` or any truthy value admits, EMPTY/FALSY DENIES — INCLUDING a gating trigger with NO `response`, which returns nothing and so refuses every client). A CRASH DENIES too — the transport seeds a deny and keeps it on a throw. Both failure modes lock the door, so plan for a self-inflicted LOCKOUT (an unguarded drill into a null `db.get` raises → everyone refused), not a breach. Gating is OPT-IN: a server with no `connect` trigger accepts every connection. `disconnect` is OBSERVATIONAL (return ignored, throws swallowed — cleanup must always complete). Both are SERVER-scoped, so `s.realtime.get_session` works but carries no channel path and no bound params.
-- `realtimeChannelTrigger({ name, channel, actions?: {join?,leave?,deliver?}, stack?, response?, responseShape? })` — realtime CHANNEL lifecycle. Inputs: `t.action` (`join|leave|deliver`), `t.channel`, `t.client`. Bind `channel` to a `realtimeChannel()` handle — a bare path is NOT accepted (it is unique only within its server). The three actions have DIFFERENT postures, and the posture decides what the stack should return: `join` GATES the join (it runs BEFORE the client becomes a member, so a denial means it never sees a fan-out) — return `{ allowed: c.bool(true) }` (optional `reason` reaches the client) or any truthy value to admit, and an EMPTY OR FALSY RETURN DENIES, so a stack that just falls through — or a gating trigger with NO `response` — refuses everyone, and a CRASH DENIES too. That is the inverse of a normal message (a crashing message still delivers) and of `deliver` below (a gate that fails OPEN). `join`/`leave` bind the channel's typed path params as INPUTS, so `inp("room_id")` resolves and the gate decides per room; a SERVER connect/disconnect has no channel, the one place a path param cannot be read; `leave` is OBSERVATIONAL (return ignored, throws swallowed); `deliver` GATES delivery PER RECIPIENT — the per-viewer redaction tool and the most expensive action here (a stack per recipient per message), and it needs `delivery.perRecipient` on the channel to run at all — BOTH HALVES are required, so a `deliver` trigger on a channel without the flag NEVER RUNS and every subscriber receives the UNREDACTED payload (no error, no log line); `export()` warns on each half alone. **`deliver`'s RETURN VALUES DO NOT READ LIKE A FILTER:** ONLY an explicit NULL drops the message for that recipient; an OBJECT replaces that recipient's payload; ANYTHING ELSE — INCLUDING `false`, `0`, `""` — DELIVERS IT UNCHANGED, as does a crash. So `return false` from a yes/no redaction check SENDS the message it was written to suppress — return null instead. The delivered payload arrives NESTED, so read `inp("payload").<field>`, and `t.client` is the SENDER while `s.realtime.get_session` describes the RECIPIENT this run is for.
+- `realtimeServerTrigger({ name, realtimeServer, actions?: {connect?,disconnect?}, stack?, response?, responseShape? })` — realtime SERVER lifecycle (a client connecting to / disconnecting from the server, not a message). Inputs: `t.action` (`connect|disconnect`), `t.realtime_server`, `t.client`. Bind `realtimeServer` to a `realtimeServer()` handle (or its name). `connect` GATES the connection — a denial sends an `error` and CLOSES the socket with code 4401 before it is ever ready, so it is a real front door, not an observer; same return shape as a channel `join` below (EMPTY/FALSY DENIES — INCLUDING a gating trigger with NO `response`, which returns nothing and so refuses every client). A CRASH DENIES too — a gate that cannot answer must not admit. Both failure modes lock the door, so plan for a self-inflicted LOCKOUT (an unguarded drill into a null `db.get` raises → everyone refused), not a breach. Gating is OPT-IN: a server with no `connect` trigger accepts every connection. `disconnect` is OBSERVATIONAL (return ignored, throws swallowed — cleanup must always complete). Both are SERVER-scoped, so `s.realtime.get_session` works but carries no channel path and no bound params.
+- `realtimeChannelTrigger({ name, channel, actions?: {join?,leave?,deliver?}, stack?, response?, responseShape? })` — realtime CHANNEL lifecycle. Inputs: `t.action` (`join|leave|deliver`), `t.channel`, `t.payload`, `t.client`. Bind `channel` to a `realtimeChannel()` handle — a bare path is NOT accepted (it is unique only within its server). The three actions have DIFFERENT postures, and the posture decides what the stack should return: `join` GATES the join (it runs BEFORE the client becomes a member, so a denial means it never sees a fan-out) — return `{ allowed: c.bool(true) }` (optional `reason` reaches the client) or any truthy value to admit, and an EMPTY OR FALSY RETURN DENIES, so a stack that just falls through — or a gating trigger with NO `response` — refuses everyone, and a CRASH DENIES too. ONCE the object carries an `allowed` key admission needs STRICTLY `true` — a computed `1`/`"yes"` there DENIES. That is the inverse of a crashing message, which still delivers, and of `deliver` below. A lifecycle trigger's inputs are PINNED to those four, so a channel PATH PARAM is NOT among them — `inp("room_id")` RAISES, which crashes the gate and so REFUSES every client; take the param from `s.realtime.get_session` (`ref("session.params.room_id")`). A gate establishes NO auth, so `ref("auth.id")` reads 0 even when authenticated — identity is `t.client("permissions.dbo_id")` or the session. A SERVER connect/disconnect has no channel, so no params at all; `leave` is OBSERVATIONAL (return ignored, throws swallowed); `deliver` GATES delivery PER RECIPIENT — the per-viewer redaction tool and the most expensive action here (a stack per recipient per message), and it needs `delivery.perRecipient` on the channel to run at all — BOTH HALVES are required, so a `deliver` trigger on a channel without the flag NEVER RUNS and every subscriber receives the UNREDACTED payload (no error, no log line); `export()` warns on each half alone. **`deliver`'s RETURN VALUES DO NOT READ LIKE A FILTER:** ONLY an explicit NULL drops the message for that recipient; an OBJECT replaces that recipient's payload; ANYTHING ELSE — INCLUDING `false`, `0`, `""` — DELIVERS IT UNCHANGED, as does a crash. So `return false` from a yes/no redaction check SENDS the message it was written to suppress — return null instead. The delivered payload arrives NESTED, so read `t.payload("<field>")`, and `t.client` is the SENDER while `s.realtime.get_session` describes the RECIPIENT this run is for.
 - `mcpServerTrigger({ name, mcpServer, stack?, response?, responseShape? })` / `agentTrigger({ name, agent, stack?, response?, responseShape? })` — toolset connection. Bind with the `mcpServer()`/`agent()` def handle (or its name) — it resolves to the toolset guid at export. Raw numeric `objId` is the escape hatch, rarely right: ids are assigned at import, so a handle passed to `objId` is a type error, and binding nothing deploys a trigger that never fires. Inputs: `t.toolset` (`t.toolset("name")`), `t.tools`. Response-bearing; the default stack copies `toolset`/`tools` into vars and returns them.
 - `workspaceTrigger({ name, actions?: {branch_live?,branch_merge?,branch_new?}, stack? })` — branch lifecycle. Inputs: `t.to_branch`, `t.from_branch`, `t.action`. Config-only.
 - `errorTrigger({ name, stack? })` — error-signature trigger. Inputs: `t.event` (`new|regression|fixed`), `t.id`, `t.signature`, `t.error` (`t.error("code")`/`t.error("message")`), `t.caller`, `t.statement`, `t.actor`, `t.count`, `t.first_seen`, `t.last_seen`, `t.fixed_at`. Config-only.

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".