@xanots/sdk 0.0.11 → 0.0.13

package/dist/{store-BLyNeQ8S.d.ts → store-9Psd0jiF.d.ts}

@@ -1,5 +1,5 @@
-import { V as Value, g as FieldXdo, d as ExprNode, S as StackItemXdo, p as TestDef, C as CacheXdo, h as FilterXdo, I as InputXdo, k as ResultItemXdo, s as TestXdo } from './xdo-BjJj5W_E.js';
-import { W as FieldOptions, h as FieldMap, Y as Prettify, x as RowFromFieldMap, l as FromFieldMap, Z as ReadonlyMethods, M as MethodArg, C as TextMethod, G as TypeBrand, I as IntMethod, D as DecimalMethod, E as EmailMethod, P as PasswordMethod, _ as XanoFileUpload, v as ObjectRef, $ as XanoDbLink, a0 as ConstMethodOpts, f as FieldDescriptor, X as XanoFileRef, K as XanoGeoValue, H as VectorMethod, T as TableRefMethod, b as BrandValue, S as Statement, w as ResponseDef, p as MockMap } from './response-BQVQ24l1.js';
+import { V as Value, g as FieldXdo, d as ExprNode, S as StackItemXdo, p as TestDef, C as CacheXdo, h as FilterXdo, I as InputXdo, k as ResultItemXdo, s as TestXdo } from './xdo-ODuJklk6.js';
+import { W as FieldOptions, h as FieldMap, Y as Prettify, x as RowFromFieldMap, l as FromFieldMap, Z as ReadonlyMethods, M as MethodArg, C as TextMethod, G as TypeBrand, I as IntMethod, D as DecimalMethod, E as EmailMethod, P as PasswordMethod, _ as XanoFileUpload, v as ObjectRef, $ as XanoDbLink, a0 as ConstMethodOpts, f as FieldDescriptor, X as XanoFileRef, K as XanoGeoValue, H as VectorMethod, T as TableRefMethod, b as BrandValue, S as Statement, w as ResponseDef, p as MockMap } from './response-D6xGLEIn.js';
 
 /**
  * The single boolean-expression algebra shared by every SDK surface that emits
@@ -18,8 +18,7 @@ import { W as FieldOptions, h as FieldMap, Y as Prettify, x as RowFromFieldMap,
  *
  * Operands pass their tag/filters straight through — a filtered operand
  * (`withFilters(...)`) is valid inline in every condition/`where` surface
- * (conditional, while, db.query/addon, …), verified against a live engine
- * (the old #118 db-search rejection no longer reproduces).
+ * (conditional, while, db.query/addon, …), verified against a live engine.
  */
 
 /**
@@ -125,7 +124,7 @@ type Condition = SearchNode | SearchNode[];
  * `cmp(col("owner"), "in", ids)` with an empty `ids` matches nothing, and the
  * same clause with `{ ignoreEmpty: true }` returns the UNFILTERED table. Never
  * put it on a clause that scopes rows to a permitted set — an empty permission
- * list then returns everything (issue #5). It is for an OPTIONAL search filter,
+ * list then returns everything. It is for an OPTIONAL search filter,
  * where "the caller left this box blank" really does mean "do not filter".
  */
 declare function cmp(left: Value, op: SearchOp, right: Value, opts?: {
@@ -173,8 +172,8 @@ declare function encodeObject<Xdo = unknown>(name: string, def: unknown): Xdo;
 declare function registeredKinds(): ObjectKind[];
 
 /**
- * Table (database) kind (U6) → payload key `dbo`. Columns reuse the shared
- * field encoder (KTD-6) with the column context; indexes, views, and
+ * Table (database) kind → payload key `dbo`. Columns reuse the shared
+ * field encoder with the column context; indexes, views, and
  * autocomplete have their own small shapes. Validated against the Xano engine's
  * persisted table shape (the full rich field-type corpus).
  */
@@ -306,7 +305,7 @@ type SeedRow<Row = unknown> = [Row] extends [never] ? Record<string, unknown> :
  *
  * Distinct from {@link RowOf}, the READ shape, where every declared column is
  * present. Using the read shape here demanded every column on every seed row —
- * stricter than both the runtime validator and the engine (issue #164).
+ * stricter than both the runtime validator and the engine.
  */
 type SeedRowOf<S extends FieldMap, IdT extends "int" | "uuid" = "int", Sys extends boolean = true> = Prettify<([Sys] extends [false] ? Record<never, never> : Partial<Omit<SystemRow<IdT>, keyof S>>) & FromFieldMap<S>>;
 /**
@@ -316,7 +315,7 @@ type SeedRowOf<S extends FieldMap, IdT extends "int" | "uuid" = "int", Sys exten
  * deferred source keeps large or sensitive seed data out of any frontend bundle
  * that value-imports the table def, and is erased entirely under `import type`.
  * Prefer the thunk form for anything beyond a handful of inline rows — it costs
- * no typing (row and column inference survive every form; issue #164).
+ * no typing (row and column inference survive every form).
  *
  * A JSON `import()` resolves to a module namespace at runtime, not the array
  * TypeScript types the specifier as; the deploy path unwraps `.default`, so
@@ -329,7 +328,7 @@ type SeedSource<Row = unknown> = ReadonlyArray<SeedRow<Row>> | SeedFileSource |
  */
 type WidenSeedValue<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends ReadonlyArray<infer E> ? ReadonlyArray<WidenSeedValue<E>> : T;
 /**
- * A seed row as a DEFERRED source can actually be typed (issue #209).
+ * A seed row as a DEFERRED source can actually be typed.
  *
  * A `.json` module's strings infer as `string`, never as the literal union an
  * `f.enum` column brands — so `seed: () => import("./rows.json")` matched no
@@ -377,7 +376,7 @@ interface SeedFileSource {
  * module, not in `@xanots/sdk`, so a bundler sees an ordinary dynamic import
  * and emits the JSON as a served chunk. Nothing the SDK does to its own code can
  * prevent that. A frontend that value-imports any def whose module graph reaches
- * the table then ships the seed to the browser (issue #204).
+ * the table then ships the seed to the browser.
  *
  * A path is a plain string, so there is nothing for a bundler to follow. The
  * file is read with `node:fs` in the deploy pipeline only.
@@ -550,7 +549,7 @@ declare function table<S extends FieldMap, IdT extends "int" | "uuid" = "int", S
  * too, and TypeScript's overload resolution silently falls through to a later
  * candidate whenever the generic one does not resolve on the first pass — which
  * a function-form `seed` triggers. The result was a table whose `Cols` and `Row`
- * both collapsed with no error reported at the `table()` call (issue #164). With
+ * both collapsed with no error reported at the `table()` call. With
  * this overload unable to match a `FieldMap`, the generic signature is the only
  * candidate and resolves, or reports a real error.
  */
@@ -604,7 +603,7 @@ declare const input: {
      * password on **both** signup and login, let the `f.password` *column* hash on write,
      * and pass the plaintext straight to `check_password`. See the auth recipe in the
      * README. Reach for `input.password` only when you specifically want bind-time hashing
-     * and are not also comparing it with `check_password` (issue #109).
+     * and are not also comparing it with `check_password`.
      */
     password: <const O extends ConstInputOpts<PasswordMethod> = Record<string, never>>(options?: O) => InputDescriptor & TypeBrand<string, O>;
     /**
@@ -864,14 +863,14 @@ declare function encodeContainerHistory<P extends ContainerPrefix>(prefix: P, in
  * Workspace-tier flat map (terminal fallback — no `inherit`). Wholesale: every
  * object type is emitted; a type absent from `map` falls back to its engine
  * default (`enabled` per the kind rule, `limit:100`). Matches the 14-key stored
- * shape in `test/fixtures/misc/workspace.json`.
+ * shape.
  */
 declare function buildWorkspaceHistory(map: WorkspaceHistoryDef): WorkspaceHistoryXdo;
 
 /**
- * `defineFunction` + the in-memory `FunctionDef` model (U6).
+ * `defineFunction` + the in-memory `FunctionDef` model.
  *
- * The authoring API is a flat declarative factory (KTD-3): data in → JSON out,
+ * The authoring API is a flat declarative factory: data in → JSON out,
  * no hidden control-flow inference.
  */
 
@@ -956,10 +955,10 @@ declare function defineFunction<const I extends Record<string, InputDescriptor>
 /** A surface that takes a JavaScript body: the lambda statement, or a filter. */
 type LambdaSurface = "s.lambda" | "fl.lambda" | "map" | "filter" | "some" | "every" | "find" | "findIndex" | "reduce";
 /**
- * Surface → the identifiers a body may reference. Live-probed
- * (`scripts/probe-lambda-bindings.ts`) rather than read off any documentation,
- * and asserted against the recorded probe output in the tests, so the guard, the
- * types, and the docs cannot disagree with the engine or with each other.
+ * Surface → the identifiers a body may reference. Live-probed rather than read
+ * off any documentation, and asserted against the recorded probe output in the
+ * tests, so the guard, the types, and the docs cannot disagree with the engine
+ * or with each other.
  *
  * `console` and `crypto` are globals inside the body rather than destructured
  * bindings, so they are legal to reference but are not part of the parameter
@@ -971,7 +970,7 @@ declare const LAMBDA_BINDINGS: Readonly<Record<LambdaSurface, readonly string[]>
 declare const LAMBDA_GLOBALS: readonly string[];
 /**
  * The libraries the engine preloads as GLOBALS in a lambda body — the only
- * dependency route that works on every instance (issue #265).
+ * dependency route that works on every instance.
  *
  * A body is prepared for execution in one of two ways depending on the
  * instance's executor generation, and the two disagree about `import()`:
@@ -1000,14 +999,15 @@ declare const LAMBDA_MODULE_GLOBALS: readonly string[];
  *
  * The slot is fixed rather than looked up because it is what the guard has to
  * key on: `filter()` sees positions, not argument names. `reduce`'s body is the
- * SECOND argument (the accumulator's initial value comes first, and #221's other
- * half is exactly that slot being invisible); every other lambda filter's is the
+ * SECOND argument (the accumulator's initial value comes first, and that slot
+ * being invisible is the other half of the same failure); every other lambda
+ * filter's is the
  * first.
  *
  * `fl.transform` is deliberately absent. It takes Xano Expression Engine source,
  * not a JavaScript body, and binds the operand as `$0` rather than `$this` — so
  * validating it against THIS contract would reject correct code. It has its own
- * guard, on its own probed contract, in `./expression-arg.ts` (issue #245); a
+ * guard, on its own probed contract, in `./expression-arg.ts`; a
  * `return` there is not merely refused but sometimes silently mis-evaluated.
  * `test/values/filters.test.ts` enumerates the `code`-taking filters from
  * `FILTER_SPECS` and fails if one is missing here.
@@ -1056,7 +1056,7 @@ interface IteratingBindings extends AmbientBindings {
 }
 /** The bindings in scope in a body at `S` — the type of a {@link lam.fn} parameter. */
 type LambdaBindings<S extends LambdaSurface = "reduce"> = S extends "reduce" ? IteratingBindings & {
-    /** The accumulator. This is the binding issue #221 guessed as `$acc`. */
+    /** The accumulator. Commonly mis-typed as `$acc`. */
     $result: any;
 } : S extends "s.lambda" ? AmbientBindings : S extends "fl.lambda" ? AmbientBindings & {
     /** The piped value the filter is applied to. */
@@ -1088,7 +1088,7 @@ type CaptureValue = string | number | boolean | null | {
  * stays open to declaration merging. So `capture: { band }` compiled when `band`
  * was a `type` and failed when the identical shape was an `interface`, with the
  * error naming `CaptureValue` rather than the one keyword that differed, and the
- * body's second parameter then degrading to the constraint (issue #266).
+ * body's second parameter then degrading to the constraint.
  *
  * A homomorphic mapped type is the way through: `keyof` an interface is the same
  * as `keyof` the alias, so this accepts both and still rejects what genuinely
@@ -2007,7 +2007,7 @@ declare const fl: {
  * statement the database runs, so they are reachable only from a query's own
  * expression surfaces — and, being absent from the runtime catalog, every one of
  * them used to be reported by `findUnresolvableFilters` as "will 500 at runtime"
- * (issue #30). That warning steered authors off the only spelling that works.
+ *. That warning steered authors off the only spelling that works.
  *
  * The distinction is worth stating because it is what makes vector search
  * possible at all: `f.vector` columns and their pgvector indexes had no query
@@ -2092,7 +2092,7 @@ type OutputPath<C extends string> = QualifiedCol<C> | PagingEnvelopeField;
  * ⚠ `comments.id` is only the bound table's own alias WHEN THE QUERY DECLARES ONE
  * (`tableAlias`) — that is why Xano's editor can write it and a hand-authored
  * query cannot. Without `tableAlias`, qualifying the bound table by its NAME does
- * not resolve, and the query fails at runtime (issue #213); `db.query` checks the
+ * not resolve, and the query fails at runtime; `db.query` checks the
  * `where`/`sort`/`eval` paths for it at export. Bare is the form to reach for.
  */
 type QualifiedCol<C extends string> = C | `${string}.${string}`;
@@ -2114,7 +2114,7 @@ type OutputRoot<P extends string> = P extends `${infer Head}.${string}` ? Head :
  * The boolean-expression algebra (`cmp`/`and`/`or`, the node types, the tree
  * walk) now lives in {@link ../expression.js}; this module keeps the db-specific
  * pieces — `where`/`additionalWhere` merge, sort, eval — and supplies the
- * filter-rejecting operand encoder (#118) to the shared walk.
+ * filter-rejecting operand encoder to the shared walk.
  */
 
 /** Sort direction for a {@link SortDirective} — the engine's `orderBy` values. */
@@ -2233,7 +2233,7 @@ declare function resolveAuthRef(hostLabel: string, host: string, auth: AuthRef |
  * spec/tags/tool-refs). Verified against the Xano engine's stored mcp_server and
  * agent formats.
  *
- * Notes from that verification (see the PR for #85/#87):
+ * Notes from that verification:
  *  - Xano's MCP server has **no** server-level `authentication` field — auth is
  *    per-tool (`tool[].auth`, a stored `json`, engine default `false`).
  *  - Toolset-level middleware is **not** an engine feature: neither transform
@@ -2246,7 +2246,7 @@ declare function resolveAuthRef(hostLabel: string, host: string, auth: AuthRef |
 /**
  * Generic over its input map `I`, branded stack tuple `S`, literal response
  * `Resp`, and declared `Res` — the same carriers `QueryDef` holds, so
- * `InferInput`/`InferResponse` work identically here (issue #119). All default,
+ * `InferInput`/`InferResponse` work identically here. All default,
  * so a bare `ToolDef` is unchanged.
  *
  * A tool's response is the value an AGENT reads back, which makes it as
@@ -2329,7 +2329,7 @@ declare const toolKind: ObjectKind<AnyToolDef$1, ToolXdo>;
 /**
  * Authoring factory for a `tool` — a function-like operation a toolset
  * references. The exact input map, stack tuple, and response are preserved on
- * the return type, so `InferInput`/`InferResponse` recover them (issue #119).
+ * the return type, so `InferInput`/`InferResponse` recover them.
  */
 declare function tool<const I extends Record<string, InputDescriptor>, Res = never, Resp extends ResponseDef = ResponseDef, const S extends readonly Statement[] = readonly []>(def: ToolDef<I, Res, Resp, S>): ToolDef<I, Res, Resp, S>;
 /**
@@ -2365,7 +2365,7 @@ interface ToolsetToolRef {
  * directly (`registerTools([saveNote])`, `bind: [{ table: users }]`), so
  * `tools: [saveNote]` is the spelling authors reach for by analogy — and the
  * wrapper's fields are all optional, so TypeScript's weak-type check let a bare
- * handle through and the export emitted `id: 0`, a null reference (issue #7).
+ * handle through and the export emitted `id: 0`, a null reference.
  * Normalizing here removes the failure mode rather than documenting around it.
  */
 type ToolsetToolEntry = ToolsetToolRef | ToolDef | string;
@@ -2556,7 +2556,7 @@ interface XanoFreeProvider extends LlmCommon {
     dynamicRetrieval?: string;
 }
 /**
- * The run prompt, in exactly one of its two spellings (issue #6).
+ * The run prompt, in exactly one of its two spellings.
  *
  * The engine stores ONE prompt behind a `prompt_type` discriminator: either a
  * `prompt` string or a `prompt_messages` template, never both. Authoring both
@@ -2597,7 +2597,7 @@ type LlmSettings = AnthropicLlm | OpenAiLlm | GoogleGenAiLlm | XanoFreeLlm;
  * stored `structuredOutputsSchema` is the same wire shape as function inputs, so
  * `encodeInput` produces it verbatim (no parallel encoder). e.g.
  * `output: { schema: { priority: input.enum(["low","high"]), summary: input.text() } }`.
- * The item shape is byte-verified against a captured live-engine golden (issue #122).
+ * The item shape is byte-verified against a captured live-engine golden.
  */
 interface AgentOutput {
     schema: Record<string, InputDescriptor>;
@@ -2611,7 +2611,7 @@ interface AgentOutput {
  * `A` is whatever `s.ai.agent.run({ agent })` was handed: an {@link AgentHandle}
  * (or {@link AgentDef}) carries a precise, branded `output.schema`, so this reads
  * the shape the agent already declares once — no second `resultShape` witness at
- * the call site (issue #124.1). A bare name/ref carries no schema → `string`.
+ * the call site. A bare name/ref carries no schema → `string`.
  *
  * The schema is a *response* shape (the object the model returns), so every
  * declared field is treated as present — {@link RowFromFieldMap}, not the
@@ -2701,12 +2701,12 @@ type AgentHandle<D extends AgentDef = AgentDef> = D & {
  * branded `output.schema`. That lets `s.ai.agent.run({ agent })` read the
  * completion shape straight off the handle via {@link AgentResultOf} — the
  * structured-output type is declared once here, not re-stated as a `resultShape`
- * witness at every call site (issue #124.1).
+ * witness at every call site.
  */
 declare function agent<const D extends AgentDef>(def: D): AgentHandle<D>;
 
 /**
- * Addon kind (U8) → payload key `addon`. An addon is a single table-bound db
+ * Addon kind → payload key `addon`. An addon is a single table-bound db
  * query (an `input` block + an `output` selection + a `context` that carries the
  * dbo binding and `return`), *not* a statement stack — the engine runs it
  * straight off `context`. The MVP models the common shape;
@@ -2718,7 +2718,7 @@ declare function agent<const D extends AgentDef>(def: D): AgentHandle<D>;
  * matches on) and brands the returned handle with the addon's **graft shape** —
  * `Pick<InferRow<table>, output>`, wrapped per {@link AddonDef.cardinality} — so
  * a `db.query`/`db.get` attaching the addon can type the grafted row field
- * instead of falling back to `unknown` (issues #62, #63).
+ * instead of falling back to `unknown`.
  */
 
 /** An addon's `output` selection: a typed column-name list, or the raw customize block. */
@@ -2861,7 +2861,7 @@ interface AddonArgs<Tbl extends ObjectRef | null, Out extends readonly string[],
 declare function addon<const Out extends readonly string[] = readonly [], Tbl extends ObjectRef | null = ObjectRef, Card extends AddonCardinality = "list", const Grp extends readonly DbEval[] = readonly [], const Ev extends readonly DbEval[] = readonly []>(def: AddonArgs<Tbl, Out, Card, Grp, Ev>): AddonDef<AddonGraft<Tbl, Out, Card, Grp, Ev>>;
 
 /**
- * Schema-DSL interpreter (U9). Turns a declarative statement schema's
+ * Schema-DSL interpreter. Turns a declarative statement schema's
  * `transform` rules into a runtime encoder, so the ~169 declarative statements
  * are driven by data (a `StatementSpec`) rather than hand-written per statement.
  *
@@ -2879,11 +2879,11 @@ declare function addon<const Out extends readonly string[] = readonly [], Tbl ex
  * `output` (whether the stored item carries `output:{filters:[]}`) is NOT
  * derivable from the transform schema — it is engine statement-class metadata
  * (e.g. `uuid4` has an `as` but no `output`; `return` has a value block but no
- * `output`). The codegen pins it from the persisted golden fixture (KTD-4),
+ * `output`). The codegen pins it from the persisted golden fixture,
  * never guessing.
  *
  * Validated against real persisted fixtures (math_add, bitwise_and, object_keys,
- * array_push, array_pop). The codegen pipeline (scripts/codegen.ts) populates the
+ * array_push, array_pop). The codegen pipeline populates the
  * spec catalog from the Xano engine's schema definitions; uninterpretable schemas are
  * logged, never guessed.
  */
@@ -2915,7 +2915,7 @@ type Route = {
     name: string;
 };
 /**
- * Per-statement envelope shape, pinned from the persisted fixture (KTD-4) — the
+ * Per-statement envelope shape, pinned from the persisted fixture — the
  * engine-class metadata that isn't in the transform schema. "Full" statements
  * (api_request, db ops, file ops) carry richer `input[]` entries and extra
  * top-level keys; lean statements (math, array, object) carry none of these.
@@ -3281,14 +3281,11 @@ declare function microservice<const D extends MicroserviceDef>(def: D): D;
 declare const microserviceKind: ObjectKind<MicroserviceDef, MicroserviceXdo>;
 
 /**
- * AUTO-GENERATED by scripts/codegen.ts — DO NOT EDIT BY HAND.
- *
- * Typed, namespaced factories for the declarative statement catalog (U9): every
+ * Typed, namespaced factories for the declarative statement catalog: every
  * generated statement is reachable + autocomplete-discoverable as
  * `generated.<namespace>.<method>({…})` (e.g. `generated.math.add`,
  * `generated.db.get`). The unified public surface is `s` in ../s.ts, which
- * merges these with the hand-authored control-flow specials. Regenerate with
- * `npm run codegen`.
+ * merges these with the hand-authored control-flow specials.
  */
 
 declare const generated: {
@@ -4677,7 +4674,7 @@ declare const generated: {
 };
 
 /**
- * Implied-input catalog per trigger `obj_type` (U1). Xano trigger inputs are
+ * Implied-input catalog per trigger `obj_type`. Xano trigger inputs are
  * **fixed by type** — they are generated by `mvp:trigger_update_defaults` and
  * cannot be edited in the UI. This module is the XanoTS mirror of that
  * generator: `impliedInputs(objType)` returns the exact input array Xano stores
@@ -4690,9 +4687,7 @@ declare const generated: {
  * Fields are built through the canonical `input.*` / `f.*` constructors + shared
  * `encodeInput`, so they carry the same stored shape and defaults as every other
  * XanoTS input (`customize:{}`, `_xsid:""`, numeric `market_item`) and cannot
- * drift from the field encoder. The shipped `test/fixtures/triggers/*.json` carry
- * the older `customize:""` parser-generation format; conformance compares
- * structurally, normalizing that legacy drift and the engine-assigned `_xsid`.
+ * drift from the field encoder.
  */
 
 /**
@@ -4713,7 +4708,7 @@ type TriggerInputObjType = "database" | "toolset" | "workspace" | "workspace_rea
  * factories pass a typed handle `t` to `stack: (t) => [...]` (and `response:
  * (t) => ...` on response-bearing types). Each member is a {@link FieldAccessor}:
  * it is a {@link Value} referencing the whole input **and** callable for typed
- * column/child access — `t.new("email")` → `inp("new.email")` (KTD-2). This
+ * column/child access — `t.new("email")` → `inp("new.email")`. This
  * mirrors the `auth("id")` callable-value precedent and keeps the
  * `{value,tag,filters}` shape so it composes with `withFilters`.
  *
@@ -4768,13 +4763,24 @@ interface RealtimeServerTriggerInputs {
     /** The connecting client — `permissions` gates its realtime row/table access. */
     client: RealtimeClient;
 }
-/** Realtime channel lifecycle trigger inputs (join / leave). */
+/** Realtime channel lifecycle trigger inputs (join / leave / deliver). */
 interface RealtimeChannelTriggerInputs {
-    /** The membership action (`"join"` | `"leave"`). */
+    /** The membership action (`"join"` | `"leave"` | `"deliver"`). */
     action: Value;
     /** The channel path the client addressed. */
     channel: Value;
-    /** The joining client — `permissions` gates its realtime row/table access. */
+    /**
+     * The message body on a `deliver` run, null on join/leave. It arrives NESTED,
+     * so read a field as `t.payload("text")`. A flat `inp("text")` names an input
+     * this trigger does not declare and RAISES at runtime, which for `deliver`
+     * means the hook fails open and the recipient gets the original.
+     */
+    payload: FieldAccessor;
+    /**
+     * The client — the JOINING client on join/leave, and the SENDING client on
+     * `deliver` (the recipient that run is for is `s.realtime.get_session`).
+     * `permissions` gates its realtime row/table access.
+     */
     client: RealtimeClient;
 }
 /** Toolset trigger inputs (MCP server / agent). */
@@ -5050,7 +5056,7 @@ type RealtimeServerHandle = RealtimeServerDef & {
      * connection hash — so pass `{ tenant }` explicitly there.
      *
      * IN A BROWSER BUNDLE, prefer the generated manifest: importing this def for
-     * its `getUrl()` pulls the SDK runtime in with it (the same ~289 kB floor a
+     * its `getUrl()` pulls the SDK runtime in with it (the same ~267 kB floor a
      * query def costs — the factory CALLS that build the def run at module load).
      * `xanots routes <entry> --emit xano/routes.gen.ts` writes the identical
      * address, tenant lift included, as `socketUrl("<server>", baseUrl)` in a file
@@ -5373,7 +5379,7 @@ declare function realtimeChannel<const I extends Record<string, InputDescriptor>
 declare function realtimeChannelGuid(def: Pick<RealtimeChannelDef, "name" | "server" | "guid">): string;
 
 /**
- * Trigger kinds (U4). All 6 trigger types share ONE stored envelope
+ * Trigger kinds. All 6 trigger types share ONE stored envelope
  * discriminated by `obj_type` + a per-type `meta` block —
  * confirmed against the Xano engine's stored trigger shape. The canonical `meta`
  * carries all four action groups (database / toolset / workspace /
@@ -5419,8 +5425,7 @@ interface RealtimeActions {
  * Same return shape as a channel `join`: `{ allowed: c.bool(true) }` or any truthy value
  * admits, and an EMPTY OR FALSY return DENIES — including a gating trigger with
  * no `response`, which returns nothing and so refuses every client. A CRASH also
- * DENIES: the transport seeds a deny decision before running the stack and keeps
- * it when the stack throws, because a gate that cannot answer must not admit.
+ * DENIES: a gate that cannot answer must not admit.
  *
  * So both failure modes lock the door rather than open it, and the risk to plan
  * for is a self-inflicted lockout — an unguarded drill into a `db.get` that
@@ -5449,16 +5454,24 @@ interface RealtimeServerActions {
  *    optional `reason` surfaces in the client's error frame) or any other truthy
  *    value to admit. AN EMPTY OR FALSY RETURN DENIES — a stack that just falls
  *    through, or a gating trigger with no `response`, refuses the join. A CRASH
- *    DENIES TOO (the gate is seeded with a deny and keeps it when the stack
- *    throws), which is the INVERSE of a normal message: a message whose stack
- *    crashes still delivers, so one workspace bug cannot black-hole a channel.
- *    Note the asymmetry with `deliver` below, which is a gate that fails OPEN.
- *
- *    `join` and `leave` both bind the channel's typed path params as INPUTS, so
- *    `inp("room_id")` resolves inside them and the gate can decide per room.
- *    (`s.realtime.get_session` carries the same values under `params`; either
- *    reads them.) A SERVER `connect`/`disconnect` trigger has no channel and so
- *    no params — that is the one place a path param cannot be read.
+ *    DENIES TOO, which is the INVERSE of a normal message: a message whose
+ *    stack crashes still delivers, so one workspace bug cannot black-hole a
+ *    channel. Note the asymmetry with `deliver` below, which is a hook that
+ *    fails OPEN.
+ *
+ *    A lifecycle trigger's inputs are PINNED to `action`/`channel`/`payload`/
+ *    `client`, so a channel path param is NOT among them: `inp("room_id")`
+ *    RAISES inside a gate, which crashes it and so refuses every client. Take
+ *    the param from `s.realtime.get_session` under `params`
+ *    (`ref("session.params.room_id")`) and the gate can decide per room. A
+ *    SERVER `connect`/`disconnect` trigger has no channel and so no params
+ *    at all.
+ *
+ *    A gate also establishes NO auth, so `ref("auth.id")` reads 0 even for an
+ *    authenticated client — identity is `t.client("permissions.dbo_id")` (0 is
+ *    anonymous) or the session. And once the returned object carries an
+ *    `allowed` key, admission needs STRICTLY `true`: a computed `1` or `"yes"`
+ *    in that shape DENIES, so produce a real bool.
  *  - `leave` is OBSERVATIONAL (return ignored, throws swallowed).
  *  - `deliver` GATES delivery PER RECIPIENT — it runs once for each client the
  *    message is about to reach. It is the heaviest of the three by a wide
@@ -5473,7 +5486,7 @@ interface RealtimeServerActions {
  *    null instead.
  *
  *    The delivered payload arrives NESTED under `payload`, so read
- *    `inp("payload").<field>`. And the two identities differ: `t.client` is the
+ *    `t.payload("<field>")`. And the two identities differ: `t.client` is the
  *    SENDER, while `s.realtime.get_session` describes the RECIPIENT this run is
  *    for — per-viewer redaction needs both, and reaching for the wrong one is
  *    silent.
@@ -5932,7 +5945,7 @@ declare const apiGroupKind: ObjectKind<ApiGroupDef, ApiGroupXdo>;
 declare function apiGroup(def: ApiGroupDef): ApiGroupDef;
 
 /**
- * Query (API endpoint) kind (U7) → payload key `query`. Function-like
+ * Query (API endpoint) kind → payload key `query`. Function-like
  * (input/run/result) plus HTTP fields: `verb`, `app` (api_group binding),
  * `auth`, `response_type`, `cache`, `output`. Validated against
  * the Xano engine's persisted shape.
@@ -6097,7 +6110,7 @@ interface QueryDef<I extends Record<string, InputDescriptor> = Record<string, In
     /**
      * The endpoint's statement stack. Captured as the literal tuple `S` (via
      * `query()`'s `const` inference) so `InferResponse` can trace a single-variable
-     * response back to the branded `db.get`/`db.query` that bound it (U5). A
+     * response back to the branded `db.get`/`db.query` that bound it. A
      * dynamically-built `Statement[]` widens `S` and the trace degrades to
      * `unknown` — the override (`responseShape`) remains the escape hatch.
      */
@@ -6105,8 +6118,8 @@ interface QueryDef<I extends Record<string, InputDescriptor> = Record<string, In
     /**
      * The response assignment: a single {@link Value} (returned directly) or a
      * record of named values (an object with those keys). Captured as the literal
-     * `Resp` so `InferResponse` can auto-derive object-literal keys (U2) and, with
-     * the branded stack, trace a single-variable response (U5).
+     * `Resp` so `InferResponse` can auto-derive object-literal keys and, with
+     * the branded stack, trace a single-variable response.
      */
     response?: Resp;
     /**
@@ -6251,7 +6264,7 @@ declare const query: typeof queryImpl & {
 };
 
 /**
- * Task (scheduled/background job) kind (U8) → payload key `task`. Function-like
+ * Task (scheduled/background job) kind → payload key `task`. Function-like
  * `run[]` plus a `schedule[]` of cron-like entries. Validated against
  * the Xano engine's persisted shape.
  */
@@ -6403,7 +6416,7 @@ declare const workflowTestKind: ObjectKind<WorkflowTestDef, WorkflowTestXdo>;
 declare function workflowTest(def: WorkflowTestDef): WorkflowTestDef;
 
 /**
- * Middleware kind (U8) → payload key `middleware`. Function-like
+ * Middleware kind → payload key `middleware`. Function-like
  * (input/run/result) plus `result_type` (merge|replace) and `exception`
  * (silent|rethrow|critical). Validated against the Xano engine's persisted shape.
  */
@@ -6442,13 +6455,13 @@ type ResultStrategy = "merge" | "replace";
  * author who writes a rate limiter and does not think about this field gets, by
  * default, a limiter that does nothing and says nothing. An inert guard is
  * worse than a loud one, so the safe reading is the default and the permissive
- * one is opt-in (issue #210).
+ * one is opt-in.
  */
 type ExceptionPolicy = "silent" | "rethrow" | "critical";
 /**
  * Generic over its branded stack tuple `S`, literal response `Resp`, and
  * declared `Res`, so `InferResponse` can trace a response ref back to the
- * statement that bound it (issue #119). All default, so a bare `MiddlewareDef`
+ * statement that bound it. All default, so a bare `MiddlewareDef`
  * is unchanged.
  *
  * No input generic, deliberately: a middleware's declared `input` is NEVER bound
@@ -6631,9 +6644,9 @@ type MessageDeliverTo = "channel" | "sender" | "others" | "explicit";
  * a declared `Res` (the `responseShape` override). All default, so every existing
  * use — a bare `RealtimeMessageDef` — works unchanged.
  *
- * This carried `I` alone until issue #119. A `Statement[]` stack is a widened
- * non-tuple, so no `as` binding in it was visible and every `ref()` in a
- * handler's response bottomed out — and with no `responseShape` field there was
+ * Carrying `I` alone is not enough. A `Statement[]` stack is a widened
+ * non-tuple, so no `as` binding in it is visible and every `ref()` in a
+ * handler's response bottoms out — and with no `responseShape` field there is
  * no override either. That gap costs more here than on an HTTP kind: a realtime
  * client's whole data path is the socket (the transcript hydrates a joiner, so
  * there is deliberately no hydration endpoint to derive a shape from), which
@@ -6771,7 +6784,7 @@ declare const realtimeMessageKind: ObjectKind<AnyRealtimeMessageDef$1, RealtimeM
  *
  * The exact input map, stack tuple, and response are preserved on the return
  * type, so `InferInput<typeof msg>` types what a client SENDS and
- * `InferResponse<typeof msg>` types what it RECEIVES (issue #119).
+ * `InferResponse<typeof msg>` types what it RECEIVES.
  */
 declare function realtimeMessage<const I extends Record<string, InputDescriptor>, Res = never, Resp extends ResponseDef = ResponseDef, const S extends readonly Statement[] = readonly []>(def: RealtimeMessageDef<I, Res, Resp, S>): RealtimeMessageDef<I, Res, Resp, S>;
 
@@ -6903,9 +6916,9 @@ declare function knowledge(def: KnowledgeDef): KnowledgeDef;
 declare const knowledgeKind: ObjectKind<KnowledgeDef, KnowledgeXdo>;
 
 /**
- * Workspace config kind (U8) → payload key `workspace` (singleton object, not
+ * Workspace config kind → payload key `workspace` (singleton object, not
  * an array). Emits the author-provided settings subset; the engine fills the
- * remaining server-managed fields on import (KTD-1). Authoring shape validated
+ * remaining server-managed fields on import. Authoring shape validated
  * against the Xano engine's persisted workspace shape.
  *
  * Two blocks — `preferences` and `settings` — merge over a named engine default
@@ -6978,7 +6991,7 @@ interface WorkspaceDefaultsDef {
 interface WorkspaceConfigDef {
     /**
      * OPTIONAL — omit it and the workspace inherits the name `workspace("…")`
-     * already gave it (#228).
+     * already gave it.
      *
      * There is exactly one config per workspace and the entry point names it, so
      * restating it here was pure duplication that every documented example got
@@ -7065,7 +7078,7 @@ interface WorkspaceConfigDef {
      *   dropped, and an empty value is written as an empty string.
      * - `release` (merge) is ADD-ONLY. It creates keys that do not yet exist and
      *   does NOT update or remove ones that do. Changing a value in code and
-     *   releasing leaves the live value as it was (issue #164).
+     *   releasing leaves the live value as it was.
      * - `release --replace` replaces, but it rebuilds the whole workspace to do it.
      *
      * So a value you need to CHANGE on an instance workspace cannot be changed by
@@ -7309,7 +7322,7 @@ interface ManifestFilter {
     /**
      * Named, typed args (richly-specified filters only). `enum` carries the exact
      * accepted spellings where the arg has a closed set — printed in place of the
-     * bare word "enum", which told a reader nothing (#198).
+     * bare word "enum", which told a reader nothing.
      */
     args?: Array<{
         name: string;
@@ -7466,7 +7479,7 @@ interface LockFile {
 declare function emptyLock(): LockFile;
 /**
  * Parse + strictly validate lock file text. Every failure is a hard error
- * (R11) — the caller must never fall back to an unlocked export when a lock
+ * — the caller must never fall back to an unlocked export when a lock
  * file exists but is broken.
  */
 declare function parseLock(text: string, path?: string): LockFile;
@@ -7508,7 +7521,7 @@ interface LockExportContext {
 declare function createLockContext(lock?: LockFile): LockExportContext;
 /**
  * Record one emitted identity into `ctx.observed`, hard-erroring on an
- * explicit-vs-lock guid split (R3): within one bundle every reference resolves
+ * explicit-vs-lock guid split: within one bundle every reference resolves
  * through the seeded lock, so an object whose payload guid disagrees with its
  * lock entry would ship a bundle where references point at a guid the target
  * no longer carries — never emit that silently.
@@ -7521,7 +7534,7 @@ interface RenameResult {
     discardedNewcomer?: LockEntry;
 }
 /**
- * Move a lock entry to a new name keeping its identity values (R7), so the
+ * Move a lock entry to a new name keeping its identity values, so the
  * next export emits the ORIGINAL guid under the new name and the engine
  * renames in place.
  *
@@ -7553,7 +7566,7 @@ interface AdoptResult {
     vaultCount: number;
 }
 /**
- * Seed/update the lock from a live engine `packageExport` bundle (R9) —
+ * Seed/update the lock from a live engine `packageExport` bundle —
  * capturing the workspace's random guids and canonicals by `(type, name)` so
  * an existing workspace can be adopted into code without a delete+create sync.
  *
@@ -7580,7 +7593,7 @@ interface MergeResult {
  *
  * Observed values win field-by-field (an explicit in-code value updates the
  * recorded one, per R2). Entries nothing matched are kept as orphans and
- * reported — renames are never guessed (R6) — with one exception: an orphan
+ * reported — renames are never guessed — with one exception: an orphan
  * whose GUID now belongs to a LIVE entry is dropped. That happens when a
  * rename is reverted after a `lock rename` fix-up (the old name re-derives the
  * pinned guid): keeping the orphan would wedge the lock on its own
@@ -7616,7 +7629,7 @@ interface Bundle {
     sig: string;
 }
 /**
- * Iterative, like the guards' walkers (issue #19), and for the same reason: what
+ * Iterative, like the guards' walkers, and for the same reason: what
  * is being crossed here is the author's own structure — a deep expression tree,
  * or a `raw()` envelope carrying whatever the engine handed back on a pull — and
  * a recursive encoder turns that into a bare `RangeError` at `export()`. Depth
@@ -7658,7 +7671,7 @@ interface ResolvedKnowledge {
 
 /**
  * The register methods take the WIDEST instantiation of each def type, not the
- * bare name (issue #208).
+ * bare name.
  *
  * A def's `Res` parameter surfaces as `responseShape?: Res` and defaults to
  * `never`, so the bare `FunctionDef` — the spelling the issue proposed —
@@ -7667,7 +7680,7 @@ interface ResolvedKnowledge {
  * never` and the registration they were already making stops compiling. Pinning
  * `Res` to `unknown` (and every other parameter to its own constraint) accepts
  * every instantiation while still rejecting an object that is not that kind of
- * def at all, which is what #208 asked for.
+ * def at all.
  */
 type AnyInputs = Record<string, InputDescriptor>;
 type AnyStack = readonly Statement[];
@@ -7707,7 +7720,7 @@ declare class Xano {
     register(kindName: string, defOrDefs: unknown): this;
     /**
      * Every def object handed to {@link register}, by identity, so the SAME one
-     * registered twice is caught at the call that did it (issue #54).
+     * registered twice is caught at the call that did it.
      *
      * Identity, not structure. Two separately constructed defs sharing a name are
      * a genuine collision, and the guid check at export already diagnoses that
@@ -7733,7 +7746,7 @@ declare class Xano {
      * what `workspace("my-app")` set — so the natural chain
      * `workspace("my-app").registerWorkspace(workspaceConfig({ history }))` no
      * longer makes an author restate a name this registry has held since its
-     * first call (#228). An explicit `name` still wins, and a rename this way is
+     * first call. An explicit `name` still wins, and a rename this way is
      * a rename of the workspace.
      */
     registerWorkspace(def: WorkspaceConfigDef): this;
@@ -7795,7 +7808,7 @@ declare class Xano {
      * With `options.strict`, every build WARNING fails the export instead of
      * printing — the shapes that deploy clean and then lose data or return the
      * wrong rows. Nothing about the emitted bundle changes; it either exports or
-     * it does not (issue #15).
+     * it does not.
      */
     export(options?: {
         lock?: LockExportContext;
@@ -7828,7 +7841,7 @@ declare class Xano {
     private validateQueryAuth;
     /**
      * Warn about an `auth()`-keyed middleware **directly attached** to a host where
-     * `auth()` may resolve to `null` (issue #81).
+     * `auth()` may resolve to `null`.
      *
      * The footgun: a rate limiter keyed by `auth("id")` is the canonical middleware,
      * but attach it to a host with no authenticated caller and `auth()` silently
@@ -7843,7 +7856,7 @@ declare class Xano {
      * false positives on legitimate use. The warning names the host and reason so
      * the author can confirm intent, vary the key, or move to an authenticated host.
      *
-     * Scope: the host's EFFECTIVE chain, across all three tiers (issue #43). The
+     * Scope: the host's EFFECTIVE chain, across all three tiers. The
      * guard used to see only a host's own `middleware.pre`/`post`, so an author who
      * DRY'd a per-user limiter up to `apiGroup({ middleware })` or to the workspace
      * tier silently reintroduced the shared bucket — the same collapse, attached
@@ -7930,7 +7943,7 @@ declare function emitBundle(xano: Xano, opts?: {
  * choke point instead makes reference and target agree everywhere by
  * construction, with zero changes at call sites.
  *
- * That yields the seeding contract (R12): **seed once per process, BEFORE any
+ * That yields the seeding contract: **seed once per process, BEFORE any
  * def module is evaluated.** Node's module cache means seeding after defs have
  * loaded is a silent no-op for already-baked references. The CLI honors this
  * automatically (it seeds before importing the workspace entry); programmatic