@xanots/sdk 0.0.12 → 0.0.14

package/dist/{lock-commands-WCRC56ME.js → lock-commands-4TX3BONI.js}

@@ -1,6 +1,6 @@
 import {
   loadDefault
-} from "./chunk-XT3XQ4PF.js";
+} from "./chunk-LISUHLWI.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-4TX3BONI.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-LISUHLWI.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-MTYGPNVT.js}

@@ -1,8 +1,8 @@
 import {
   assertBundleInput,
   loadBundleText
-} from "./chunk-ELK7UALJ.js";
-import "./chunk-XT3XQ4PF.js";
+} from "./chunk-UXPDQFG2.js";
+import "./chunk-LISUHLWI.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-MTYGPNVT.js.map

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

@@ -6,7 +6,7 @@ import {
 import {
   assertBundleInput,
   loadBundleText
-} from "./chunk-ELK7UALJ.js";
+} from "./chunk-UXPDQFG2.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-LISUHLWI.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-VBB7JYXH.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-VBB7JYXH.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-NXCPQDFF.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-GSH3M3N6.js}

@@ -3,12 +3,12 @@ import {
 } from "./chunk-ERQZFWIW.js";
 import {
   refreshAgentFiles
-} from "./chunk-2VTJSI6X.js";
+} from "./chunk-F3MRG7NI.js";
 import {
   isMachineOutput,
   writeJson
 } from "./chunk-NUQCEOKA.js";
-import "./chunk-VK26K7AY.js";
+import "./chunk-XBIFQWZM.js";
 import {
   runNpm
 } from "./chunk-ZSYZTGJH.js";
@@ -21,8 +21,8 @@ import {
   registryUrl,
   suppressUpdateNotice,
   upgradeCommand
-} from "./chunk-AG5GCZDD.js";
-import "./chunk-XT3XQ4PF.js";
+} from "./chunk-CII2TOE4.js";
+import "./chunk-LISUHLWI.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-GSH3M3N6.js.map

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

@@ -11,7 +11,7 @@ import {
 } from "./chunk-NUQCEOKA.js";
 import {
   fetchWorkspaceBundle
-} from "./chunk-PLE5QQOZ.js";
+} from "./chunk-UQMMFW32.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-VK26K7AY.js";
+import "./chunk-ORZINVGQ.js";
+import "./chunk-XBIFQWZM.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-LISUHLWI.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-XUOPLVQ4.js.map

package/guides/README.md

@@ -23,7 +23,7 @@ These guides are for humans. Agents read a different set, generated from the SDK
 sources so it cannot drift from what the code does:
 
 - **`llms.txt`** — a small always-read router: the mental model, the deploy contract, and
-  every gotcha, ending in a map of the topic files.
+  every cross-cutting gotcha, ending in a map of the topic files.
 - **`llms/*.md`** — one file per surface, opened only when that surface is in play.
 - **`manifest.json`** — the exhaustive per-entry catalog, reached by targeted lookup.
 

package/guides/coverage.md

@@ -53,8 +53,9 @@ can learn the SDK without reading source:
   --help` and the `cli` array in `manifest.json` do, from the same registry that generates
   the shell completions. The written version is the [CLI guide](cli.md).
 - **`llms/*.md`** — one file per surface (object def shapes, statements, values, fields,
-  filters, lambda bodies, and the legacy names a pulled workspace carries), read only when
-  that surface is in play. **`llms-full.txt`** is all
+  filters, lambda bodies, what a client pays to import a def, an index of exact error
+  strings, and the legacy names a pulled workspace carries), read only when that surface
+  is in play. **`llms-full.txt`** is all
   of them concatenated, for a reader that wants one file rather than two.
 - **`manifest.json`** — the exhaustive reference tier, reached by targeted lookup (grep or
   `jq` one entry; never read it whole). Every object kind (factory, `Xano.register*` method,

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

@@ -0,0 +1,44 @@
+# Consuming defs from a client
+
+> Read when a frontend imports a def (`getPath()`/`InferResponse`) or calls the deployed backend — what the import costs, `window.XANO_HOST`, local dev, file URLs, and a Node spot-check.
+
+Importing a def into a browser bundle or a Node script — for `getPath()`, `getUrl()`, `verb`, or `InferResponse` — runs its factory calls; these are the costs and the checks.
+
+- **Client bundle size / tree-shaking.** `@xanots/sdk` is `sideEffects: false` and pulls
+  no Node built-ins, so a bundler drops unused SDK exports. But importing a **def** for its
+  `getPath()`/`verb`/`getUrl()`/`getChannel()` also pulls whatever its `stack` references:
+  the `s.*`/`c.*` factory CALLS run at module load to BUILD it. Types are free.
+  ⚠ A FLOOR — **~267 kB minified (~65 kB gzipped)** for the FIRST def; splitting modules
+  never removes it. The floor is the RUNTIME, not the def: a second or much richer def
+  adds ~2 kB, so trimming a def does not shrink it.
+  Fix: `xanots routes <entry> --emit xano/routes.gen.ts` (`paths` is an accepted alias) — verbs, paths, and sockets as
+  plain data importing NOTHING, still compile-checked: `routePath("GET blog/{slug}", { slug })`
+  `channelPath("rooms/{room_id}", { room_id })`, `socketUrl("chat", baseUrl)` (tenant base
+  URLs lifted to `wss://h/ws/<tenant>:<canonical>`). A rename is a type error, not a 404.
+- **Verifying a def outside a bundler.** Inside a bundler (Vite/webpack) importing a
+  query def to read `getPath()`/`verb` works directly. To spot-check from Node, run a REAL
+  file with `tsx <file.ts>` **from inside the project root** — not `tsx -e "import …"`
+  (its CJS-preparse mis-resolves the package `exports` map → ERR_PACKAGE_PATH_NOT_EXPORTED),
+  and not bare `node file.ts` (chokes on the `.js`-specifier intra-workspace imports the
+  xanots CLI's own loader resolves). Running from outside the project root also breaks
+  the `@xanots/sdk` specifier resolution.
+
+**Reading the injected backend URL.** `xanots deploy <entry> --static <dir>` writes the deployed env's URL
+into every html document: a prerendered build serves a different one per
+route, and a route without the global renders fine while every call goes to the wrong
+origin. Read it at runtime with a build-time fallback:
+  const HOST = (typeof window !== 'undefined' && window.XANO_HOST) || import.meta.env.VITE_XANO_HOST;
+In LOCAL DEV there is no injected global, so the fallback is what answers: set
+`VITE_XANO_HOST` in a `.env.local` beside `.env.example` at the PROJECT ROOT. The
+scaffold's vite config sets `envDir` there (its `root` is `frontend/`, and Vite
+resolves `.env` files against `root`) — without it the var reads as undefined, the
+host falls back to '', and every call 404s off the dev server.
+⚠ It is INJECTED in bracket form — `window["XANO_HOST"]="…"` — so verifying a deploy
+by grepping `window.XANO_HOST` matches nothing and reads as a failed inject. Grep the
+bare `XANO_HOST` token.
+**Displaying a stored file.** A file column comes back as `{ path, name, type, size,
+meta, access, url }`. ⚠ Do NOT use its `url`: on a tenant-scoped environment that field
+addresses the instance host WITHOUT the `/tenant/<name>` segment and 404s, silently —
+as a broken `<img>`, with every API assertion still passing. Build the URL from `path`
+instead: `fileUrl(row.avatar, HOST)` returns `null` for
+an absent file and is correct on an ephemeral and an instance workspace alike.

package/llms/errors.md

@@ -0,0 +1,33 @@
+# Error index
+
+> Read when a request, test, build, or pull fails with a message you did not write — the string, its cause, and where the fix is.
+
+### Request-time (deployed) failures
+
+- `Unable to locate input: <name>` — `inp()` names an undeclared input, or an attached middleware reads its own `input` (never bound). Declare it; a stack value is `ref("var.field")`; middleware reads the body with `s.util.get_all_input`. `llms.txt`; `llms/kinds-core.md`.
+- `Unable to locate var: <a.b>` (HTTP 500) — a dotted `ref` into a null base (a `db.get` miss), or a column absent from the row (`f.password` is `internal`). Guard existence first, or use the null-safe `safe` option; name the column in `output`. `llms.txt`.
+- `Missing var entry: <name>` inside `s.expect.to_throw` — the body runs in an isolated var stack; bind what it needs inside the body. `llms/tests.md`.
+- `Missing param: field_value` (HTTP 400) — a `db.*` match argument resolved to `null` (a safe ref, a nullable foreign key). Guard existence before the lookup; an optional FK stores `0` and is read with field-match `db.get`. `llms.txt`; `llms/fields.md`.
+- `Value is less than the minimum value of 1` (HTTP 400) — `db.get_by_id` given `0`; use field-match `db.get`. `llms/statements-data.md`.
+- `Invalid op: <op>` — a `cmp` operator (`in`, `like`, …) in a RUNTIME condition, which takes the `expr` set only; write `or(expr(...), expr(...))`. `llms/kinds-core.md`.
+- `Unsupported param format` / `Unsupported parameter reference` — an aggregate or `eval` `name` that is not a bare column, or a bare `eval` name for a joined column. `llms/statements-data.md`.
+- `ParseError: Invalid value for param` (HTTP 400) — `contains`/`@>`/`overlaps` on a text column (use `includes`), or a joined column qualified without `tableAlias`. `llms/statements-data.md`.
+- `ERROR_FATAL: <Type> does not exist: <type>:<n>` — `s.api.call`/`s.task.call`/`s.trigger.call`/`s.workflow_test.call` outside a workflow test; share logic via `defineFunction` + `s.function.run`. `llms.txt`.
+- `ERROR_FATAL "Unable to decode."` — a populated JSON string where the engine expects `c.obj`'s form; write `c.obj({...})` or `obj({...})`. `llms/values.md`.
+- `Precondition failed.` in place of your message — `error` was a bare string; pass `c.text("…")`. `llms/fields.md`.
+- `Param: token - Text filter requires an integer, float, string or boolean value` — `s.api.call` `auth.token` given a tagged `Value`; it must be a bare string. `llms/statements-calls.md`.
+- Every `s.db.add` into one table 400s naming a column while complaining about its VALUE — the column is named `run`. `llms.txt`.
+- HTTP 200 with an EMPTY body where `0` was expected — a bare `returnType: "count"` of zero; wrap it as `{ count: ref("n") }`. `llms/statements-data.md`.
+- A lambda returns error TEXT with HTTP 200 (`Could not resolve "node:crypto"`, an undefined-binding message) — the body threw; use the preloaded globals, the surface's bindings, and `capture`. `llms/lambda.md`.
+- `Unable to locate request.` (404) on an endpoint that deployed — a lowercase verb, a `.` in the name, or a CORS `mode` typo that dropped the whole API group. `llms/kinds-core.md`.
+- A browser call fails on a missing `access-control-allow-origin` while deploy looks fine — CORS `mode: "custom"` with `"*"` or an unmatched origin. `llms/kinds-core.md`.
+- A websocket is closed right after the handshake — a refused `connect` gate: an empty/falsy return, a crash, or a gating trigger with no `response`. `llms/triggers.md`.
+- `to_throw failed - response is ok` around an auth-refused call — `ERROR_CODE_ACCESS_DENIED` carries no message; the auth gate is not reachable from a workflow test. `llms/tests.md`.
+- Output reads `Hi [object Object]` — a tagged value inside a JS template literal; compose at runtime with `withFilters` + `fl.concat`. `llms.txt`.
+
+### Build-time and tooling failures
+
+- `must be ES modules` — package.json says `"type": "commonjs"`; set `"type": "module"`. `llms.txt` Quickstart.
+- A response types as `StackTupleWidened` — a `Statement[]` helper was spread into the stack; return `statements(...)`. `llms.txt`; `llms/statements-runtime.md`.
+- `ERR_PACKAGE_PATH_NOT_EXPORTED` — `tsx -e "import …"`, or running from outside the project root; run a real file with `tsx <file.ts>` from the root. `llms/client.md`.
+- `Missing statement: mvp:placeholder` on import — an unconfigured slot in a pulled tree; replace it with the statement it stands in for. `llms/legacy.md`.

package/llms/fields.md

@@ -1,6 +1,6 @@
 # Column and input types
 
-> Read when declaring a table column (`f.*`) or a function/query input (`input.*`) — a type's options and accessor methods, and the `s.precondition` error/status contract that rides the same catalog.
+> Read when declaring a table column (`f.*`) or a function/query input (`input.*`) — a type's options and methods, and the `s.precondition` error/status contract. Also `table({ seed })` rows and `use_xdo`.
 
 Author table columns + function/API inputs with the typed catalog: `f.<type>(opts?)`
 for columns, `input.<type>(opts?)` for inputs. Common opts: `required`, `nullable`,
@@ -45,6 +45,31 @@ any `SearchOp`: give the table `index: [{ type: "vector", fields: [{ name: "embe
 queries it.
 `{ array: true }` makes any `f.*` scalar a **list column** — `f.text({ array: true })`
 surfaces as `string[]` in `InferRow<typeof table>` (the column analogue of `input.list`).
+**Seed a table's starting rows with `table({ seed })`.** `seed` takes rows
+typed against the table's schema as a WRITE shape (a column without
+`required: true`, and the system columns, may be omitted; `null` needs
+`nullable: true`) — inline (`seed: [{ name: "…" }]`), a FILE
+(`seed: seedFile("./seed.json", import.meta.url)`; path resolves against the DECLARING
+file), or a thunk (`seed: () => import("./seed.json")`, async ok, `.default` unwrapped).
+Inline rows are TYPED against the schema at compile time; a `seedFile`/thunk seed is
+NOT — the JSON is opaque to the typechecker, and the `xanots export`/`deploy` CLI
+validates it instead, naming the row index, the offending column, and the known
+columns. ⚠ Prefer `seedFile` for a file: a thunk's `import()` sits in
+YOUR module, so a bundler emits the JSON as a served chunk. NEITHER is a secrecy
+boundary — a bundler that inlines the asset ships them either way. Never put secrets
+in `seed`. `deploy --static` REFUSES a build carrying internal/sensitive seed values;
+`--allow-seed-in-static` overrides for deliberately public demo credentials.
+Deploy is a full replace, so re-deploying re-seeds
+cleanly (no duplication). Omit `id` and rows auto-number `1..N` (int PK) or take
+a stable derived uuid (uuid PK); supplying `id` pins it (engine preserves it,
+resets an int sequence past the max). All-or-nothing — mixing explicit and
+omitted `id` throws. A `system:false` PK is the author's to supply. Pinning is
+`seed`-only — `s.db.bulk.add` DROPS `id` unless `allowIdField: true`.
+**`use_xdo` storage mode.** Workspace setting (`registerWorkspace({ use_xdo })`,
+default `false`) controlling whether fields are stored as JSON under the `xdo`
+column (`true`, adds a `gin(xdo)` index) or as real columns (`false`, no gin).
+Tables inherit it; override per-table with `table({ useXdo })`. Resolved at
+`export()`, so the workspace and tables can be registered in any order.
 A **column `default` must stay within the BMP** — a 4-byte character (codepoint > U+FFFF,
 e.g. an emoji) is mangled into invalid UTF-8 by the engine's default pipeline and is rejected
 at export rather than 500ing at deploy (Postgres `22021`); BMP defaults (accents, `€`, most

package/llms/filters.md

@@ -38,14 +38,10 @@ statement, and one CANNOT be synthesized in the SDK (it would compile to this sa
 database with a single `s.db.direct_query` UPDATE (`SET clicks = clicks + 1 WHERE …`),
 which the DB applies atomically. Reserve the pipeline form for low-contention counters
 where a rare lost update is acceptable.
-⚠ `direct_query` needs the table's PHYSICAL Postgres name, which the typed surface
-does NOT expose: the engine derives it from ids assigned at import — not knowable from a
-`table()` def (identity is a name + guid, not the numeric id) — and `sql_name` persists
-empty. The derived name is also NOT STABLE: a deploy is a full replace, so every table is
-created afresh and the id in its name moves each time, on the same unchanged project. So
-the safe counter drops out of the typed surface: resolve the physical name from
-`information_schema` inside the request that uses it, and never store, cache or hardcode
-one. A typed atomic path needs an engine change.
+⚠ `direct_query` needs the table's PHYSICAL Postgres name, which the typed surface does NOT
+expose and which is NOT STABLE across deploys — resolve it from `information_schema` inside
+the request that uses it, never store or hardcode one (rules under `s.db.direct_query` in
+`llms/statements-data.md`). A typed atomic path needs an engine change.
 
 - `fl.add(value: decimal): decimal`
 - `fl.append(value: <T>, path: text): <T>[]`

package/llms/kinds-agent-mcp.md

@@ -10,3 +10,4 @@
   - `output?`: `{ schema: Record<string, input.*>, enabled? }` — structured-output schema. `schema` is a named-field record authored with the `input.*` catalog, exactly like a `defineFunction`/`query` `input:` map (the stored `structuredOutputsSchema` is the same wire shape as function inputs). e.g. `output: { schema: { priority: input.enum(["low","high"]), summary: input.text() } }`. When you pass the agent *handle* to `s.ai.agent.run({ agent })`, `.result` is typed straight from this schema — no `resultShape` witness needed (the shape is declared once). `resultShape` remains only to override that, or to type an agent referenced by bare name.
   - **Run + read recipe (`s.ai.agent.run`):** bind the run to a var (`s.ai.agent.run({ agent, args, as: "run" })`) — it produces a rich envelope, and the completion is at **`.result`**. Read one structured field with a dotted ref (`response: ref("run.result.priority")`) or the whole completion (`ref("run.result")`, typed from `output.schema`); persist it in a later step the same way (`s.set_var({ name, value: ref("run.result.summary") })`). `args` is a plain object of run inputs (`{ topic: inp("topic") }` — raw literals are fine, e.g. `{ max_steps: 3 }`) surfaced to the agent as `{{ $args.topic }}`. Tool-call / per-step data (when tools ran) rides `.toolCalls` / `.steps` on the same envelope — both optional, absent or empty when no tools executed.
   - **Marketplace:** for chat history, use `@xanots/chatbot`; for vector RAG, use `@xanots/vector` (`tools: [vector.searchTool]`). Find add-ons with `xanots marketplace search <q>`.
+- Both kinds persist under the `toolset` payload key, so a same-name `agent` + `mcpServer` pair derives ONE guid and `export()` throws — give them distinct names.