@xanots/sdk 0.0.12 → 0.0.13

package/dist/internal.js

@@ -29,7 +29,7 @@ import {
   taskKind,
   toolKind,
   workflowTestKind
-} from "./chunk-VRNZ2NVV.js";
+} from "./chunk-PJNWOZMT.js";
 import {
   GENERATED_SPECS,
   GENERATED_STATEMENT_NAMES,
@@ -51,7 +51,7 @@ import {
   registerSpec,
   triggerKind,
   workspaceKind
-} from "./chunk-GSP2BY4F.js";
+} from "./chunk-BYQHCCYU.js";
 import {
   IMPLEMENTED_STATEMENTS,
   STATEMENT_SURFACES,
@@ -776,7 +776,7 @@ function renderTestsSection() {
     "",
     "- The run uses an EMPTY datasource, so **no `table({ seed })` rows exist while it runs** and every `db` read misses. A test that buys seeded row 1 fails with its own precondition message, which reads as a wrong id rather than an empty database. Create what the test needs INSIDE the test \u2014 typically a `defineFunction` fixture the stack calls first.",
     '- `s.api.call` does NOT raise when the endpoint answers with an error. It BINDS the error envelope (`{code, message}`) to its `as` and carries on, so a later `s.expect.to_be_defined({ expr: ref("r.field") })` reports the ASSERTION while the real failure was the call, four statements up. Assert on the envelope \u2014 `s.expect.to_contain({ expr: ref("r.code"), value: c.text("ERROR_CODE_INPUT_ERROR") })` \u2014 when a call may fail. `s.function.run` raises instead; the two disagree.',
-    '- `s.expect.to_throw({ body, exception? })` runs `body` in an ISOLATED var stack, so a variable bound EARLIER in the test is not visible inside it \u2014 bind what the body needs inside the body. `exception` is 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 \u2014 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` \u2014 which reads as a broken auth gate on a gate that works.",
     "- An endpoint's `auth` gate is NOT enforced on `s.api.call`. A `query({ auth: users })` runs anyway and fails only where its stack dereferences `auth(...)`. A stack that never touches `auth(...)` runs unauthenticated and passes.",
     "- Neither `auth.token` nor an `Authorization` entry in `headers` authenticates the call \u2014 a token that answers 200 over real HTTP is refused here. To cover auth-gated logic, move the body into a `defineFunction` taking the user id and `s.function.call` that; the gate itself is not reachable from a workflow test.",
@@ -1116,10 +1116,10 @@ function renderSections(m) {
     "  `getPath()`/`verb`/`getUrl()`/`getChannel()` also pulls whatever its `stack` references:",
     "  the `s.*`/`c.*` factory CALLS run at module load to BUILD it. Types are free.",
     "  \u26A0 A FLOOR \u2014 **~267 kB minified (~65 kB gzipped)** for the FIRST def; splitting modules",
-    "  never removes it. The floor is the RUNTIME, not the def: a second def, or a much richer",
-    "  one, adds ~2 kB \u2014 so reducing what a def does will not reduce it.",
+    "  never removes it. The floor is the RUNTIME, not the def: a second or much richer def",
+    "  adds ~2 kB, so trimming a def does not shrink it.",
     "  Fix: `xanots routes <entry> --emit xano/routes.gen.ts` (`paths` is an accepted alias) \u2014 verbs, paths, and sockets as",
-    '  plain data importing NOTHING, still compile-checked: `routePath("blog/{slug}", { slug })`,',
+    '  plain data importing NOTHING, still compile-checked: `routePath("GET blog/{slug}", { slug })`',
     '  `channelPath("rooms/{room_id}", { room_id })`, `socketUrl("chat", baseUrl)` (tenant base',
     "  URLs lifted to `wss://h/ws/<tenant>:<canonical>`). A rename is a type error, not a 404.",
     "- **Intra-workspace imports use `.js` specifiers** (`../tables/links.js`), not",
@@ -1196,7 +1196,7 @@ function renderSections(m) {
     "  submission on bind, so `s.security.check_password` compares two different hashes",
     "  and a correct password always fails (`ok:false` on a found row). Take the submitted",
     "  password as `input.text()` on both signup and login and pass the plaintext straight",
-    "  to `check_password` (which does the comparison hash itself).",
+    "  to `check_password` (which does the comparison hash itself). `export()` warns.",
     "- **Agents authenticate with env vars \u2014 never `xanots login`.** `login` blocks on a",
     "  browser consent no agent can complete. Set `$XANO_INSTANCE_URL` + `$XANO_WORKSPACE_ID`",
     "  + `$XANO_META_TOKEN` and run `deploy`/`release` directly: no disk, no rotation, so it",
@@ -1365,11 +1365,11 @@ function renderSections(m) {
     '    - `deliverTo?`: `"channel"` (default) | `"sender"` | `"others"` | `"explicit"`. \u26A0 `"explicit"` still delivers to NOBODY \u2014 nothing selects recipients from inside a handler, and `s.realtime.publish` (which originates an event INTO a channel) is not a substitute.',
     '    - Only `"channel"`/`"others"` fan out AND are written to the `conversation` transcript \u2014 a `"sender"` response is invisible to every future joiner.',
     '  - **Both input surfaces read as ordinary inputs:** `inp("body")` for a payload field, `inp("room_id")` for the channel\'s `{room_id}`. No session lookup, no frame parsing.',
-    "    - A path param is bound ONCE at join and read from the connection thereafter, never from the frame \u2014 a sender cannot claim a room it did not join. The same values reach a channel `join`/`leave` trigger's stack.",
+    "    - A path param is bound ONCE at join and read from the connection thereafter, never from the frame \u2014 a sender cannot claim a room it did not join.",
     "  - `s.realtime.get_session({ as })` \u2014 the CALLER's realtime session for the current frame. FLAT shape:",
     '    - `authenticated` bool \xB7 `client_id` text (the AUTHED ROW ID as text, `""` anonymous) \xB7 `dbo_id` int (the auth TABLE\'s id \u2014 NOT the user\'s row id; `0` anonymous \u2014 to look the caller up use `client_id`. `dbo_id` is an int in the same position and typechecks, so a gate that keys on it finds no user and refuses EVERYONE) \xB7 `socket_id` int (transport id) \xB7 `channel` text (resolved path, `""` in a server trigger) \xB7 `params` object (bound path params, `{}` when none \u2014 `ref("session.params.room_id")`) \xB7 `extras` object \xB7 `opened_at` decimal.',
     "    - Works in a realtime MESSAGE stack and in CHANNEL and SERVER trigger stacks; off that path it degrades to an anonymous session.",
-    '    - For a path param prefer `inp("room_id")`. Reach for the session when you need the CONNECTION (identity/extras) \u2014 "who is this sender" on an anonymous-client channel.',
+    '    - 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) \u2014 "who is this sender" on an anonymous-client channel.',
     "    - \u26A0 THREE UNRELATED THINGS ARE CALLED A CLIENT ID: `session.client_id` (app-facing identity), `session.socket_id` (transport), and a frame's `options.client_id` (the at_least_once CURSOR handle). Conflating the first and last breaks at_least_once for anonymous clients.",
     "  - `s.realtime.publish({ server, channel, data, message?, authTable?, authId? })` \u2014 the PUSH direction: originate a server-authored event onto a channel from ANY stack, no client frame first.",
     "    - `server` is the handle or its NAME (resolved by name, not guid); `channel` is the FILLED-IN path (`channel.getChannel({ room_id: 42 })`), never the template \u2014 a constant still carrying `{param}` THROWS at author time, and a constant `server`/`channel` naming nothing this workspace registers WARNS at export.",
@@ -1437,8 +1437,8 @@ function renderSections(m) {
     "errorTrigger}({ name, guid?, description?, active?, tags?, ... })`.",
     "",
     '- `tableTrigger({ name, table?, datasources?, actions?: {insert?,update?,delete?,truncate?}, stack })` \u2014 database/table trigger. `t.new` / `t.old` are the row **after** / **before** the change; `t.action` (`insert|update|delete|truncate`), `t.datasource`. Bind `table` to a `table()` handle and `t.new("col")` / `t.old("col")` are typed to that row (misspelled column = compile error). Nullability follows the enabled actions: insert \u2192 `old` is null, delete \u2192 `new` is null, update \u2192 both, truncate \u2192 neither. Config-only (no response).',
-    "- `realtimeServerTrigger({ name, realtimeServer, actions?: {connect?,disconnect?}, stack?, response?, responseShape? })` \u2014 realtime SERVER lifecycle (a client connecting to / disconnecting from the server, not a message). Inputs: `t.action` (`connect|disconnect`), `t.realtime_server`, `t.client`. Bind `realtimeServer` to a `realtimeServer()` handle (or its name). `connect` GATES the connection \u2014 a denial sends an `error` and CLOSES the socket with code 4401 before it is ever ready, so it is a real front door, not an observer; same return shape as a channel `join` (`{ allowed: c.bool(true) }` or any truthy value admits, EMPTY/FALSY DENIES \u2014 INCLUDING a gating trigger with NO `response`, which returns nothing and so refuses every client). A CRASH DENIES too \u2014 the transport seeds a deny and keeps it on a throw. Both failure modes lock the door, so plan for a self-inflicted LOCKOUT (an unguarded drill into a null `db.get` raises \u2192 everyone refused), not a breach. Gating is OPT-IN: a server with no `connect` trigger accepts every connection. `disconnect` is OBSERVATIONAL (return ignored, throws swallowed \u2014 cleanup must always complete). Both are SERVER-scoped, so `s.realtime.get_session` works but carries no channel path and no bound params.",
-    '- `realtimeChannelTrigger({ name, channel, actions?: {join?,leave?,deliver?}, stack?, response?, responseShape? })` \u2014 realtime CHANNEL lifecycle. Inputs: `t.action` (`join|leave|deliver`), `t.channel`, `t.client`. Bind `channel` to a `realtimeChannel()` handle \u2014 a bare path is NOT accepted (it is unique only within its server). The three actions have DIFFERENT postures, and the posture decides what the stack should return: `join` GATES the join (it runs BEFORE the client becomes a member, so a denial means it never sees a fan-out) \u2014 return `{ allowed: c.bool(true) }` (optional `reason` reaches the client) or any truthy value to admit, and an EMPTY OR FALSY RETURN DENIES, so a stack that just falls through \u2014 or a gating trigger with NO `response` \u2014 refuses everyone, and a CRASH DENIES too. That is the inverse of a normal message (a crashing message still delivers) and of `deliver` below (a gate that fails OPEN). `join`/`leave` bind the channel\'s typed path params as INPUTS, so `inp("room_id")` resolves and the gate decides per room; a SERVER connect/disconnect has no channel, the one place a path param cannot be read; `leave` is OBSERVATIONAL (return ignored, throws swallowed); `deliver` GATES delivery PER RECIPIENT \u2014 the per-viewer redaction tool and the most expensive action here (a stack per recipient per message), and it needs `delivery.perRecipient` on the channel to run at all \u2014 BOTH HALVES are required, so a `deliver` trigger on a channel without the flag NEVER RUNS and every subscriber receives the UNREDACTED payload (no error, no log line); `export()` warns on each half alone. **`deliver`\'s RETURN VALUES DO NOT READ LIKE A FILTER:** ONLY an explicit NULL drops the message for that recipient; an OBJECT replaces that recipient\'s payload; ANYTHING ELSE \u2014 INCLUDING `false`, `0`, `""` \u2014 DELIVERS IT UNCHANGED, as does a crash. So `return false` from a yes/no redaction check SENDS the message it was written to suppress \u2014 return null instead. The delivered payload arrives NESTED, so read `inp("payload").<field>`, and `t.client` is the SENDER while `s.realtime.get_session` describes the RECIPIENT this run is for.',
+    "- `realtimeServerTrigger({ name, realtimeServer, actions?: {connect?,disconnect?}, stack?, response?, responseShape? })` \u2014 realtime SERVER lifecycle (a client connecting to / disconnecting from the server, not a message). Inputs: `t.action` (`connect|disconnect`), `t.realtime_server`, `t.client`. Bind `realtimeServer` to a `realtimeServer()` handle (or its name). `connect` GATES the connection \u2014 a denial sends an `error` and CLOSES the socket with code 4401 before it is ever ready, so it is a real front door, not an observer; same return shape as a channel `join` below (EMPTY/FALSY DENIES \u2014 INCLUDING a gating trigger with NO `response`, which returns nothing and so refuses every client). A CRASH DENIES too \u2014 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 \u2192 everyone refused), not a breach. Gating is OPT-IN: a server with no `connect` trigger accepts every connection. `disconnect` is OBSERVATIONAL (return ignored, throws swallowed \u2014 cleanup must always complete). Both are SERVER-scoped, so `s.realtime.get_session` works but carries no channel path and no bound params.",
+    '- `realtimeChannelTrigger({ name, channel, actions?: {join?,leave?,deliver?}, stack?, response?, responseShape? })` \u2014 realtime CHANNEL lifecycle. Inputs: `t.action` (`join|leave|deliver`), `t.channel`, `t.payload`, `t.client`. Bind `channel` to a `realtimeChannel()` handle \u2014 a bare path is NOT accepted (it is unique only within its server). The three actions have DIFFERENT postures, and the posture decides what the stack should return: `join` GATES the join (it runs BEFORE the client becomes a member, so a denial means it never sees a fan-out) \u2014 return `{ allowed: c.bool(true) }` (optional `reason` reaches the client) or any truthy value to admit, and an EMPTY OR FALSY RETURN DENIES, so a stack that just falls through \u2014 or a gating trigger with NO `response` \u2014 refuses everyone, and a CRASH DENIES too. ONCE the object carries an `allowed` key admission needs STRICTLY `true` \u2014 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 \u2014 `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 \u2014 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 \u2014 the per-viewer redaction tool and the most expensive action here (a stack per recipient per message), and it needs `delivery.perRecipient` on the channel to run at all \u2014 BOTH HALVES are required, so a `deliver` trigger on a channel without the flag NEVER RUNS and every subscriber receives the UNREDACTED payload (no error, no log line); `export()` warns on each half alone. **`deliver`\'s RETURN VALUES DO NOT READ LIKE A FILTER:** ONLY an explicit NULL drops the message for that recipient; an OBJECT replaces that recipient\'s payload; ANYTHING ELSE \u2014 INCLUDING `false`, `0`, `""` \u2014 DELIVERS IT UNCHANGED, as does a crash. So `return false` from a yes/no redaction check SENDS the message it was written to suppress \u2014 return null instead. The delivered payload arrives NESTED, so read `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? })` \u2014 toolset connection. Bind with the `mcpServer()`/`agent()` def handle (or its name) \u2014 it resolves to the toolset guid at export. Raw numeric `objId` is the escape hatch, rarely right: ids are assigned at import, so a handle passed to `objId` is a type error, and binding nothing deploys a trigger that never fires. Inputs: `t.toolset` (`t.toolset("name")`), `t.tools`. Response-bearing; the default stack copies `toolset`/`tools` into vars and returns them.',
     "- `workspaceTrigger({ name, actions?: {branch_live?,branch_merge?,branch_new?}, stack? })` \u2014 branch lifecycle. Inputs: `t.to_branch`, `t.from_branch`, `t.action`. Config-only.",
     '- `errorTrigger({ name, stack? })` \u2014 error-signature trigger. Inputs: `t.event` (`new|regression|fixed`), `t.id`, `t.signature`, `t.error` (`t.error("code")`/`t.error("message")`), `t.caller`, `t.statement`, `t.actor`, `t.count`, `t.first_seen`, `t.last_seen`, `t.fixed_at`. Config-only.',

package/dist/{lock-commands-WCRC56ME.js → lock-commands-6U7UIJGR.js}

@@ -1,6 +1,6 @@
 import {
   loadDefault
-} from "./chunk-XT3XQ4PF.js";
+} from "./chunk-RLI6XD4O.js";
 import "./chunk-7WRJPKGK.js";
 import {
   readLockFile,
@@ -15,7 +15,7 @@ import "./chunk-GNPVYOPB.js";
 import "./chunk-EZG76F7R.js";
 import {
   Xano
-} from "./chunk-QYSQ3UDO.js";
+} from "./chunk-MEFMTICH.js";
 import "./chunk-V5Y7D4LH.js";
 import "./chunk-N74KDCBD.js";
 import "./chunk-EETVJZAZ.js";
@@ -231,4 +231,4 @@ ${lines}
 export {
   runLockCommand
 };
-//# sourceMappingURL=lock-commands-WCRC56ME.js.map
+//# sourceMappingURL=lock-commands-6U7UIJGR.js.map

package/dist/node.d.ts

@@ -1,5 +1,5 @@
-import { aZ as LambdaOptions, a_ as CaptureValue, a$ as LambdaSurface, b0 as CaptureRecord, b1 as LambdaBindings, F as FunctionDef, b2 as Xano, i as LockFile } from './store-DAnUIi1T.js';
-export { b3 as AddonDef, b4 as AddonXdo, A as AdoptChange, a as AdoptResult, b5 as AgentDef, b6 as AgentHandle, b7 as AgentOutput, b8 as AgentSettingsXdo, b9 as AgentXdo, ba as AmbientBindings, bb as AnthropicLlm, bc as ApiGroupDef, bd as ApiGroupXdo, be as AuthRef, bf as Authored, B as Bundle, b as BundlePayload, c as BundleType, bg as Capturable, bh as ChannelConversationDef, bi as ChannelDeliveryDef, bj as ChannelDeliveryGuarantee, bk as ChannelPublishDef, bl as ChannelPublishWho, bm as ChannelRateLimitDef, bn as ColumnDef, bo as Comparison, bp as ContainerEnv, bq as ContainerPort, br as ContainerResources, bs as ContainerVolume, bt as CorsConfig, bu as CorsMode, bv as DatabaseActions, bw as DatabaseInputs, bx as DbEval, by as DbEvalFilter, bz as DbWhere, bA as ErrorInputs, bB as ExceptionPolicy, bC as FieldAccessor, bD as FieldRule, bE as GoogleGenAiLlm, bF as HistoryInput, bG as HttpVerb, bH as IndexDef, bI as IndexLang, bJ as IndexOp, bK as IndexType, bL as IndexXdo, bM as InferRow, bN as InputDescriptor, bO as InputOptions, bP as IteratingBindings, bQ as KnowledgeDef, bR as KnowledgeDirSource, bS as KnowledgeFileSource, bT as KnowledgeMode, bU as KnowledgeType, bV as LAMBDA_BINDINGS, bW as LAMBDA_CODE_FILTERS, bX as LAMBDA_GLOBALS, bY as LAMBDA_MODULE_GLOBALS, bZ as LAMBDA_STATEMENTS, b_ as LambdaBody, b$ as LlmPrompt, c0 as LlmProvider, c1 as LlmSettings, g as LockEntry, h as LockExportContext, M as Manifest, j as ManifestField, k as ManifestKind, l as ManifestStatement, c2 as ManifestValue, c3 as McpPathOptions, c4 as McpServerDef, c5 as McpServerHandle, c6 as McpServerXdo, m as MergeResult, c7 as MessageDeliverTo, c8 as MicroserviceChart, c9 as MicroserviceConfig, ca as MicroserviceContainer, cb as MicroserviceDef, cc as MicroserviceDeployment, cd as MicroserviceIngress, ce as MicroserviceRegistryAuth, cf as MicroserviceVolume, cg as MicroserviceXdo, ch as MiddlewareAttach, ci as MiddlewareAttachEntry, cj as MiddlewareDef, ck as MiddlewareXdo, O as ObjectKind, cl as OpenAiLlm, n as PayloadArrayKey, cm as QueryDef, cn as QueryFilterName, co as QueryHandle, cp as QueryResponseType, cq as QueryXdo, cr as RealtimeActions, cs as RealtimeChannelActions, ct as RealtimeChannelDef, cu as RealtimeChannelHandle, cv as RealtimeChannelRef, cw as RealtimeChannelTriggerInputs, cx as RealtimeChannelXdo, cy as RealtimeClient, cz as RealtimeInputs, cA as RealtimeMessageDef, cB as RealtimeMessageXdo, cC as RealtimeServerActions, cD as RealtimeServerDef, cE as RealtimeServerHandle, cF as RealtimeServerRef, cG as RealtimeServerTriggerInputs, cH as RealtimeServerXdo, cI as RealtimeUrlOptions, R as RenameResult, cJ as ResultStrategy, cK as Route, cL as RowOf, cM as ScheduleDef, cN as SchemaCols, cO as SchemaDef, cP as SearchComparison, cQ as SearchGroup, cR as SearchNode, cS as SearchOp, cT as SearchParamValue, cU as SeedFileSource, cV as SeedRow, cW as SeedSource, cX as SortDir, cY as SortDirective, S as StatementSpec, cZ as TableDef, c_ as TableXdo, c$ as TaskDef, d0 as TaskXdo, d1 as ToolDef, d2 as ToolXdo, d3 as ToolsetBaseDef, d4 as ToolsetBaseXdo, d5 as ToolsetInputs, d6 as ToolsetToolEntry, d7 as ToolsetToolRef, d8 as TriggerDef, d9 as TriggerObjType, da as TriggerXdo, db as ViewDef, dc as ViewXdo, dd as WorkflowTestDef, de as WorkflowTestXdo, df as WorkspaceActions, dg as WorkspaceConfigDef, dh as WorkspaceConfigXdo, di as WorkspaceHistoryDef, dj as WorkspaceHistoryXdo, dk as WorkspaceInputs, dl as WorkspaceMiddlewareDef, dm as WorkspaceMiddlewareXdo, dn as XanoFreeLlm, dp as addon, dq as agent, dr as agentTrigger, ds as and, dt as apiGroup, du as assertLambdaBody, dv as bitwiseAnd, dw as bitwiseOr, dx as bitwiseXor, dy as cmp, dz as defineFunction, dA as emit, dB as emitBundle, dC as errorTrigger, dD as expr, dE as fl, dF as input, dG as knowledge, dH as knowledgeDir, dI as knowledgeFile, dJ as mathAdd, dK as mathDiv, dL as mathMul, dM as mathSub, dN as mcpServer, dO as mcpServerTrigger, dP as microservice, dQ as middleware, dR as mixed, dS as objectEntries, dT as objectKeys, dU as objectValues, dV as or, dW as query, dX as realtimeChannel, dY as realtimeChannelTrigger, dZ as realtimeMessage, d_ as realtimeServer, d$ as realtimeServerTrigger, e0 as realtimeTrigger, e1 as resetLockOverrides, e2 as seedFile, e3 as seedLockOverrides, e4 as table, e5 as tableTrigger, e6 as task, e7 as textAppend, e8 as textPrepend, e9 as toSearchParams, ea as tool, eb as workflowTest, ec as workspace, ed as workspaceConfig, ee as workspaceTrigger } from './store-DAnUIi1T.js';
+import { aZ as LambdaOptions, a_ as CaptureValue, a$ as LambdaSurface, b0 as CaptureRecord, b1 as LambdaBindings, F as FunctionDef, b2 as Xano, i as LockFile } from './store-9Psd0jiF.js';
+export { b3 as AddonDef, b4 as AddonXdo, A as AdoptChange, a as AdoptResult, b5 as AgentDef, b6 as AgentHandle, b7 as AgentOutput, b8 as AgentSettingsXdo, b9 as AgentXdo, ba as AmbientBindings, bb as AnthropicLlm, bc as ApiGroupDef, bd as ApiGroupXdo, be as AuthRef, bf as Authored, B as Bundle, b as BundlePayload, c as BundleType, bg as Capturable, bh as ChannelConversationDef, bi as ChannelDeliveryDef, bj as ChannelDeliveryGuarantee, bk as ChannelPublishDef, bl as ChannelPublishWho, bm as ChannelRateLimitDef, bn as ColumnDef, bo as Comparison, bp as ContainerEnv, bq as ContainerPort, br as ContainerResources, bs as ContainerVolume, bt as CorsConfig, bu as CorsMode, bv as DatabaseActions, bw as DatabaseInputs, bx as DbEval, by as DbEvalFilter, bz as DbWhere, bA as ErrorInputs, bB as ExceptionPolicy, bC as FieldAccessor, bD as FieldRule, bE as GoogleGenAiLlm, bF as HistoryInput, bG as HttpVerb, bH as IndexDef, bI as IndexLang, bJ as IndexOp, bK as IndexType, bL as IndexXdo, bM as InferRow, bN as InputDescriptor, bO as InputOptions, bP as IteratingBindings, bQ as KnowledgeDef, bR as KnowledgeDirSource, bS as KnowledgeFileSource, bT as KnowledgeMode, bU as KnowledgeType, bV as LAMBDA_BINDINGS, bW as LAMBDA_CODE_FILTERS, bX as LAMBDA_GLOBALS, bY as LAMBDA_MODULE_GLOBALS, bZ as LAMBDA_STATEMENTS, b_ as LambdaBody, b$ as LlmPrompt, c0 as LlmProvider, c1 as LlmSettings, g as LockEntry, h as LockExportContext, M as Manifest, j as ManifestField, k as ManifestKind, l as ManifestStatement, c2 as ManifestValue, c3 as McpPathOptions, c4 as McpServerDef, c5 as McpServerHandle, c6 as McpServerXdo, m as MergeResult, c7 as MessageDeliverTo, c8 as MicroserviceChart, c9 as MicroserviceConfig, ca as MicroserviceContainer, cb as MicroserviceDef, cc as MicroserviceDeployment, cd as MicroserviceIngress, ce as MicroserviceRegistryAuth, cf as MicroserviceVolume, cg as MicroserviceXdo, ch as MiddlewareAttach, ci as MiddlewareAttachEntry, cj as MiddlewareDef, ck as MiddlewareXdo, O as ObjectKind, cl as OpenAiLlm, n as PayloadArrayKey, cm as QueryDef, cn as QueryFilterName, co as QueryHandle, cp as QueryResponseType, cq as QueryXdo, cr as RealtimeActions, cs as RealtimeChannelActions, ct as RealtimeChannelDef, cu as RealtimeChannelHandle, cv as RealtimeChannelRef, cw as RealtimeChannelTriggerInputs, cx as RealtimeChannelXdo, cy as RealtimeClient, cz as RealtimeInputs, cA as RealtimeMessageDef, cB as RealtimeMessageXdo, cC as RealtimeServerActions, cD as RealtimeServerDef, cE as RealtimeServerHandle, cF as RealtimeServerRef, cG as RealtimeServerTriggerInputs, cH as RealtimeServerXdo, cI as RealtimeUrlOptions, R as RenameResult, cJ as ResultStrategy, cK as Route, cL as RowOf, cM as ScheduleDef, cN as SchemaCols, cO as SchemaDef, cP as SearchComparison, cQ as SearchGroup, cR as SearchNode, cS as SearchOp, cT as SearchParamValue, cU as SeedFileSource, cV as SeedRow, cW as SeedSource, cX as SortDir, cY as SortDirective, S as StatementSpec, cZ as TableDef, c_ as TableXdo, c$ as TaskDef, d0 as TaskXdo, d1 as ToolDef, d2 as ToolXdo, d3 as ToolsetBaseDef, d4 as ToolsetBaseXdo, d5 as ToolsetInputs, d6 as ToolsetToolEntry, d7 as ToolsetToolRef, d8 as TriggerDef, d9 as TriggerObjType, da as TriggerXdo, db as ViewDef, dc as ViewXdo, dd as WorkflowTestDef, de as WorkflowTestXdo, df as WorkspaceActions, dg as WorkspaceConfigDef, dh as WorkspaceConfigXdo, di as WorkspaceHistoryDef, dj as WorkspaceHistoryXdo, dk as WorkspaceInputs, dl as WorkspaceMiddlewareDef, dm as WorkspaceMiddlewareXdo, dn as XanoFreeLlm, dp as addon, dq as agent, dr as agentTrigger, ds as and, dt as apiGroup, du as assertLambdaBody, dv as bitwiseAnd, dw as bitwiseOr, dx as bitwiseXor, dy as cmp, dz as defineFunction, dA as emit, dB as emitBundle, dC as errorTrigger, dD as expr, dE as fl, dF as input, dG as knowledge, dH as knowledgeDir, dI as knowledgeFile, dJ as mathAdd, dK as mathDiv, dL as mathMul, dM as mathSub, dN as mcpServer, dO as mcpServerTrigger, dP as microservice, dQ as middleware, dR as mixed, dS as objectEntries, dT as objectKeys, dU as objectValues, dV as or, dW as query, dX as realtimeChannel, dY as realtimeChannelTrigger, dZ as realtimeMessage, d_ as realtimeServer, d$ as realtimeServerTrigger, e0 as realtimeTrigger, e1 as resetLockOverrides, e2 as seedFile, e3 as seedLockOverrides, e4 as table, e5 as tableTrigger, e6 as task, e7 as textAppend, e8 as textPrepend, e9 as toSearchParams, ea as tool, eb as workflowTest, ec as workspace, ed as workspaceConfig, ee as workspaceTrigger } from './store-9Psd0jiF.js';
 export { ActionCallArgs, AddonCallArgs, AddonSpec, AgentRunResult, AiAgentRunArgs, AnyAddonDef, AnyFunctionDef, AnyQueryDef, AnyTableDef, ApiCallArgs, ApplyFilter, ApplyFilters, ArrayMapArgs, CloudJobArgs, CloudJobAwaitArgs, CloudJobStatusArgs, CreateAuthTokenArgs, DbAddArgs, DbAddOrEditArgs, DbAggregate, DbAggregatePaging, DbBind, DbBulkAddArgs, DbBulkDeleteArgs, DbBulkWriteArgs, DbDelArgs, DbDirectQueryArgs, DbDistinct, DbEditArgs, DbExternal, DbExternalPermissions, DbExternalQueryArgs, DbField, DbGetArgs, DbHasArgs, DbJoin, DbPaging, DbPatchArgs, DbQueryArgs, DbResponseType, DbReturnType, DbSchemaArgs, DbTransactionArgs, DbTruncateArgs, ExpectToThrowArgs, ExternalSqlEngine, ForArgs, ForeachArgs, FunctionCallArgs, FunctionRunArgs, GetRawInputArgs, HeaderMap, HttpMethod, InferInput, InferResponse, IpLookupArgs, IpLookupResult, MiddlewareCallArgs, RealtimeEventArgs, StackTupleWidened, SwitchArgs, SwitchCaseArgs, TaskCallArgs, ToolCallArgs, TriggerCallArgs, TryCatchArgs, WhileArgs, WorkflowTestCallArgs, actionCall, actionPackageCall, addonCall, aiAgentRun, apiCall, arrayMap, arrayUnion, cloudJob, cloudJobAwait, cloudJobStatus, comment, compile, conditional, createAuthToken, dbAdd, dbAddOrEdit, dbBulkAdd, dbBulkDelete, dbBulkPatch, dbBulkUpdate, dbDel, dbDirectQuery, dbEdit, dbExternalQuery, dbGet, dbHas, dbPatch, dbQuery, dbSchema, dbTransaction, dbTruncate, debugLog, die, expectToThrow, fileUrl, forLoop, foreachBreak, foreachContinue, foreachLoop, foreachRemove, functionCall, functionRun, getRawInput, group, ignored, ipLookup, middlewareCall, postProcess, realtimeEvent, returnValue, s, setVar, switchCase, switchStatement, taskCall, toolCall, triggerCall, tryCatch, updateVar, whileLoop, workflowTestCall } from './index.js';
 export { B as BrandOpts, b as BrandValue, D as DecimalMethod, E as EmailMethod, c as FieldAccess, f as FieldDescriptor, h as FieldMap, j as FieldOpts, k as FieldStyleType, l as FromFieldMap, I as IntMethod, M as MethodArg, m as MethodOpts, n as MethodSpec, o as MockEntry, p as MockMap, q as MockXdo, O as ObjInput, s as ObjMember, u as ObjValue, v as ObjectRef, P as PasswordMethod, w as ResponseDef, x as RowFromFieldMap, S as Statement, y as StatementAnnotations, z as StatementOptions, T as TableRefMethod, A as TextFormat, C as TextMethod, G as TypeBrand, V as ValueOf, H as VectorMethod, X as XanoFileRef, J as XanoGeoPosition, K as XanoGeoValue, L as annotate, N as f, Q as obj, U as statements } from './response-D6xGLEIn.js';
 import { V as Value } from './xdo-ODuJklk6.js';

package/dist/node.js

@@ -17,7 +17,7 @@ import {
   task,
   tool,
   workflowTest
-} from "./chunk-VRNZ2NVV.js";
+} from "./chunk-PJNWOZMT.js";
 import {
   actionCall,
   actionPackageCall,
@@ -100,7 +100,7 @@ import {
   workflowTestCall,
   workspaceConfig,
   workspaceTrigger
-} from "./chunk-GSP2BY4F.js";
+} from "./chunk-BYQHCCYU.js";
 import {
   exportBundleJson,
   loadDefault,
@@ -108,7 +108,7 @@ import {
   run,
   writeArtifact,
   writeBundle
-} from "./chunk-XT3XQ4PF.js";
+} from "./chunk-RLI6XD4O.js";
 import "./chunk-7WRJPKGK.js";
 import {
   readLockFile,
@@ -120,7 +120,7 @@ import "./chunk-EZG76F7R.js";
 import {
   Xano,
   workspace
-} from "./chunk-QYSQ3UDO.js";
+} from "./chunk-MEFMTICH.js";
 import "./chunk-V5Y7D4LH.js";
 import {
   LAMBDA_BINDINGS,

package/dist/{preflight-command-TZWPHBXY.js → preflight-command-UYE7SUQV.js}

@@ -1,8 +1,8 @@
 import {
   assertBundleInput,
   loadBundleText
-} from "./chunk-ELK7UALJ.js";
-import "./chunk-XT3XQ4PF.js";
+} from "./chunk-OONT4ZL4.js";
+import "./chunk-RLI6XD4O.js";
 import "./chunk-7WRJPKGK.js";
 import "./chunk-3LQGF2WS.js";
 import "./chunk-Z2ZIE5CO.js";
@@ -15,7 +15,7 @@ import {
   success,
   warn
 } from "./chunk-EZG76F7R.js";
-import "./chunk-QYSQ3UDO.js";
+import "./chunk-MEFMTICH.js";
 import "./chunk-V5Y7D4LH.js";
 import "./chunk-N74KDCBD.js";
 import "./chunk-EETVJZAZ.js";
@@ -121,4 +121,4 @@ function fmt(v) {
 export {
   runPreflightCommand
 };
-//# sourceMappingURL=preflight-command-TZWPHBXY.js.map
+//# sourceMappingURL=preflight-command-UYE7SUQV.js.map

package/dist/{release-command-WEFYRTCI.js → release-command-CMMYT6XK.js}

@@ -6,7 +6,7 @@ import {
 import {
   assertBundleInput,
   loadBundleText
-} from "./chunk-ELK7UALJ.js";
+} from "./chunk-OONT4ZL4.js";
 import {
   sharedSchemaChanges
 } from "./chunk-AOFFKSJC.js";
@@ -37,7 +37,7 @@ import "./chunk-NDP7OUPS.js";
 import "./chunk-AE3PDSDS.js";
 import {
   resolveLockPath
-} from "./chunk-XT3XQ4PF.js";
+} from "./chunk-RLI6XD4O.js";
 import "./chunk-7WRJPKGK.js";
 import {
   readLockFile
@@ -57,7 +57,7 @@ import {
   success,
   warn
 } from "./chunk-EZG76F7R.js";
-import "./chunk-QYSQ3UDO.js";
+import "./chunk-MEFMTICH.js";
 import "./chunk-V5Y7D4LH.js";
 import "./chunk-N74KDCBD.js";
 import "./chunk-EETVJZAZ.js";
@@ -447,7 +447,7 @@ async function runReleaseCommand(args) {
     { withSeed: req.records === true }
   );
   if (args.static !== void 0) {
-    const { assertNoSeedLeaks } = await import("./deploy-command-XHS5PKPV.js");
+    const { assertNoSeedLeaks } = await import("./deploy-command-CGVKRWUE.js");
     await assertNoSeedLeaks(args.static, nonPublicSeedValues, args.allowSeedInStatic);
   }
   const workspaceId = auth.workspaceId;
@@ -589,7 +589,7 @@ Retry, or drop \`--backup-branch\` to release without one.`,
     ...backupLabel !== void 0 ? { backupBranch: backupLabel } : {}
   };
   if (args.static !== void 0) {
-    const { buildStaticEnv, deployStaticTo } = await import("./deploy-command-XHS5PKPV.js");
+    const { buildStaticEnv, deployStaticTo } = await import("./deploy-command-CGVKRWUE.js");
     const env = buildStaticEnv(auth.instance, args.staticEnv);
     const explicit = Object.keys(args.staticEnv).length > 0;
     summary.static = await deployStaticTo(
@@ -608,4 +608,4 @@ Retry, or drop \`--backup-branch\` to release without one.`,
 export {
   runReleaseCommand
 };
-//# sourceMappingURL=release-command-WEFYRTCI.js.map
+//# sourceMappingURL=release-command-CMMYT6XK.js.map

package/dist/{routes-manifest-5ZFKUQWA.js → routes-manifest-MN6XBYRE.js}

@@ -5,6 +5,9 @@ import {
 // src/emit/routes-manifest.ts
 var RouteManifestError = class extends Error {
 };
+function routeKey(route) {
+  return `${route.verb} ${route.name}`;
+}
 function literal(value) {
   return JSON.stringify(value);
 }
@@ -70,31 +73,33 @@ ${REALTIME_IMPLEMENTATION}`;
 }
 function renderRouteManifest(routes, realtime) {
   const sorted = [...routes].sort(
-    (a, b) => a.canonical.localeCompare(b.canonical) || a.name.localeCompare(b.name)
+    (a, b) => a.canonical.localeCompare(b.canonical) || a.name.localeCompare(b.name) || a.verb.localeCompare(b.verb)
   );
-  const seen = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Map();
   const rows = sorted.map((route) => {
-    if (seen.has(route.name)) {
+    const key = routeKey(route);
+    const clash = seen.get(key);
+    if (clash !== void 0) {
       throw new RouteManifestError(
-        `Two endpoints are both named "${route.name}". The route manifest keys on the endpoint name, so the names must be unique across api groups. Rename one.`
+        `Two endpoints are both "${key}" \u2014 one in the api group whose canonical is "${clash}", one in "${route.canonical}". The route manifest keys on "<VERB> <name>", so a verb+name pair must be unique across api groups. Rename one, or give it a different verb.`
       );
     }
-    seen.add(route.name);
-    const params = parsePathParams(`route "${route.name}"`, route.name);
+    seen.set(key, route.canonical);
+    const params = parsePathParams(`route "${key}"`, route.name);
     const path = `/api:${route.canonical}/${route.name.replace(/^\/+/, "")}`;
-    return { ...route, params, path };
+    return { ...route, key, params, path };
   });
   const entries = rows.map(
-    (r) => `  ${literal(r.name)}: { verb: ${literal(r.verb)}, path: ${literal(r.path)} },`
+    (r) => `  ${literal(r.key)}: { verb: ${literal(r.verb)}, path: ${literal(r.path)} },`
   );
   const realtimeSection = realtime && (realtime.servers.length > 0 || realtime.channels.length > 0) ? renderRealtime(realtime) : "";
   return `${HEADER}${FILL_PARAMS}
 export const ROUTES = ${objectLiteral(entries)} as const;
 
-/** Every endpoint name in this workspace. */
+/** Every endpoint in this workspace, keyed \`"<VERB> <name>"\` (e.g. \`"GET listings"\`). */
 export type RouteName = keyof typeof ROUTES;
 
-${overloadsFor("routePath", rows)}
+${overloadsFor("routePath", rows.map((r) => ({ name: r.key, params: r.params })))}
 ${IMPLEMENTATION}${realtimeSection}`;
 }
 var HEADER = `/**
@@ -157,7 +162,12 @@ export function routePath(name: RouteName, params?: Record<string, string | numb
   // Read through a widened view: a workspace with no endpoints at all makes
   // \`RouteName\` \`never\`, which cannot index the literal type.
   const route = (ROUTES as Record<string, { verb: string; path: string } | undefined>)[name];
-  if (!route) throw new Error(\`routePath: unknown route "\${String(name)}".\`);
+  if (!route) {
+    throw new Error(
+      \`routePath: unknown route "\${String(name)}". Routes are keyed "<VERB> <name>", \` +
+        'e.g. "GET listings" \u2014 regenerate the manifest if the endpoint is new.',
+    );
+  }
   return fillParams(\`routePath("\${String(name)}")\`, "route", route.path, params, true);
 }
 `;
@@ -239,6 +249,7 @@ export function socketUrl(
 `;
 export {
   RouteManifestError,
-  renderRouteManifest
+  renderRouteManifest,
+  routeKey
 };
-//# sourceMappingURL=routes-manifest-5ZFKUQWA.js.map
+//# sourceMappingURL=routes-manifest-MN6XBYRE.js.map

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

@@ -4763,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). */
@@ -5414,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
@@ -5444,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
@@ -5468,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.

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

@@ -21,8 +21,8 @@ import {
   registryUrl,
   suppressUpdateNotice,
   upgradeCommand
-} from "./chunk-AG5GCZDD.js";
-import "./chunk-XT3XQ4PF.js";
+} from "./chunk-2AY3PKF4.js";
+import "./chunk-RLI6XD4O.js";
 import "./chunk-7WRJPKGK.js";
 import "./chunk-3LQGF2WS.js";
 import "./chunk-Z2ZIE5CO.js";
@@ -35,7 +35,7 @@ import {
   success,
   warn
 } from "./chunk-EZG76F7R.js";
-import "./chunk-QYSQ3UDO.js";
+import "./chunk-MEFMTICH.js";
 import "./chunk-V5Y7D4LH.js";
 import "./chunk-N74KDCBD.js";
 import "./chunk-EETVJZAZ.js";
@@ -175,4 +175,4 @@ function messageOf(err) {
 export {
   runUpgradeCommand
 };
-//# sourceMappingURL=upgrade-command-GYEIMJBG.js.map
+//# sourceMappingURL=upgrade-command-A75DOIUH.js.map

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

@@ -11,7 +11,7 @@ import {
 } from "./chunk-NUQCEOKA.js";
 import {
   fetchWorkspaceBundle
-} from "./chunk-PLE5QQOZ.js";
+} from "./chunk-SS2V2QOG.js";
 import "./chunk-RQ3FXV4K.js";
 import "./chunk-K5IOND4K.js";
 import {
@@ -26,18 +26,18 @@ import {
   fetchOrExplain,
   httpFailure
 } from "./chunk-NDP7OUPS.js";
-import "./chunk-VPAWRBK5.js";
+import "./chunk-S3DOJOW4.js";
 import "./chunk-VK26K7AY.js";
 import "./chunk-ZSYZTGJH.js";
 import "./chunk-YX22LKQE.js";
 import "./chunk-6VNRMKFJ.js";
 import "./chunk-RQNMTDXD.js";
 import "./chunk-PR7OXHGZ.js";
-import "./chunk-GSP2BY4F.js";
+import "./chunk-BYQHCCYU.js";
 import "./chunk-EHP3WPEG.js";
 import "./chunk-AE3PDSDS.js";
 import "./chunk-DCMANKMX.js";
-import "./chunk-XT3XQ4PF.js";
+import "./chunk-RLI6XD4O.js";
 import "./chunk-7WRJPKGK.js";
 import "./chunk-3LQGF2WS.js";
 import {
@@ -51,7 +51,7 @@ import {
   step,
   success
 } from "./chunk-EZG76F7R.js";
-import "./chunk-QYSQ3UDO.js";
+import "./chunk-MEFMTICH.js";
 import "./chunk-V5Y7D4LH.js";
 import "./chunk-N74KDCBD.js";
 import "./chunk-EETVJZAZ.js";
@@ -160,4 +160,4 @@ async function runExport(args) {
 export {
   runWorkspaceCommand
 };
-//# sourceMappingURL=workspace-command-2ZTGT26W.js.map
+//# sourceMappingURL=workspace-command-YELP47SJ.js.map

package/guides/typed-frontend.md

@@ -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 ~200x saving, with no SDK code in the output. Route names and their `{param}` keys are still checked at compile
-time, so a backend rename is a compile error rather than a 404:
+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/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.