@xano/sdk 1.0.0

package/dist/chunk-CTMO46PK.js

@@ -0,0 +1,1897 @@
+import {
+  resolveAuthRef
+} from "./chunk-ZDPP6RKB.js";
+import {
+  obj
+} from "./chunk-K5BBGTYZ.js";
+import {
+  buildBundle
+} from "./chunk-LQCMKAJ7.js";
+import {
+  checkAddonAttachments,
+  checkAddonOutput,
+  checkAgentApiKeys,
+  checkAgentArgPlaceholders,
+  checkApiGroupDocsExposure,
+  checkAssertionsOutsideTests,
+  checkAuthNoCaller,
+  checkCacheTtl,
+  checkDecodeOnlyStatements,
+  checkDocumentationTokens,
+  checkExpressionOperands,
+  checkGuardRoleColumns,
+  checkIntRange,
+  checkInterpolatedValues,
+  checkKnowledge,
+  checkLiveDatasourceTests,
+  checkLoopControl,
+  checkMcpResourceUris,
+  checkMcpStackHazards,
+  checkMicroserviceBlocks,
+  checkMicroserviceReferences,
+  checkMicroserviceSecrets,
+  checkNonJsonValues,
+  checkNonNullVectorColumns,
+  checkNullMatchArgs,
+  checkOmittedCallInputs,
+  checkPasswordInputHashing,
+  checkPathSegmentCandidates,
+  checkPrimitiveAuthIdentity,
+  checkRatelimitWithoutError,
+  checkRealtimeDeliver,
+  checkRealtimeGates,
+  checkRealtimeJoinDeliver,
+  checkRealtimePublish,
+  checkRealtimeSilentShapes,
+  checkReferences,
+  checkRegexOperandOrder,
+  checkReservedColumnNames,
+  checkReservedInputNames,
+  checkRouteShadowing,
+  checkRunFamilyHosts,
+  checkSafeRefMatchArgs,
+  checkSameNameSiblings,
+  checkSearchOperandFilters,
+  checkSeed,
+  checkStackAuthRatelimit,
+  checkStacks,
+  checkSwitchFallthrough,
+  checkTimezoneArgs,
+  checkToThrowScope,
+  checkToolAuthIdentity,
+  checkToolOutputSchema,
+  checkTriggerBindings,
+  checkUnboundVarRefs,
+  checkUnitTests,
+  checkUnknownCallInputs,
+  checkUnusableColumnNames,
+  checkWriteBeforeElicit,
+  checkZeroBasedObjects,
+  checkZipPasswordKeys,
+  postEnvelopeMisreads,
+  unnestedEnvelopeReads,
+  walkNodes
+} from "./chunk-YGZHHAAB.js";
+import {
+  WORKSPACE_HISTORY_TYPES,
+  assertNameAsStored,
+  middlewareEntryGuid,
+  stackReferencesAuth
+} from "./chunk-5V5XU32D.js";
+import {
+  defKindOf
+} from "./chunk-ERVIASGL.js";
+import {
+  AUTHOR_KIND_NAME,
+  assertDefShape,
+  assertMockKeysResolved,
+  assertNoProtoKeys,
+  assertTestIds,
+  encodeObject,
+  getKind
+} from "./chunk-4POWHT2K.js";
+import {
+  documentationTokenDeclarations,
+  resolveDocumentationTokens
+} from "./chunk-3JDU4VRL.js";
+import {
+  nearestKey
+} from "./chunk-WTPZRR4I.js";
+import {
+  DiagnosticBag,
+  allowableWarnings,
+  setDiagnosticSink
+} from "./chunk-2EZ3ZJZZ.js";
+import {
+  CANONICAL_PAYLOAD_KEYS,
+  LOCK_PAYLOAD_KEYS,
+  WORKSPACE_KEY,
+  identityNamesByGuid,
+  lockKey,
+  lockNameForObject,
+  mintCanonical,
+  recordObserved,
+  sdkKindName
+} from "./chunk-6MR5TI5V.js";
+import {
+  HOSTED_ICON_KINDS,
+  pendingHostedFile
+} from "./chunk-XNCP4KYO.js";
+import {
+  isTaggedValue
+} from "./chunk-OXA6PSZT.js";
+import {
+  REFERENCEABLE_KINDS,
+  deriveGuid,
+  refSpelling,
+  resolveRef
+} from "./chunk-NZOWWHU5.js";
+import {
+  getLockedCanonical
+} from "./chunk-4BW2SG2N.js";
+import {
+  describeEntry
+} from "./chunk-CIMQZRRE.js";
+import {
+  withArticle
+} from "./chunk-36JUQZVQ.js";
+
+// src/kinds/def-keys.ts
+var keys = (roster, ...extra) => [...Object.keys(roster), ...extra];
+var COMMON = { __kind: 1, name: 1, guid: 1, description: 1, tags: 1 };
+var STACK = { input: 1, stack: 1, response: 1, responseShape: 1, history: 1, middleware: 1 };
+var TOOLSET = { ...COMMON, docs: 1, history: 1, output: 1, enabled: 1, canonical: 1, tools: 1, llm: 1, diagnostics: 1 };
+var DEF_KEYS = {
+  query: keys(
+    {
+      ...COMMON,
+      ...STACK,
+      verb: 1,
+      apiGroup: 1,
+      apiGroupId: 1,
+      diagnostics: 1,
+      auth: 1,
+      docs: 1,
+      responseType: 1,
+      apiEnabled: 1,
+      disabled: 1,
+      cache: 1,
+      tests: 1,
+      example: 1
+    },
+    "getPath",
+    "toSearchParams"
+  ),
+  function: keys(
+    { ...COMMON, ...STACK, docs: 1, cache: 1, tests: 1, workspace: 1, diagnostics: 1 }
+  ),
+  task: keys(
+    { ...COMMON, docs: 1, middleware: 1, history: 1, stack: 1, datasource: 1, active: 1, schedule: 1, diagnostics: 1 }
+  ),
+  table: keys(
+    {
+      ...COMMON,
+      auth: 1,
+      docs: 1,
+      __cols: 1,
+      __row: 1,
+      __internal: 1,
+      install: 1,
+      schema: 1,
+      system: 1,
+      idType: 1,
+      useXdo: 1,
+      index: 1,
+      autocomplete: 1,
+      external: 1,
+      views: 1,
+      seed: 1,
+      publicSeed: 1,
+      diagnostics: 1
+    }
+  ),
+  middleware: keys(
+    { ...COMMON, ...STACK, docs: 1, tests: 1, resultStrategy: 1, exceptionPolicy: 1, diagnostics: 1 }
+  ),
+  addon: keys(
+    {
+      ...COMMON,
+      input: 1,
+      table: 1,
+      tableAlias: 1,
+      where: 1,
+      sort: 1,
+      context: 1,
+      output: 1,
+      cardinality: 1,
+      group: 1,
+      eval: 1,
+      __graft: 1,
+      diagnostics: 1
+    }
+  ),
+  agent: keys(TOOLSET, "getCanonical"),
+  mcp_server: keys(
+    { ...TOOLSET, instructions: 1, spec: 1, prompts: 1, resources: 1, oauth: 1 },
+    "getCanonical",
+    "getPath",
+    "getUrl"
+  ),
+  tool: keys(
+    {
+      ...COMMON,
+      ...STACK,
+      docs: 1,
+      enabled: 1,
+      instructions: 1,
+      toolsetId: 1,
+      diagnostics: 1,
+      title: 1,
+      annotations: 1,
+      icons: 1,
+      output: 1
+    }
+  ),
+  prompt: keys(
+    { ...COMMON, ...STACK, docs: 1, title: 1, icons: 1, diagnostics: 1 }
+  ),
+  resource: keys(
+    { ...COMMON, ...STACK, docs: 1, uri: 1, mimeType: 1, title: 1, icons: 1, annotations: 1, diagnostics: 1 }
+  ),
+  realtime_server: keys(
+    { ...COMMON, diagnostics: 1, middleware: 1, history: 1, enabled: 1, canonical: 1 },
+    "getCanonical",
+    "getPath",
+    "getUrl"
+  ),
+  channel: keys(
+    {
+      ...COMMON,
+      middleware: 1,
+      history: 1,
+      input: 1,
+      active: 1,
+      server: 1,
+      anonymousClients: 1,
+      presence: 1,
+      publish: 1,
+      conversation: 1,
+      delivery: 1,
+      rateLimit: 1,
+      diagnostics: 1
+    },
+    "getChannel"
+  ),
+  message: keys(
+    { ...COMMON, ...STACK, auth: 1, disabled: 1, active: 1, server: 1, channel: 1, deliverTo: 1, diagnostics: 1 }
+  ),
+  knowledge: keys({ ...COMMON, enabled: 1, type: 1, mode: 1, body: 1, refs: 1, diagnostics: 1 }),
+  workflow_test: keys(
+    { ...COMMON, docs: 1, stack: 1, datasource: 1, active: 1, diagnostics: 1 }
+  ),
+  api_group: keys(
+    {
+      ...COMMON,
+      docs: 1,
+      middleware: 1,
+      history: 1,
+      canonical: 1,
+      documentation: 1,
+      swagger: 1,
+      apiGroupEnabled: 1,
+      cors: 1,
+      diagnostics: 1
+    }
+  ),
+  microservice: keys(
+    {
+      ...COMMON,
+      kind: 1,
+      tenantDeploy: 1,
+      deployment: 1,
+      ingresses: 1,
+      configs: 1,
+      volumes: 1,
+      chart: 1,
+      registryAuth: 1,
+      diagnostics: 1
+    }
+  ),
+  trigger: keys(
+    {
+      ...COMMON,
+      history: 1,
+      stack: 1,
+      response: 1,
+      responseShape: 1,
+      active: 1,
+      objType: 1,
+      toolsetType: 1,
+      objId: 1,
+      hasResult: 1,
+      meta: 1,
+      diagnostics: 1
+    }
+  ),
+  workspace: keys(
+    {
+      __kind: 1,
+      name: 1,
+      diagnostics: 1,
+      description: 1,
+      middleware: 1,
+      history: 1,
+      canonical: 1,
+      use_xdo: 1,
+      preferences: 1,
+      realtime: 1,
+      documentation: 1,
+      swagger: 1,
+      env: 1,
+      settings: 1,
+      use_custom_names: 1,
+      defaults: 1,
+      datasources: 1,
+      datasource_live: 1
+    }
+  )
+};
+var MIDDLEWARE = keys({ pre: 1, post: 1 });
+var CACHE = keys({ active: 1, ttl: 1, input: 1, auth: 1, datasource: 1, ip: 1, headers: 1, env: 1 });
+var NESTED_DEF_KEYS = {
+  query: { cache: CACHE },
+  function: { cache: CACHE },
+  table: {
+    "views[]": keys({ name: 1, id: 1, alias: 1, hide: 1, q: 1, where: 1, sort: 1 })
+  },
+  task: {
+    "schedule[]": keys(
+      { startsOn: 1, freq: 1, repeatEnabled: 1, endsOn: 1, endsEnabled: 1 }
+    )
+  },
+  microservice: {
+    deployment: keys({ replicas: 1, strategy: 1, docker: 1, containers: 1 }),
+    "deployment.containers[]": keys(
+      { name: 1, image: 1, pullSecret: 1, type: 1, command: 1, args: 1, env: 1, ports: 1, resources: 1, volumes: 1 }
+    ),
+    "deployment.containers[].env[]": keys({ name: 1, value: 1, fromEnv: 1 }),
+    "deployment.containers[].ports[]": keys({ servicePort: 1, containerPort: 1 }),
+    "deployment.containers[].resources": keys({ cpu: 1, ram: 1 }),
+    "deployment.containers[].volumes[]": keys(
+      { name: 1, type: 1, persistent: 1, emptyDir: 1, config: 1 }
+    ),
+    "ingresses[]": keys({ name: 1, domain: 1, paths: 1 }),
+    "ingresses[].paths[]": keys({ service: 1, path: 1 }),
+    "configs[]": keys({ name: 1, type: 1, value: 1 }),
+    "volumes[]": keys({ name: 1, size: 1, class: 1 }),
+    chart: keys({ ref: 1, values: 1, version: 1 }),
+    registryAuth: keys({ type: 1, server: 1, dockerconfigjson: 1 })
+  },
+  api_group: {
+    cors: keys(
+      { mode: 1, allowOrigins: 1, allowHeaders: 1, allowCredentials: 1, maxAge: 1, allowMethods: 1 }
+    ),
+    "cors.allowMethods": keys(
+      { delete: 1, get: 1, head: 1, patch: 1, post: 1, put: 1 }
+    ),
+    documentation: keys({ require_token: 1, token: 1 })
+  },
+  channel: {
+    publish: keys({ who: 1, direct: 1 }),
+    conversation: keys({ enabled: 1, limit: 1, ttl: 1 }),
+    delivery: keys({ guarantee: 1, perRecipient: 1 }),
+    rateLimit: keys({ messagesPerMinute: 1 })
+  },
+  workspace: {
+    preferences: keys({ allow_push: 1, track_performance: 1, use_internal_docs: 1 }),
+    // The workspace's own middleware is per host tier, each a `{ pre, post }`.
+    middleware: keys({ query: 1, function: 1, task: 1, tool: 1 }),
+    "middleware.query": MIDDLEWARE,
+    "middleware.function": MIDDLEWARE,
+    "middleware.task": MIDDLEWARE,
+    "middleware.tool": MIDDLEWARE,
+    // WHOLESALE maps: a key nothing reads falls back to its default silently.
+    history: WORKSPACE_HISTORY_TYPES,
+    defaults: keys({ db_primary_key: 1 })
+  }
+};
+var NEAR_MISS_DEF_KEYS = {
+  workspace: {
+    realtime: ["hash", "mode", "enabled", "channels"],
+    documentation: ["require_token", "token", "whitelist"]
+  }
+};
+function recordsAt(def, path) {
+  let at = [["", def]];
+  for (const part of path.split(".")) {
+    const list = part.endsWith("[]");
+    const field = list ? part.slice(0, -2) : part;
+    at = at.flatMap(([where, v]) => {
+      if (typeof v !== "object" || v === null) return [];
+      const next = v[field];
+      const label = where ? `${where}.${field}` : field;
+      if (!list) return [[label, next]];
+      return Array.isArray(next) ? next.map((e, i) => [`${label}[${i}]`, e]) : [];
+    });
+  }
+  return at.filter(([, v]) => typeof v === "object" && v !== null && !Array.isArray(v));
+}
+function assertDefKeys(owner, def, known, kind) {
+  if (known === void 0 || typeof def !== "object" || def === null) return;
+  refuseUnknown(owner, def, known);
+  const nested = { middleware: MIDDLEWARE, ...kind ? NESTED_DEF_KEYS[kind] : {} };
+  for (const [path, roster] of Object.entries(nested)) {
+    for (const [where, record] of recordsAt(def, path)) refuseUnknown(`${owner} \`${where}\``, record, roster);
+  }
+  for (const [path, roster] of Object.entries(kind && NEAR_MISS_DEF_KEYS[kind] || {})) {
+    for (const [where, record] of recordsAt(def, path)) {
+      const typos = Object.keys(record).filter((k) => !roster.includes(k) && nearestKey(k, roster) !== void 0);
+      if (typos.length > 0) refuseUnknown(`${owner} \`${where}\``, Object.fromEntries(typos.map((k) => [k, 1])), roster);
+    }
+  }
+}
+function refuseUnknown(owner, def, known) {
+  for (const key of Object.keys(def)) {
+    if (known.includes(key)) continue;
+    const near = nearestKey(key, known) ?? known.find((k) => k.length > 3 && (key.startsWith(k) || k.startsWith(key)));
+    throw new Error(
+      `${owner}: unknown key "${key}"${near ? ` \u2014 did you mean "${near}"?` : "."} Nothing reads it, so it would not do what it says. Keys this def takes: ${known.filter((k) => !k.startsWith("__") && !/^get[A-Z]/.test(k) && k !== "token").join(", ")}.` + // A literal token is refused at export: it is a secret, never source.
+      (known.includes("token") ? " A token is not written here \u2014 it comes from `xano/.secrets.json`." : "")
+    );
+  }
+}
+
+// src/kinds/mcp-oauth.ts
+var MCP_OAUTH_PRESETS = ["auth0", "clerk", "workos", "entra", "okta", "cognito", "generic"];
+var MCP_OAUTH_PRESETS_WITHOUT_AUD = ["clerk"];
+var MCP_OAUTH_STABLE_CLAIMS = ["sub", "oid", "email"];
+var HOSTED_KEYS = ["mode", "authTable", "loginUrl"];
+var EXTERNAL_KEYS = [
+  "mode",
+  "authTable",
+  "issuer",
+  "column",
+  "audience",
+  "audienceAck",
+  "claim",
+  "claimAck",
+  "preset",
+  "allowedClientIds"
+];
+var REMOVED_KEYS = ["consent", "branding", "trustedClients"];
+var ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var MCP_OAUTH_ENV_REF = /^\$\{env\.([A-Za-z_][A-Za-z0-9_]*)\}$/;
+function envString(owner, field, v) {
+  if (typeof v === "string") return v;
+  if (isTaggedValue(v)) {
+    const name = v.value;
+    if (v.tag === "setting" && v.filters.length === 0 && ENV_NAME.test(name)) return `\${env.${name}}`;
+    throw new Error(
+      `${owner} \`oauth.${field}\`: only \`env("NAME")\` (a workspace environment variable) is accepted here, not ${JSON.stringify({ tag: v.tag, value: name })}. Built-in settings (\`$remote_ip\` and the like) and filtered values are not resolved in this setting \u2014 pass a string or \`env("NAME")\`.`
+    );
+  }
+  throw new Error(`${owner} \`oauth.${field}\`: expected a string or \`env("NAME")\` (got ${v === null ? "null" : typeof v}).`);
+}
+function strings(owner, field, v, envAllowed) {
+  if (v === void 0) return [];
+  if (!Array.isArray(v)) throw new Error(`${owner} \`oauth.${field}\`: expected a list of strings.`);
+  return v.map((item, i) => {
+    if (envAllowed) return envString(owner, `${field}[${i}]`, item);
+    if (typeof item !== "string") throw new Error(`${owner} \`oauth.${field}[${i}]\`: expected a string.`);
+    return item;
+  });
+}
+function oneOf(owner, field, v, allowed) {
+  if (v === void 0) return;
+  if (typeof v !== "string" || !allowed.includes(v)) {
+    throw new Error(
+      `${owner} \`oauth.${field}\` must be ${allowed.map((a) => JSON.stringify(a)).join(", ")} \u2014 got ${JSON.stringify(v)}. The platform refuses any other spelling rather than reading it as a different sign-in flow.`
+    );
+  }
+}
+function encodeMcpOauth(owner, oauth) {
+  if (oauth === null || typeof oauth !== "object" || Array.isArray(oauth)) {
+    throw new Error(`${owner} \`oauth\`: expected { mode: "hosted" | "external", authTable, \u2026 }.`);
+  }
+  const raw = oauth;
+  oneOf(owner, "mode", raw.mode, ["hosted", "external"]);
+  if (raw.mode === void 0) throw new Error(`${owner} \`oauth.mode\` is required: "hosted" or "external".`);
+  for (const key of REMOVED_KEYS) {
+    if (key in raw) {
+      throw new Error(
+        `${owner} \`oauth.${key}\` no longer exists: the platform dropped \`consent\`, \`branding\` and \`trustedClients\`. Your \`loginUrl\` page is the consent screen \u2014 show what \`s.mcp.oauth.request\` returns (client name, logo, callback host, whether the client is verified) and pass the user's choice to \`s.mcp.oauth.complete\` as \`decision\`. Remove the key.`
+      );
+    }
+  }
+  refuseUnknown(`${owner} \`oauth\` (mode "${String(raw.mode)}")`, raw, raw.mode === "hosted" ? HOSTED_KEYS : EXTERNAL_KEYS);
+  const table = raw.authTable;
+  if (table === void 0 || table === null || table === false || table === "") {
+    throw new Error(
+      `${owner} \`oauth.authTable\` is required: the auth table (a \`table({ auth: true })\` handle or its name) whose row a sign-in resolves to.`
+    );
+  }
+  const authTable = resolveAuthRef("mcpServer oauth", owner, table);
+  const out = {
+    mode: raw.mode,
+    auth_table: authTable,
+    login_url: "",
+    issuer: "",
+    audience: [],
+    audience_ack: false,
+    claim: "sub",
+    claim_ack: false,
+    column: "",
+    preset: "",
+    allowed_client_ids: []
+  };
+  if (oauth.mode === "hosted") {
+    out.login_url = envString(owner, "loginUrl", oauth.loginUrl ?? "");
+    return out;
+  }
+  oneOf(owner, "preset", oauth.preset, MCP_OAUTH_PRESETS);
+  out.issuer = envString(owner, "issuer", oauth.issuer ?? "");
+  out.audience = strings(owner, "audience", oauth.audience, true);
+  out.audience_ack = oauth.audienceAck === true;
+  if (oauth.claim !== void 0 && typeof oauth.claim !== "string") throw new Error(`${owner} \`oauth.claim\`: expected a string.`);
+  out.claim = oauth.claim || "sub";
+  out.claim_ack = oauth.claimAck === true;
+  if (oauth.column !== void 0 && typeof oauth.column !== "string") throw new Error(`${owner} \`oauth.column\`: expected a string.`);
+  out.column = oauth.column ?? "";
+  out.preset = oauth.preset ?? "";
+  out.allowed_client_ids = strings(owner, "allowedClientIds", oauth.allowedClientIds, false);
+  return out;
+}
+
+// src/workspace/guards-mcp-oauth.ts
+function checkMcpOauth(sections, bag) {
+  for (const set of sections.toolset ?? []) {
+    if (!set || typeof set !== "object") continue;
+    const { name, oauth } = set;
+    if (!oauth || typeof oauth !== "object" || Array.isArray(oauth)) continue;
+    const o = oauth;
+    const server = `mcpServer "${String(name ?? "?")}"`;
+    const text = (k) => typeof o[k] === "string" ? o[k].trim() : "";
+    if (o.mode === "hosted" && text("login_url") === "") {
+      bag.error(
+        "mcp.oauth-hosted-incomplete",
+        `${server}: \`oauth\` is hosted mode with no \`loginUrl\`. A client signing in is sent to that page, so the platform refuses the push without one. Set \`loginUrl\` to your login page (https), or \`env("NAME")\`.`,
+        set
+      );
+    }
+    if (o.mode !== "external") continue;
+    const missing = ["issuer", "column"].filter((k) => text(k) === "");
+    if (missing.length > 0) {
+      bag.error(
+        "mcp.oauth-external-incomplete",
+        `${server}: \`oauth\` is external mode with no ${missing.map((k) => `\`${k}\``).join(" or ")}. The \`issuer\` is what a token is verified against and the \`column\` is the auth-table column its claim names a row by; the platform refuses the push without both.`,
+        set
+      );
+    }
+    const preset = text("preset");
+    const clientIds = Array.isArray(o.allowed_client_ids) ? o.allowed_client_ids : [];
+    if (MCP_OAUTH_PRESETS_WITHOUT_AUD.includes(preset) && clientIds.length === 0) {
+      bag.error(
+        "mcp.oauth-preset-client-ids",
+        `${server}: \`oauth.preset\` "${preset}" issues access tokens without an audience, so nothing ties a token to this server. Set \`allowedClientIds\` to the client ids allowed to call it; the platform refuses the push without them.`,
+        set
+      );
+    }
+    const claim = typeof o.claim === "string" && o.claim !== "" ? o.claim : "sub";
+    if (!MCP_OAUTH_STABLE_CLAIMS.includes(claim) && o.claim_ack !== true) {
+      bag.error(
+        "mcp.oauth-claim-unacked",
+        `${server}: \`oauth.claim\` "${claim}" can be edited by users at many identity providers, which would let a user choose the row they sign in as. Use "sub", "oid" or "email", or set \`claimAck: true\` to accept it; the platform refuses the push otherwise.`,
+        set
+      );
+    }
+  }
+}
+function isEmptyRevokeTarget(input) {
+  if (typeof input?.tag !== "string" || !input.tag.startsWith("const")) return false;
+  const value = String(input.value ?? "");
+  if (input.name === "user_id") return value === "";
+  if (input.name === "grant_id") return value === "" || Number(value) <= 0;
+  if (input.name === "all") return value === "" || value === "false" || value === "0";
+  return false;
+}
+function checkMcpOauthRevoke(sections, bag) {
+  for (const [payloadKey, arr] of Object.entries(sections)) {
+    for (const obj2 of arr ?? []) {
+      if (!obj2 || typeof obj2 !== "object") continue;
+      walkNodes(obj2, (node) => {
+        if (node.name !== "mvp:mcp_oauth_revoke" || !Array.isArray(node.input)) return;
+        const targets = node.input.filter((i) => !isEmptyRevokeTarget(i)).map((i) => i?.name).filter((n) => n === "user_id" || n === "grant_id" || n === "all");
+        if (targets.length === 1) return;
+        const name = obj2.name;
+        const owner = `${sdkKindName(payloadKey, obj2)} "${typeof name === "string" ? name : "?"}"`;
+        bag.error(
+          "mcp.oauth-revoke-target",
+          `${owner}: \`s.mcp.oauth.revoke\` needs exactly one of \`user_id\`, \`grant_id\` or \`all\`, but it names ${targets.length === 0 ? "no target" : targets.map((t) => `\`${t}\``).join(" and ")} \u2014 the platform refuses any other combination every time the statement runs.`,
+          obj2
+        );
+      });
+    }
+  }
+}
+
+// src/workspace/filter-operands.ts
+var SCALAR_COLUMN_TYPES = /* @__PURE__ */ new Set([
+  "int",
+  "decimal",
+  "text",
+  "bool",
+  "epochms",
+  "timestamp",
+  "date",
+  "email",
+  "password",
+  "enum",
+  "uuid"
+]);
+var SCALAR_TAGS = /* @__PURE__ */ new Set(["const", "const:encoded", "const:int", "const:decimal", "const:bool", "const:null"]);
+var NUMERIC_TEXT = {
+  int: /^\s*[+-]?\d+\s*$/,
+  decimal: /^\s*(?:[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?|nan|[+-]?inf(?:inity)?)\s*$/i
+};
+function outsideInt64(v) {
+  const text = typeof v === "number" && Number.isInteger(v) ? BigInt(v).toString() : typeof v === "string" ? v.trim() : void 0;
+  if (text === void 0 || !/^[+-]?\d+$/.test(text)) return false;
+  const n = BigInt(text);
+  return n > 2n ** 63n - 1n || n < -(2n ** 63n);
+}
+function isScalar(v) {
+  return typeof v === "string" || typeof v === "number" || typeof v === "boolean";
+}
+var COMPARISON_OPS = /* @__PURE__ */ new Set(["=", "==", "!=", "===", "!==", "<", "<=", ">", ">="]);
+var PATTERN_OPS = /* @__PURE__ */ new Set(["like", "not like", "ilike", "not ilike", "~", "!~", "includes", "not includes", "search"]);
+var CONTAINMENT_OPS = /* @__PURE__ */ new Set(["contains", "not contains", "overlaps", "not overlaps"]);
+function unfiltered(o) {
+  return !Array.isArray(o.filters) || o.filters.length === 0;
+}
+function literalShape(o) {
+  if (typeof o.tag !== "string" || !unfiltered(o)) return void 0;
+  const text = typeof o.operand === "string" ? o.operand : void 0;
+  if (text?.startsWith("(")) return void 0;
+  if (SCALAR_TAGS.has(o.tag)) return { kind: "scalar" };
+  if (o.tag !== "const:array" && o.tag !== "const:obj") return void 0;
+  let value;
+  try {
+    value = JSON.parse(text ?? "");
+  } catch {
+    return void 0;
+  }
+  if (Array.isArray(value)) return { kind: "list", length: value.length, items: value };
+  if (!value || typeof value !== "object") return void 0;
+  const keys2 = Object.keys(value);
+  if (keys2.every((k, i) => k === String(i))) return void 0;
+  return { kind: "object" };
+}
+function objectLiteral(o) {
+  return o.tag === "const:obj" && o.operand === "{}" && Array.isArray(o.filters) && o.filters.length > 0 && o.filters.every((x) => x?.name === "set");
+}
+function emptyLiteral(o) {
+  if (o.tag === "const:null") return true;
+  return typeof o.operand !== "string" || ["", "0", "[]", "{}", "false", "null"].includes(o.operand);
+}
+function tableShapes(sections) {
+  const out = /* @__PURE__ */ new Map();
+  for (const raw of sections.dbo ?? []) {
+    const t = raw;
+    if (typeof t?.guid !== "string" || !Array.isArray(t.schema)) continue;
+    const cols = /* @__PURE__ */ new Map();
+    for (const c of t.schema) {
+      if (typeof c?.name !== "string" || typeof c.type !== "string") continue;
+      cols.set(c.name, { type: c.type, list: c.style?.type === "list" });
+    }
+    out.set(t.guid, cols);
+  }
+  return out;
+}
+function describeColumn(name, c) {
+  return `\`${name}\` (${c.type}${c.list ? " list" : ""})`;
+}
+function describeLiteral(s) {
+  if (s.kind === "list") return `a ${s.length}-element list`;
+  return s.kind === "object" ? "an object" : "a scalar";
+}
+function problem(op, left, right, columns) {
+  if (right.ignore_empty === true && emptyLiteral(right)) return void 0;
+  const lit = literalShape(right);
+  const leftName = left.tag === "col" && typeof left.operand === "string" && unfiltered(left) ? left.operand : void 0;
+  const column = leftName !== void 0 && !leftName.includes(".") ? columns?.get(leftName) : void 0;
+  if (op === "between" || op === "not between") {
+    if (left.tag !== "col") return void 0;
+    if (right.tag === "col") return `\`${op}\` takes a literal two-value list on the right, not a column`;
+    if (lit && !(lit.kind === "list" && lit.length === 2)) {
+      return `\`${op}\` needs exactly a two-value list (\`c.array([low, high])\`) on the right; it has ${describeLiteral(lit)}`;
+    }
+    return void 0;
+  }
+  if (!column) return void 0;
+  const col = describeColumn(leftName, column);
+  if (CONTAINMENT_OPS.has(op) && !column.list && SCALAR_COLUMN_TYPES.has(column.type)) {
+    return `\`${op}\` is json/list containment and ${col} is neither \u2014 for a substring match use \`includes\``;
+  }
+  if (CONTAINMENT_OPS.has(op) && column.type === "json" && !column.list && right.tag !== "col") {
+    return `\`${op}\` on a json column has no working operand: the database cannot compare ${col} with the list it builds, whatever the value. Store the values in a list column (\`f.text({ array: true })\`), where \`${op}\` works, or match a json array of objects with \`@>\` (\`c.array([{ \u2026 }])\`)`;
+  }
+  if (op === "@>" && SCALAR_COLUMN_TYPES.has(column.type)) {
+    return `\`@>\` needs a json column on the left, and ${col} is not one`;
+  }
+  if (op === "@>" && !column.list && objectLiteral(right)) {
+    return `\`@>\` with an object literal on the right fails with "Invalid expression" \u2014 bind the object first (\`s.set_var("match", c.obj({ \u2026 }))\`, then \`ref("match")\`) or take it as a json input; a json array of objects matches with \`c.array([{ \u2026 }])\``;
+  }
+  if ((op === "includes" || op === "not includes") && column.type === "bool") {
+    return `\`${op}\` does not take a bool column (${col})`;
+  }
+  if (!lit) return void 0;
+  if (op === "in" || op === "not in") {
+    if (!column.list && lit.kind !== "list") return `\`${op}\` on ${col} needs a list on the right; it has ${describeLiteral(lit)}`;
+    if (column.list && lit.kind === "list") return `\`${op}\` needs a scalar on one side, and ${col} and the right side are both lists`;
+    return void 0;
+  }
+  if (op === "@>" && column.type === "json") {
+    if (lit.kind === "scalar" || lit.kind === "list" && isScalar(lit.items[0])) {
+      return `\`@>\` needs a json value on the right, and a ${lit.kind === "scalar" ? "scalar" : "list of scalars"} is not one \u2014 the engine reads a list by its first element. A list of objects works (\`c.array([{ \u2026 }])\`); matching scalar elements needs a list column (\`f.text({ array: true })\`) with \`contains\``;
+    }
+    return void 0;
+  }
+  const numeric = NUMERIC_TEXT[column.type];
+  if (CONTAINMENT_OPS.has(op) && column.list && numeric !== void 0 && lit.kind === "list") {
+    const bad = lit.items.find((v) => typeof v === "string" && !numeric.test(v));
+    if (bad !== void 0) {
+      return `\`${op}\` on ${col} casts every element to ${column.type === "int" ? "a whole number" : "a number"}, and ${JSON.stringify(bad)} is not one`;
+    }
+    const big = column.type === "int" ? lit.items.find(outsideInt64) : void 0;
+    if (big !== void 0) {
+      return `\`${op}\` on ${col} casts every element to a 64-bit whole number, and ${JSON.stringify(big)} is out of its range`;
+    }
+  }
+  if (CONTAINMENT_OPS.has(op)) {
+    if (lit.kind === "scalar") return `\`${op}\` needs json or a list on the right; it has a scalar \u2014 wrap it: \`c.array([value])\``;
+    return void 0;
+  }
+  if (COMPARISON_OPS.has(op)) {
+    if (lit.kind === "list") return `\`${op}\` does not compare lists; the right side is ${describeLiteral(lit)} \u2014 use \`in\``;
+    if (column.list && right.tag !== "const:null") return `\`${op}\` does not compare lists, and ${col} is one`;
+    return void 0;
+  }
+  if (PATTERN_OPS.has(op)) {
+    if (lit.kind === "list") return `\`${op}\` does not take a list on the right; it has ${describeLiteral(lit)}`;
+  }
+  return void 0;
+}
+function walk(node, visit) {
+  const stack = [node];
+  while (stack.length > 0) {
+    const n = stack.pop();
+    if (Array.isArray(n)) {
+      for (let i = n.length - 1; i >= 0; i--) stack.push(n[i]);
+    } else if (n && typeof n === "object") {
+      const record = n;
+      visit(record);
+      const values = Object.values(record);
+      for (let i = values.length - 1; i >= 0; i--) stack.push(values[i]);
+    }
+  }
+}
+function checkFilterOperands(sections, bag) {
+  const tables = tableShapes(sections);
+  for (const [payloadKey, arr] of Object.entries(sections)) {
+    for (const obj2 of arr ?? []) {
+      if (!obj2 || typeof obj2 !== "object") continue;
+      const found = [];
+      walk(obj2, (record) => {
+        const context = record.context;
+        if (!context || typeof context.search !== "object" || context.search === null) return;
+        const id = context.dbo?.id;
+        const columns = typeof id === "string" ? tables.get(id) : void 0;
+        walk(context.search, (node) => {
+          const s = node.statement;
+          if (!s || typeof s !== "object" || typeof s.op !== "string") return;
+          const why = problem(s.op, s.left ?? {}, s.right ?? {}, columns);
+          if (why !== void 0) found.push(why);
+        });
+      });
+      if (found.length === 0) continue;
+      const name = obj2.name;
+      const owner = `${sdkKindName(payloadKey, obj2)} "${typeof name === "string" ? name : "?"}"`;
+      for (const why of [...new Set(found)]) {
+        bag.warn(
+          "db.filter-operand-invalid",
+          `${owner}: a \`where\` clause fails every request that reaches it, whatever the data \u2014 ${why}.`,
+          obj2
+        );
+      }
+    }
+  }
+}
+
+// src/workspace/xano.ts
+var MIDDLEWARE_HOST_KINDS = ["query", "task", "function", "tool", "prompt", "resource"];
+var XANO_BRAND = /* @__PURE__ */ Symbol.for("xanosdk.Xano");
+var XANO_ORIGIN = /* @__PURE__ */ Symbol.for("xanosdk.Xano.origin");
+function nameResponseRecordError(err, kindName, def) {
+  if (!(err instanceof Error)) return err;
+  const response = def?.response;
+  if (response === null || typeof response !== "object" || isTaggedValue(response)) return err;
+  if (err.message.startsWith("`response.")) {
+    err.message = `${authorKindName(kindName)} "${String(def.name)}": ${err.message}`;
+    return err;
+  }
+  if (err.message.startsWith("obj() takes a { key: value } record")) {
+    const bad = Object.entries(response).find(([, m]) => typeof m !== "object" || m === null || Array.isArray(m));
+    if (bad !== void 0) {
+      const [key, member] = bad;
+      err.message = `${authorKindName(kindName)} "${String(def.name)}": \`response.${key}\` is ${describeEntry(member)} \u2014 a response key takes a value (\`ref("x")\`, \`c.*\`) or a { key: value } record.` + (Array.isArray(member) ? ` A list of values goes inside a record member (\`${key}: { items: [ \u2026 ] }\`), or bind it first (\`s.set_var\`) and use \`ref()\`; a list of constants is \`c.array([ \u2026 ])\`.` : "");
+    }
+    return err;
+  }
+  if (!err.message.startsWith("obj(): `")) return err;
+  for (const [key, member] of Object.entries(response)) {
+    if (member === null || typeof member !== "object" || Array.isArray(member) || isTaggedValue(member)) continue;
+    try {
+      obj(member);
+    } catch {
+      err.message = `${authorKindName(kindName)} "${String(def.name)}": ` + err.message.replace("obj(): `", `\`response.${key}.`) + ` A nested response record is one object expression; a top-level response key can carry this value as it is.`;
+      break;
+    }
+  }
+  return err;
+}
+function assertDefEntry(via, kindName, def, index) {
+  if (typeof def === "object" && def !== null && !Array.isArray(def)) return;
+  const at = index === void 0 ? "its argument" : `entry [${index}]`;
+  const hint = def === false || def === void 0 ? " A `cond && def` entry leaves false/undefined behind \u2014 spread it instead: `...(cond ? [def] : [])`." : typeof def === "function" ? " A factory passed uncalled is a function \u2014 call it: `table({ \u2026 })`, not `table`." : Array.isArray(def) && index === void 0 ? ` It takes one def, not a list \u2014 \`${via}(def)\`.` : "";
+  throw new Error(`${via}: ${at} must be ${withArticle(authorKindName(kindName))} def \u2014 got ${describeEntry(def)}.${hint}`);
+}
+function authorKindName(kindName) {
+  return AUTHOR_KIND_NAME[kindName] ?? (kindName === "workspace" ? "workspaceConfig" : kindName);
+}
+var REGISTER_METHOD = {
+  workspace: "registerWorkspace",
+  table: "registerTables",
+  function: "registerFunctions",
+  query: "registerQueries",
+  api_group: "registerApiGroups",
+  task: "registerTasks",
+  middleware: "registerMiddleware",
+  addon: "registerAddons",
+  tool: "registerTools",
+  prompt: "registerPrompts",
+  resource: "registerResources",
+  mcp_server: "registerMcpServers",
+  agent: "registerAgents",
+  trigger: "registerTriggers",
+  knowledge: "registerKnowledge",
+  microservice: "registerMicroservices",
+  realtime_server: "registerRealtimeServers",
+  channel: "registerRealtimeChannels",
+  message: "registerRealtimeMessages",
+  workflow_test: "registerWorkflowTests"
+};
+function structuralKind(def, kindName) {
+  if (typeof def !== "object" || def === null) return void 0;
+  const d = def;
+  if (typeof d.verb === "string") return "query";
+  if (typeof d.objType === "string") return "trigger";
+  if (d.cors !== void 0 || d.swagger !== void 0 && kindName !== "workspace") return "api_group";
+  if (d.canonical !== void 0 && !CANONICAL_KINDS.has(kindName)) return "api_group";
+  return void 0;
+}
+function standaloneDefKind(def) {
+  const branded = defKindOf(def);
+  if (branded !== void 0) return branded;
+  const structural = structuralKind(def, "");
+  if (structural !== void 0) return structural;
+  if (typeof def !== "object" || def === null) return void 0;
+  if (def.schema !== void 0) return "table";
+  const keys2 = Object.keys(def);
+  if (keys2.includes("name") && keys2.every((k) => API_GROUP_KEYS.has(k))) return "api_group";
+  return void 0;
+}
+var API_GROUP_KEYS = new Set(DEF_KEYS["api_group"]);
+var CANONICAL_KINDS = /* @__PURE__ */ new Set(["api_group", "mcp_server", "agent", "realtime_server", "workspace"]);
+function assertDefKind(via, kindName, def, index) {
+  const made = defKindOf(def) ?? structuralKind(def, kindName);
+  if (made === void 0 || made === kindName) return;
+  const at = index === void 0 ? "its argument" : `entry [${index}]`;
+  const method = REGISTER_METHOD[made];
+  throw new Error(
+    `${via}: ${at} is ${withArticle(authorKindName(made))} def, not ${withArticle(authorKindName(kindName))} def` + (method === void 0 ? "." : ` \u2014 use ${method}.`)
+  );
+}
+function acceptedWarnings(kindName, def) {
+  const diagnostics = def?.diagnostics;
+  if (diagnostics === void 0 || diagnostics === null) return void 0;
+  const offered = allowableWarnings(kindName);
+  const name = def.name;
+  const owner = `${authorKindName(kindName)}${typeof name === "string" ? ` "${name}"` : ""}`;
+  const codes = offered.map((c) => `"${c}"`).join(", ");
+  if (offered.length === 0) throw new Error(`${owner}: \`diagnostics\` \u2014 this def raises no warning that can be accepted.`);
+  const allow = diagnostics.allow;
+  const extra = typeof diagnostics === "object" ? Object.keys(diagnostics).find((k) => k !== "allow") : void 0;
+  if (typeof diagnostics !== "object" || !Array.isArray(allow) || extra !== void 0) {
+    throw new Error(
+      `${owner}: \`diagnostics\` must be { allow: [...] } \u2014 got ${describeEntry(extra ?? allow ?? diagnostics)}${extra === void 0 ? "" : " as a key"}. Codes this def can accept: ${codes}.`
+    );
+  }
+  for (const code of allow) {
+    if (typeof code === "string" && offered.includes(code)) continue;
+    const near = typeof code === "string" ? nearestCode(code, offered) : void 0;
+    throw new Error(
+      `${owner}: \`diagnostics.allow\` names ${typeof code === "string" ? `unknown code "${code}"` : describeEntry(code)} for ${withArticle(authorKindName(kindName))}${near === void 0 ? "." : ` \u2014 did you mean "${near}"?`} Codes this def can accept: ${codes}.`
+    );
+  }
+  return new Set(allow);
+}
+function asAuthoringRefusal(err) {
+  if (err instanceof Error && Object.getPrototypeOf(err) === Error.prototype && err.code === void 0) {
+    Object.defineProperty(err, "name", { value: "UsageError", configurable: true, writable: true });
+  }
+  return err;
+}
+function nearestCode(code, offered) {
+  return nearestKey(code, offered) ?? offered.find((c) => c.includes(code) || code.includes(c));
+}
+var Xano = class {
+  /** @internal cross-realm identity brand — see {@link Xano.isXano}. */
+  [XANO_BRAND] = true;
+  constructor() {
+    Object.defineProperty(this, XANO_ORIGIN, { value: new Error("registry created"), enumerable: false });
+  }
+  /** Encoded objects keyed by `packageExport` payload key. */
+  sections = /* @__PURE__ */ new Map();
+  /** Table defs, encoded lazily at {@link export} so each can inherit the workspace `use_xdo`. */
+  tableDefs = [];
+  knowledgeDefs = [];
+  workspaceConfig = {};
+  /**
+   * Whether the attached config named `env` at all — `env: {}` included. The
+   * encoded config always carries an `env` list, so it cannot tell a config that
+   * declares none on purpose from one that was never attached; this can.
+   */
+  envAuthored = false;
+  /**
+   * Whether a config was passed to {@link registerWorkspace} by the author, as
+   * opposed to the `{ name }` the {@link workspace} shorthand registers. Lets the
+   * env guard tell "no config attached" from "the attached config has no `env`".
+   */
+  configAttached = false;
+  bundleType = "workspace";
+  /**
+   * Encoded objects whose `canonical` a locked {@link export} filled in (from
+   * the lock or freshly minted) rather than the author writing it.
+   *
+   * The fill mutates the registered object, so a second `export()` off the same
+   * registry can no longer see that the slug started empty. Without this the
+   * re-export would classify a minted token as a pinned one and a later release
+   * would refuse over a URL nobody promised.
+   */
+  filledCanonicals = /* @__PURE__ */ new WeakSet();
+  /** The filled canonicals whose lock entry was adopted from a live backend (`canonical_source: "adopted"`). */
+  adoptedCanonicals = /* @__PURE__ */ new WeakSet();
+  /** Every guid a def pins with its own `guid:` — recorded in the lock as `guid_source: "code"`. */
+  codeGuids = /* @__PURE__ */ new Set();
+  /** True for any `Xano` registry, even one created by a different module instance. */
+  static isXano(value) {
+    return typeof value === "object" && value !== null && value[XANO_BRAND] === true;
+  }
+  /** Encode one def and stamp its deterministic guid (the engine's sync/reference anchor). */
+  encodeOne(kind, def) {
+    let encoded;
+    const raised = [];
+    const previous = setDiagnosticSink((d) => raised.push(d));
+    try {
+      encoded = kind.encode(def);
+    } catch (err) {
+      throw asAuthoringRefusal(nameResponseRecordError(err, kind.name, def));
+    } finally {
+      setDiagnosticSink(previous);
+    }
+    if (raised.length > 0 && encoded !== null && typeof encoded === "object") this.encodeWarnings.set(encoded, raised);
+    assertTestIds(encoded, kind.name);
+    assertMockKeysResolved(encoded, kind.name);
+    if (REFERENCEABLE_KINDS.has(kind.name) && encoded && typeof encoded === "object") {
+      const obj2 = encoded;
+      const explicit = def.guid;
+      if (obj2.guid === void 0 && typeof obj2.name === "string") {
+        obj2.guid = explicit ?? kind.guidOf?.(def) ?? deriveGuid(kind.payloadKey, obj2.name);
+      }
+      if (typeof explicit === "string" && explicit !== "" && obj2.guid === explicit) this.codeGuids.add(explicit);
+    }
+    return encoded;
+  }
+  /** Register one or more authoring defs of a given kind. */
+  register(kindName, defOrDefs, via = `register(${JSON.stringify(kindName)})`) {
+    const kind = getKind(kindName);
+    const defs = Array.isArray(defOrDefs) ? defOrDefs : [defOrDefs];
+    defs.forEach((def, i) => {
+      assertDefEntry(via, kind.name, def, Array.isArray(defOrDefs) ? i : void 0);
+      assertDefKind(via, kind.name, def, Array.isArray(defOrDefs) ? i : void 0);
+      const name = def.name;
+      assertDefKeys(`${authorKindName(kind.name)}${typeof name === "string" ? ` "${name}"` : ""}`, def, DEF_KEYS[kind.name], kind.name);
+      assertDefShape(kind.name, def);
+      assertNameAsStored(authorKindName(kind.name), name);
+    });
+    const allows = defs.map((def) => acceptedWarnings(kind.name, def));
+    for (const def of defs) this.assertNotAlreadyRegistered(kind.name, def);
+    if (kind.name === "table") {
+      defs.forEach((def, i) => {
+        this.tableDefs.push(def);
+        if (allows[i]) this.accepted.set(def, allows[i]);
+      });
+      return this;
+    }
+    if (kind.name === "knowledge") {
+      for (const def of defs) this.knowledgeDefs.push(def);
+    }
+    const bucket = this.sections.get(kind.payloadKey) ?? [];
+    defs.forEach((def, i) => {
+      const encoded = this.encodeOne(kind, def);
+      const allow = allows[i];
+      if (allow && encoded && typeof encoded === "object") this.accepted.set(encoded, allow);
+      bucket.push(encoded);
+    });
+    this.sections.set(kind.payloadKey, bucket);
+    return this;
+  }
+  /**
+   * A table's bundle entry, encoded now that the workspace `use_xdo` is known: a
+   * table without an explicit `useXdo` inherits the workspace default.
+   */
+  encodeTableEntry(def) {
+    const wsUseXdo = this.workspaceConfig.use_xdo === true;
+    const encoded = this.encodeOne(
+      getKind("table"),
+      def.useXdo === void 0 ? { ...def, useXdo: wsUseXdo } : def
+    );
+    const dbo = { ...encoded, import: { mode: "standard" } };
+    const allow = this.accepted.get(def);
+    if (allow) this.accepted.set(dbo, allow);
+    const raised = this.encodeWarnings.get(encoded);
+    if (raised) this.encodeWarnings.set(dbo, raised);
+    return dbo;
+  }
+  /**
+   * @internal The entry `def` becomes in the bundle a registry holding only it
+   * exports — what `emit` and `xanosdk compile` print. Registered first, so the
+   * def is validated exactly as a `register*` call validates it; the encoder's
+   * warnings are returned rather than printed, for the caller's checks to raise.
+   * The cross-object fills a lone def can take are applied as export applies
+   * them: an empty canonical from the seeded lock, hosted-file icons from
+   * `opts.hostedFiles`, a group's documentation token from
+   * `opts.documentationTokens`. Knowledge bodies are export's.
+   */
+  encodeEntry(kindName, def, opts = {}) {
+    const kind = getKind(kindName);
+    if (kind.name === "workspace") {
+      this.registerWorkspace(def);
+      return { payloadKey: kind.payloadKey, entry: this.export().payload.workspace, warnings: [] };
+    }
+    this.register(kind.name, def);
+    const encoded = kind.name === "table" ? this.encodeTableEntry(def) : this.sections.get(kind.payloadKey).at(-1);
+    const warnings = this.encodeWarnings.get(encoded) ?? [];
+    let entry = encoded;
+    if (CANONICAL_PAYLOAD_KEYS.has(kind.payloadKey) && entry.canonical === "" && typeof entry.name === "string") {
+      const locked = getLockedCanonical(lockKey(kind.payloadKey, entry.name));
+      if (locked !== void 0) entry = { ...entry, canonical: locked };
+    }
+    if (opts.hostedFiles !== void 0 && HOSTED_ICON_KINDS.includes(kind.payloadKey)) {
+      const sections = { [kind.payloadKey]: [entry] };
+      this.fillHostedFiles(sections, opts.hostedFiles);
+      entry = sections[kind.payloadKey][0];
+    }
+    if (kind.name === "api_group") {
+      entry = resolveDocumentationTokens({
+        workspace: {},
+        apiGroups: [entry],
+        values: opts.documentationTokens ?? {}
+      }).apiGroups[0];
+    }
+    return { payloadKey: kind.payloadKey, entry, warnings };
+  }
+  /**
+   * Every def object handed to {@link register}, by identity, so the SAME one
+   * registered twice is caught at the call that did it.
+   *
+   * Identity, not structure. Two separately constructed defs sharing a name are
+   * a genuine collision, and the guid check at export already diagnoses that
+   * correctly — it explains that identity derives from `(type, name)` and names
+   * both objects. This guard must not shadow it.
+   */
+  registered = /* @__PURE__ */ new Set();
+  /** The warnings each encoded object's encoder raised, raised again about it by every export. */
+  encodeWarnings = /* @__PURE__ */ new WeakMap();
+  /** Each encoded object's accepted warning codes, from its def's `diagnostics.allow`. */
+  accepted = /* @__PURE__ */ new WeakMap();
+  /** The workspace config's accepted warning codes — they hold for every object. */
+  workspaceAccepted;
+  /**
+   * Refuse the same def object twice.
+   *
+   * The failure this front-runs: a helper registers a def on your behalf and
+   * you then register it again yourself — `registerAuth(ws).registerTables([userTable])`
+   * is the reported shape. Nothing objected at the second call; it surfaced much
+   * later at `emitBundle` as `Duplicate object guid (efb55…) shared by "dbo/user"
+   * and "dbo/user"`, a message that names a guid and the same label twice and
+   * points at neither line.
+   */
+  assertNotAlreadyRegistered(kindName, def) {
+    if (def === null || typeof def !== "object") return;
+    if (!this.registered.has(def)) {
+      this.registered.add(def);
+      return;
+    }
+    const name = def.name;
+    const label = typeof name === "string" ? `"${name}"` : "it";
+    throw new Error(
+      `register: the same ${kindName} def ${label} was registered twice on this workspace. The second registration is always a mistake \u2014 the bundle would carry the object twice under one guid, which fails the import. A helper that registers on your behalf is the usual cause (\`registerAuth(ws)\` registers its own tables, so a following \`registerTables([userTable])\` is the duplicate): drop the manual call. Two DIFFERENT defs that share a name are a separate problem, and export reports that one by guid.`
+    );
+  }
+  /**
+   * Register the workspace settings object (singleton).
+   *
+   * A config with no `name` inherits the one already on the registry — which is
+   * what `workspace("my-app")` set — so the natural chain
+   * `workspace("my-app").registerWorkspace(workspaceConfig({ history }))` no
+   * longer makes an author restate a name this registry has held since its
+   * first call. An explicit `name` still wins, and a rename this way is
+   * a rename of the workspace.
+   */
+  registerWorkspace(def) {
+    if (def !== void 0 && def !== null) {
+      assertDefEntry("registerWorkspace", "workspace", def, void 0);
+      assertDefKind("registerWorkspace", "workspace", def, void 0);
+      assertNoProtoKeys("registerWorkspace", def);
+      assertDefKeys("workspaceConfig", def, DEF_KEYS.workspace, "workspace");
+      assertDefShape("workspace", def);
+    }
+    const authored = def ?? {};
+    if (typeof authored.name === "string" && authored.name.trim() === "") {
+      throw new Error(
+        `registerWorkspace: the workspace name must not be blank \u2014 got ${describeEntry(authored.name)}. Name it, or leave \`name\` out to keep the one \`workspace("\u2026")\` gave.`
+      );
+    }
+    const inherited = this.workspaceConfig.name;
+    const withName = authored.name === void 0 && typeof inherited === "string" ? { ...authored, name: inherited } : authored;
+    this.workspaceConfig = encodeObject("workspace", withName);
+    this.workspaceAccepted = acceptedWarnings("workspace", authored);
+    this.envAuthored = authored.env !== void 0;
+    this.configAttached = SHORTHAND_CONFIGS.has(def) ? this.configAttached : true;
+    return this;
+  }
+  /**
+   * Fill each encoded knowledge item's `content` and emit its reference files as
+   * the sibling `knowledge_file` section.
+   *
+   * Reference rows name their parent by GUID rather than by row id: the id does
+   * not exist until the import inserts the parent, and the importer resolves the
+   * guid back to it. `references` stays empty — the platform derives that list
+   * from the stored files itself, so anything written here is overwritten.
+   */
+  fillKnowledge(sections, resolved) {
+    const byName = new Map(resolved.map((r) => [r.name, r]));
+    const files = [];
+    const warnings = [];
+    const items = (sections.knowledge ?? []).map((source) => {
+      if (!byName.has(source.name)) return source;
+      const copy = { ...source };
+      const allow = this.accepted.get(source);
+      if (allow) this.accepted.set(copy, allow);
+      const raised = this.encodeWarnings.get(source);
+      if (raised) this.encodeWarnings.set(copy, raised);
+      return copy;
+    });
+    if (sections.knowledge !== void 0) sections.knowledge = items;
+    for (const item of items) {
+      const match = byName.get(item.name);
+      if (match === void 0) continue;
+      item.content = match.content;
+      for (const w of match.warnings ?? []) warnings.push({ item, ...w });
+      for (const file of match.files) {
+        files.push({
+          knowledge: { id: item.guid },
+          path: file.path,
+          content: file.content,
+          size: file.size,
+          guid: deriveGuid("knowledge_file", `${item.name}/${file.path}`)
+        });
+      }
+    }
+    if (files.length > 0) sections.knowledge_file = files;
+    return warnings;
+  }
+  /**
+   * Replace every pending hosted-file placeholder with the resolver's value and
+   * list the files it read as the `vault` section.
+   *
+   * The encoded MCP objects are the registry's own, shared by every export, so
+   * each is copied rather than edited: an unresolved `export()` after a
+   * resolved one still sees the inert placeholder.
+   */
+  fillHostedFiles(sections, resolver) {
+    for (const key of HOSTED_ICON_KINDS) {
+      const items = sections[key];
+      if (items === void 0) continue;
+      sections[key] = items.map((item) => {
+        const icons = item.icons;
+        if (!Array.isArray(icons) || !icons.some((icon) => pendingHostedFile(icon) !== void 0)) return item;
+        const copy = {
+          ...item,
+          icons: icons.map((icon) => {
+            const hosted = pendingHostedFile(icon);
+            return hosted === void 0 ? icon : { ...icon, src: resolver.resolve(hosted.ref, hosted.rules) };
+          })
+        };
+        const allow = this.accepted.get(item);
+        if (allow) this.accepted.set(copy, allow);
+        return copy;
+      });
+    }
+    const rows = resolver.libraryRows();
+    if (rows.length > 0) sections.vault = rows;
+  }
+  /** Set the bundle `type` (defaults to "workspace"). */
+  setBundleType(type) {
+    this.bundleType = type;
+    return this;
+  }
+  /**
+   * The registered table defs (with their authored `seed`), for the Node deploy
+   * path to build `content/` seed entries. Deliberately NOT reached from
+   * `export()` — seed values are resolved only in the deploy pipeline, so they
+   * never enter the browser-safe bundle. See {@link import("./seed.js")}.
+   */
+  tables() {
+    return [...this.tableDefs];
+  }
+  /**
+   * The ENCODED workspace config, read-only.
+   *
+   * For the deploy path, which needs to know which env variable names the
+   * workspace declares before the bundle exists — so an `--env-var` naming
+   * something undeclared can be reported as an addition rather than silently
+   * appended, and so a declared name with no value anywhere can refuse a deploy
+   * rather than clear the live one. A shallow copy: nothing outside
+   * `registerWorkspace` may write it.
+   */
+  workspaceSettings() {
+    return { ...this.workspaceConfig };
+  }
+  /**
+   * Every scope in this workspace that declares a documentation gate, with the
+   * sidecar key its token is stored under.
+   *
+   * For the deploy path, which has to know them before the bundle exists — so a
+   * gate with no token anywhere can refuse a deploy rather than ship a workspace
+   * whose doc site silently does not match its source. Read off the ENCODED
+   * shapes, so a decoded workspace is covered exactly like a hand-authored one,
+   * and so the guid each key is built from is the one already stamped at
+   * registration.
+   */
+  documentationTokenNames() {
+    return documentationTokenDeclarations({
+      workspace: this.workspaceConfig,
+      apiGroups: this.sections.get("app")
+    });
+  }
+  /**
+   * The registered knowledge defs (with their authored `body`/`refs` path
+   * markers), for the Node compile path to read markdown off disk. Deliberately
+   * NOT reached from `export()` — a file read has no place in the browser-safe
+   * bundle, so the encoder emits an empty `content` and the compile path fills
+   * it. See {@link import("./knowledge.js")}.
+   */
+  knowledge() {
+    return [...this.knowledgeDefs];
+  }
+  registerFunctions(defs) {
+    return this.register("function", defs, "registerFunctions");
+  }
+  /** Register knowledge items — the markdown a workspace's AI agents read. */
+  registerKnowledge(defs) {
+    return this.register("knowledge", defs, "registerKnowledge");
+  }
+  registerTriggers(defs) {
+    return this.register("trigger", defs, "registerTriggers");
+  }
+  registerTools(defs) {
+    return this.register("tool", defs, "registerTools");
+  }
+  /** Register MCP prompts. Expose one by listing it in an `mcpServer({ prompts })`. */
+  registerPrompts(defs) {
+    return this.register("prompt", defs, "registerPrompts");
+  }
+  /** Register MCP resources. Expose one by listing it in an `mcpServer({ resources })`. */
+  registerResources(defs) {
+    return this.register("resource", defs, "registerResources");
+  }
+  registerMcpServers(defs) {
+    return this.register("mcp_server", defs, "registerMcpServers");
+  }
+  registerAgents(defs) {
+    return this.register("agent", defs, "registerAgents");
+  }
+  registerTables(defs) {
+    return this.register("table", defs, "registerTables");
+  }
+  registerQueries(defs) {
+    return this.register("query", defs, "registerQueries");
+  }
+  registerApiGroups(defs) {
+    return this.register("api_group", defs, "registerApiGroups");
+  }
+  registerTasks(defs) {
+    return this.register("task", defs, "registerTasks");
+  }
+  registerMiddleware(defs) {
+    return this.register("middleware", defs, "registerMiddleware");
+  }
+  registerAddons(defs) {
+    return this.register("addon", defs, "registerAddons");
+  }
+  registerMicroservices(defs) {
+    return this.register("microservice", defs, "registerMicroservices");
+  }
+  registerRealtimeServers(defs) {
+    return this.register("realtime_server", defs, "registerRealtimeServers");
+  }
+  registerRealtimeChannels(defs) {
+    return this.register("channel", defs, "registerRealtimeChannels");
+  }
+  registerRealtimeMessages(defs) {
+    return this.register("message", defs, "registerRealtimeMessages");
+  }
+  registerWorkflowTests(defs) {
+    return this.register("workflow_test", defs, "registerWorkflowTests");
+  }
+  /**
+   * Assemble the signed aggregate `packageExport` bundle.
+   *
+   * With `options.lock` (a {@link LockExportContext}), the export participates
+   * in identity locking: empty api-group/toolset canonicals are filled from the
+   * lock — minted fresh on first sight — and every identity the bundle emits is
+   * reported back through `ctx.observed` (MUTATING the passed context), which
+   * the caller merges into the lock file. All lock work happens before the
+   * bundle is signed. Without options the output is byte-identical to before.
+   *
+   * With `options.strict`, every build WARNING fails the export instead of
+   * printing — the shapes that deploy clean and then lose data or return the
+   * wrong rows. Nothing about the emitted bundle changes; it either exports or
+   * it does not.
+   */
+  export(options = {}) {
+    try {
+      return this.assemble(options);
+    } catch (err) {
+      throw asAuthoringRefusal(err);
+    }
+  }
+  /** {@link export}'s work, its refusals not yet classed. */
+  assemble(options) {
+    const lockCtx = options.lock;
+    const sections = {};
+    for (const [key, arr] of this.sections) {
+      sections[key] = arr;
+    }
+    if (this.tableDefs.length > 0) {
+      sections[getKind("table").payloadKey] = this.tableDefs.map((def) => this.encodeTableEntry(def));
+    }
+    const knowledgeWarnings = options.knowledge !== void 0 && options.knowledge.length > 0 ? this.fillKnowledge(sections, options.knowledge) : [];
+    if (options.hostedFiles !== void 0) {
+      this.fillHostedFiles(sections, options.hostedFiles);
+    }
+    const resolveDocs = () => resolveDocumentationTokens({
+      workspace: this.workspaceConfig,
+      apiGroups: sections["app"],
+      values: options.documentationTokens ?? {},
+      ...options.allowEmptyDocToken ? { allowEmpty: options.allowEmptyDocToken } : {}
+    });
+    const docsView = resolveDocs();
+    docsView.apiGroups?.forEach((copy, i) => {
+      const allow = this.accepted.get(sections["app"]?.[i]);
+      if (allow && copy !== null && typeof copy === "object") this.accepted.set(copy, allow);
+    });
+    const bag = new DiagnosticBag(options.strict === true);
+    const used = /* @__PURE__ */ new Map();
+    const use = (allow, code) => {
+      if (allow?.has(code) !== true) return false;
+      used.set(allow, (used.get(allow) ?? /* @__PURE__ */ new Set()).add(code));
+      return true;
+    };
+    bag.accepts = (code, subject) => {
+      const own = use(subject === void 0 ? void 0 : this.accepted.get(subject), code);
+      return use(this.workspaceAccepted, code) || own;
+    };
+    let subjectMap;
+    const subjects = () => subjectMap ??= this.diagnosticSubjects(sections, docsView.apiGroups);
+    bag.describe = (subject) => subjects().get(subject);
+    for (const arr of Object.values(sections)) {
+      for (const obj2 of arr ?? []) {
+        if (obj2 === null || typeof obj2 !== "object") continue;
+        for (const d of this.encodeWarnings.get(obj2) ?? []) bag.warn(d.code, d.message, obj2);
+      }
+    }
+    for (const { item, code, message } of knowledgeWarnings) bag.warn(code, message, item);
+    checkDocumentationTokens(this.workspaceConfig, sections, bag, options.secretsRemedy);
+    const documentedSections = docsView.apiGroups === void 0 ? sections : { ...sections, app: docsView.apiGroups };
+    checkApiGroupDocsExposure(documentedSections, bag, new Set(docsView.unresolvedGroups), options.secretsRemedy);
+    this.validateQueryAuth(sections, bag);
+    this.validateMiddlewareAuth(sections, bag);
+    this.validatePostMiddlewareEnvelope(sections, bag);
+    checkMicroserviceSecrets(sections, bag);
+    checkMicroserviceBlocks(sections, bag);
+    checkNonJsonValues(sections, bag, this.workspaceConfig);
+    checkLiveDatasourceTests(sections, bag);
+    checkStacks(
+      this.tableDefs,
+      sections,
+      bag,
+      this.workspaceConfig,
+      this.envAuthored ? "authored" : this.configAttached ? "no-env" : "unattached"
+    );
+    checkExpressionOperands(sections, bag);
+    checkInterpolatedValues(sections, bag);
+    checkZeroBasedObjects(sections, bag);
+    checkIntRange(sections, bag);
+    checkRegexOperandOrder(sections, bag);
+    checkTimezoneArgs(sections, bag);
+    checkReferences(this.bundleType, sections, this.workspaceConfig.guid, bag);
+    checkMicroserviceReferences(this.bundleType, sections, bag);
+    checkDecodeOnlyStatements(sections, bag);
+    checkRunFamilyHosts(sections, bag);
+    checkLoopControl(sections, bag);
+    checkSwitchFallthrough(sections, bag);
+    checkSearchOperandFilters(sections, bag);
+    checkFilterOperands(sections, bag);
+    checkToolAuthIdentity(sections, bag);
+    checkPrimitiveAuthIdentity(sections, bag);
+    checkWriteBeforeElicit(sections, bag);
+    checkMcpStackHazards(sections, bag);
+    checkMcpResourceUris(sections, bag);
+    checkMcpOauth(sections, bag);
+    checkMcpOauthRevoke(sections, bag);
+    checkStackAuthRatelimit(sections, bag);
+    checkRatelimitWithoutError(sections, bag);
+    checkAuthNoCaller(sections, bag);
+    checkRealtimeGates(sections, bag);
+    checkRealtimeSilentShapes(sections, bag);
+    checkNonNullVectorColumns(sections, bag);
+    checkRealtimeDeliver(this.bundleType, sections, bag);
+    checkRealtimeJoinDeliver(sections, bag);
+    checkTriggerBindings(sections, bag);
+    checkUnboundVarRefs(sections, bag);
+    checkToThrowScope(sections, bag);
+    checkPasswordInputHashing(sections, bag);
+    checkZipPasswordKeys(sections, bag);
+    checkSafeRefMatchArgs(sections, bag);
+    checkNullMatchArgs(sections, bag);
+    checkPathSegmentCandidates(sections, bag);
+    checkRouteShadowing(sections, bag);
+    checkSameNameSiblings(sections, bag);
+    checkSeed(this.tableDefs, bag, this.workspaceConfig.use_xdo === true);
+    checkReservedColumnNames(this.tableDefs, bag);
+    checkUnusableColumnNames(this.tableDefs, bag);
+    checkCacheTtl(sections, bag);
+    checkReservedInputNames(sections, bag);
+    checkOmittedCallInputs(sections, bag);
+    checkUnknownCallInputs(sections, bag);
+    checkAddonAttachments(sections, bag);
+    checkUnitTests(sections, bag);
+    checkAddonOutput(sections, bag);
+    checkGuardRoleColumns(sections, this.tableDefs, bag);
+    checkToolOutputSchema(sections, bag);
+    checkAgentArgPlaceholders(sections, bag);
+    checkAssertionsOutsideTests(sections, bag);
+    checkAgentApiKeys(sections, bag);
+    checkKnowledge(sections, bag, { resolved: options.knowledge !== void 0 });
+    checkRealtimePublish(this.bundleType, sections, bag);
+    this.checkAllowsUsed(bag, subjects, used);
+    options.accepted?.push(...bag.accepted());
+    bag.flush();
+    if (lockCtx) this.applyLock(lockCtx, sections);
+    if (this.workspaceConfig.guid === void 0) {
+      const wsName = typeof this.workspaceConfig.name === "string" ? this.workspaceConfig.name : "workspace";
+      this.workspaceConfig.guid = deriveGuid("workspace", wsName);
+    }
+    const shipped = resolveDocs();
+    if (shipped.apiGroups !== void 0) sections["app"] = shipped.apiGroups;
+    return buildBundle({
+      type: this.bundleType,
+      workspace: shipped.workspace,
+      sections,
+      lock: lockCtx?.lock,
+      ...options.envOverrides ? { envOverrides: options.envOverrides } : {},
+      ...options.knowledge !== void 0 ? { knowledgeRead: true } : {}
+    });
+  }
+  /**
+   * The def each object this export checks was registered from — the encoded
+   * objects, the table defs whose columns are read directly, and the copies the
+   * docs view took — for a finding to name its subject.
+   */
+  diagnosticSubjects(sections, docsCopies) {
+    const subjects = /* @__PURE__ */ new Map();
+    const add = (obj2, kind) => {
+      if (obj2 === null || typeof obj2 !== "object") return;
+      const name = obj2.name;
+      if (typeof name === "string") subjects.set(obj2, { kind, name });
+    };
+    add(this.workspaceConfig, "workspace");
+    for (const [key, items] of Object.entries(sections)) {
+      for (const obj2 of items ?? []) add(obj2, sdkKindName(key, obj2));
+    }
+    for (const def of this.tableDefs) add(def, "table");
+    docsCopies?.forEach((copy, i) => {
+      const source = subjects.get(sections["app"]?.[i]);
+      if (source && copy !== null && typeof copy === "object") subjects.set(copy, source);
+    });
+    return subjects;
+  }
+  /**
+   * Warn on each `diagnostics.allow` code that accepted nothing in this export.
+   * The shape it named is gone, or the check stopped finding it — either way
+   * the source still reads as "this def has a known hazard". Raised directly
+   * rather than through `warn`: it is about the allow itself, so no allow can
+   * accept it. A code whose check did not run here had nothing to accept.
+   */
+  checkAllowsUsed(bag, subjects, used) {
+    const owners = /* @__PURE__ */ new Map();
+    for (const [obj2, subject] of subjects()) {
+      const allow = obj2 === this.workspaceConfig ? this.workspaceAccepted : this.accepted.get(obj2);
+      if (allow && !owners.has(allow)) owners.set(allow, subject);
+    }
+    for (const [allow, subject] of owners) {
+      const unused = [...allow].filter((code) => used.get(allow)?.has(code) !== true && !bag.wasSkipped(code));
+      if (unused.length === 0) continue;
+      const one = unused.length === 1;
+      bag.add({
+        severity: "warning",
+        code: "diagnostics.allow-unused",
+        message: `${subject.kind} "${subject.name}": \`diagnostics.allow\` accepts ${unused.map((c) => `"${c}"`).join(", ")}, but this export raised no such warning about ${allow === this.workspaceAccepted ? "any def" : "it"} \u2014 the shape ${one ? "it" : "they"} accepted is gone, or the check no longer finds it. Remove ${one ? "it" : "them"} from \`allow\`.`,
+        subject
+      });
+    }
+  }
+  /**
+   * Cross-check every query's resolved `auth` against the registered auth tables.
+   *
+   * `resolveAuth` (in `encodeQuery`) turns a table ref into a guid with no
+   * registry visibility, so a bare-name typo produces a valid-looking guid that
+   * only fails at deploy with an opaque engine error. Here we have the registry,
+   * so we catch it at export and name the offending query.
+   *
+   * A registered table that is not `table({ auth: true })` only WARNS: the
+   * engine reads that flag nowhere at request time (it compares the token's
+   * `dbo` to the endpoint's by name, and mints tokens for any table by name), so
+   * refusing the combination blocked a real workspace's round trip. A numeric
+   * `auth` (raw `dbo.id` escape hatch) references a table by id xanosdk never
+   * sees, so it's left as-is; `false` is a public endpoint. A table that pins an
+   * explicit `guid` referenced by bare name lands in the "not registered" branch
+   * (its name-derived guid diverges from the pinned one) — pass the def instead.
+   */
+  validateQueryAuth(sections, bag) {
+    const queries = sections["query"];
+    if (!Array.isArray(queries) || queries.length === 0) return;
+    const tableNameByGuid = /* @__PURE__ */ new Map();
+    const authGuids = /* @__PURE__ */ new Set();
+    for (const def of this.tableDefs) {
+      const guid = resolveRef("dbo", def);
+      tableNameByGuid.set(guid, def.name);
+      if (def.auth === true) authGuids.add(guid);
+    }
+    for (const q of queries) {
+      if (!q || typeof q !== "object") continue;
+      const auth = q.auth;
+      if (typeof auth !== "string" || authGuids.has(auth)) continue;
+      const name = String(q.name ?? "?");
+      const known = tableNameByGuid.get(auth);
+      if (known) {
+        bag.warn(
+          "query.auth-table-unflagged",
+          `query "${name}" requires auth against table "${known}", which is not marked \`table({ auth: true })\`. The engine allows it \u2014 a token minted for that table is accepted \u2014 but the editor will not offer the table as an auth source. Mark it if that is what you meant.`,
+          q
+        );
+        continue;
+      }
+      if (this.bundleType === "workspace") continue;
+      bag.error(
+        "query.auth-table-unregistered",
+        refSpelling(auth) === "handle" ? `query "${name}": \`auth\` is a table def that isn't registered on this workspace \u2014 add it with \`registerTables([\u2026])\`.` : `query "${name}": \`auth\` references a table that isn't registered on this workspace. Check the name for a typo, or register the auth table with \`registerTables([\u2026])\`; if it pins an explicit \`guid\`, pass the table def rather than its name.`
+      );
+    }
+  }
+  /**
+   * Warn about an `auth()`-keyed middleware **directly attached** to a host where
+   * there is no caller identity for `auth()` to resolve.
+   *
+   * The footgun: a rate limiter keyed by `auth("id")` is the canonical middleware,
+   * but attach it to a host with no authenticated caller and `auth()` cannot
+   * resolve — every request 403s before the host runs, with no signal at author
+   * or export time. This surfaces it at export, where the
+   * middleware registry is known (an attachment entry only carries the target's
+   * guid; we resolve it back to the encoded `run` to inspect for `auth()`).
+   *
+   * It **warns, never throws** — a bare `auth()` reference is not proof the
+   * request will fail: the statement holding it may sit on a branch that never
+   * runs on this host, and the same middleware object is often attached to
+   * authenticated hosts too. Blocking the export would produce false positives
+   * on legitimate use. The warning names the host and reason so
+   * the author can confirm intent, key off `sys.remoteIp()`, or move to an
+   * authenticated host.
+   *
+   * Scope: the host's EFFECTIVE chain, across all three tiers. Seeing only a
+   * host's own `middleware.pre`/`post` would let an author who DRY'd a per-user
+   * limiter up to `apiGroup({ middleware })` or to the workspace tier silently
+   * reintroduce the failure — the same unresolvable key, attached one level up,
+   * with the warning switched off. The limiter is most naturally written once at
+   * the group, so that is the tier that most needs the warning.
+   *
+   * The cascade is the engine's own: a phase whose `_customize` flag is set is
+   * answered by that tier (including `clear()`, which customizes with an empty
+   * list and therefore stops inheritance); an un-customized phase falls through
+   * to the API group, then to the workspace's `{objType}_{phase}` map. A query
+   * that clears a phase is NOT warned about a group middleware it does not run.
+   *
+   * An authenticated `query` (its own `auth` table set) resolves an identity, so
+   * it is skipped at every tier.
+   */
+  validateMiddlewareAuth(sections, bag) {
+    const authCache = /* @__PURE__ */ new Map();
+    const referencesAuth = (guid, mw) => {
+      let hit = authCache.get(guid);
+      if (hit === void 0) {
+        const run = mw?.run;
+        hit = stackReferencesAuth(Array.isArray(run) ? run : void 0);
+        authCache.set(guid, hit);
+      }
+      return hit;
+    };
+    const reasons = {
+      query: "this endpoint has no auth table",
+      task: "a task is scheduled/background and never has a request identity",
+      function: "there is no caller identity unless an authenticated caller invokes it",
+      tool: "there is no caller identity unless an authenticated caller invokes it",
+      prompt: "there is no caller identity unless an authenticated caller invokes it",
+      resource: "there is no caller identity unless an authenticated caller invokes it"
+    };
+    for (const { label, host, hostName, tier, guid, middleware } of this.attachedMiddleware(sections)) {
+      if (label === "query" && host.auth) continue;
+      if (!referencesAuth(guid, middleware)) continue;
+      const mwName = String(middleware?.name ?? guid);
+      bag.warn(
+        "middleware.auth-null-host",
+        `middleware "${mwName}" references auth() and is attached to ${label} "${hostName}"${tier}, where ${reasons[label]}. auth() cannot resolve there and the request FAILS (403) rather than degrading to a shared key \u2014 attach it to an authenticated host, key off sys.remoteIp(), or remove auth().`,
+        middleware
+      );
+    }
+  }
+  /**
+   * Warn about a middleware in a host's effective **`post`** chain that reads a
+   * request field out of `s.util.get_all_input` — see `postEnvelopeMisreads`.
+   *
+   * In `post` that envelope holds the host's outcome (`{ status, result }`), not
+   * the request, so the read cannot resolve. Under the default `rethrow` policy
+   * it fails the request with `Unable to locate var` after the host's stack has
+   * run and its writes have landed. Checked on the effective chain for the same
+   * reason as {@link validateMiddlewareAuth}: a post middleware is most often
+   * attached once, at the group or the workspace tier.
+   *
+   * Warns rather than throws: the same middleware is valid in a `pre` chain, and
+   * a read on a branch the post path never takes fails nothing.
+   */
+  validatePostMiddlewareEnvelope(sections, bag) {
+    for (const middleware of sections["middleware"] ?? []) {
+      const unnested = unnestedEnvelopeReads(middleware);
+      if (unnested.length === 0) continue;
+      const hard = unnested.filter((r) => !r.safe);
+      const soft = unnested.filter((r) => r.safe);
+      const list = (rs) => rs.map((r) => `\`${r.path}\``).join(", ");
+      const fixed = unnested.map((r) => `\`${r.path.replace(".", ".vars.")}\``).join(", ");
+      const outcome = [
+        hard.length > 0 ? `${list(hard)} fails with \`Unable to locate var\` (a 500)` : "",
+        soft.length > 0 ? `${list(soft)} (a safe/\`get\` read) is always null, silently` : ""
+      ].filter(Boolean);
+      bag.warn(
+        "middleware.envelope-unnested",
+        `middleware "${String(middleware.name ?? "?")}" reads ${list(unnested)} straight off \`s.util.get_all_input\`, which binds a \`{ type, vars }\` envelope \u2014 the request is under \`vars\`, so ${outcome.join("; ")}. In \`pre\` read ${fixed} (or unwrap once: \`asFilters: [fl.get(c.text("vars"))]\`); in \`post\`, \`vars\` is \`{ status, result }\` and the request body is \`s.util.get_raw_input\`.`,
+        middleware
+      );
+    }
+    const misreadCache = /* @__PURE__ */ new Map();
+    for (const { label, hostName, phase, tier, guid, middleware } of this.attachedMiddleware(sections)) {
+      if (phase !== "post") continue;
+      let misreads = misreadCache.get(guid);
+      if (misreads === void 0) {
+        misreads = postEnvelopeMisreads(middleware);
+        misreadCache.set(guid, misreads);
+      }
+      if (misreads.length === 0) continue;
+      const mwName = String(middleware?.name ?? guid);
+      const results = [...new Set(misreads.map((p) => p.split(".")[0]))].map((b) => `\`${b}.vars.result.<field>\``).join(" / ");
+      bag.warn(
+        "middleware.post-reads-request",
+        `middleware "${mwName}" is in the post chain of ${label} "${hostName}"${tier} and reads ${misreads.map((p) => `\`${p}\``).join(", ")} from \`s.util.get_all_input\`. In \`post\` that envelope is \`{ type, vars: { status, result } }\` (plus \`payload\` on an error) \u2014 the host's outcome, not the request \u2014 so the read fails with \`Unable to locate var\` after the host already ran (under \`rethrow\`, a failed response for committed work). Read the response at ${results}, or the request body with \`s.util.get_raw_input\`.`,
+        middleware
+      );
+    }
+  }
+  /**
+   * Every enabled middleware attachment in each leaf host's EFFECTIVE chain,
+   * resolved across all three tiers — one row per host, phase and entry.
+   *
+   * The cascade is the engine's own: a phase whose `_customize` flag is set is
+   * answered by that tier (including `clear()`, which customizes with an empty
+   * list and therefore stops inheritance); an un-customized phase falls through
+   * to the API group (queries only), then to the workspace's
+   * `{objType}_{phase}` map. The apiGroup and workspace tiers are not hosts —
+   * they are resolved INTO each host's chain. A disabled attachment does not run
+   * and is not yielded.
+   */
+  *attachedMiddleware(sections) {
+    const middlewares = sections["middleware"];
+    if (!Array.isArray(middlewares) || middlewares.length === 0) return;
+    const byGuid = /* @__PURE__ */ new Map();
+    for (const mw of middlewares) {
+      if (!mw || typeof mw !== "object") continue;
+      const guid = mw.guid;
+      if (typeof guid === "string") byGuid.set(guid, mw);
+    }
+    const groupByGuid = /* @__PURE__ */ new Map();
+    for (const group of sections["app"] ?? []) {
+      if (!group || typeof group !== "object") continue;
+      const guid = group.guid;
+      if (typeof guid === "string") groupByGuid.set(guid, group);
+    }
+    const workspaceTier = this.workspaceConfig.middleware ?? {};
+    const list = (x) => Array.isArray(x) ? x : [];
+    const customizes = (block, phase) => !!block && typeof block === "object" && block[`${phase}_customize`] === true;
+    for (const label of MIDDLEWARE_HOST_KINDS) {
+      const hosts = sections[label];
+      if (!Array.isArray(hosts)) continue;
+      for (const host of hosts) {
+        if (!host || typeof host !== "object") continue;
+        const block = host.middleware;
+        const hostName = String(host.name ?? "?");
+        const groupId = label === "query" ? host.app?.id : void 0;
+        const group = typeof groupId === "string" ? groupByGuid.get(groupId) : void 0;
+        for (const phase of ["pre", "post"]) {
+          let entries;
+          let tier;
+          if (customizes(block, phase)) {
+            entries = list(block[phase]);
+            tier = "";
+          } else if (group && customizes(group.middleware, phase)) {
+            entries = list(group.middleware[phase]);
+            tier = ` (inherited from apiGroup "${String(group.name ?? "?")}")`;
+          } else {
+            entries = list(workspaceTier[`${label}_${phase}`]);
+            tier = " (inherited from the workspace tier)";
+          }
+          for (const entry of entries) {
+            if (entry?.disabled === true) continue;
+            const guid = middlewareEntryGuid(entry);
+            if (!guid) continue;
+            yield {
+              label,
+              host,
+              hostName,
+              phase,
+              tier,
+              guid,
+              middleware: byGuid.get(guid)
+            };
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Lock participation (see {@link export}): canonical fill + identity report.
+   * Runs after all sections are assembled and before signing.
+   */
+  applyLock(ctx, sections) {
+    const usedCanonicals = /* @__PURE__ */ new Set();
+    for (const entry of Object.values(ctx.lock.objects)) {
+      if (entry.canonical) usedCanonicals.add(entry.canonical);
+    }
+    for (const arr of Object.values(sections)) {
+      for (const obj2 of arr ?? []) {
+        const canonical = obj2.canonical;
+        if (typeof canonical === "string" && canonical !== "") usedCanonicals.add(canonical);
+      }
+    }
+    const mintUnique = () => {
+      let token = mintCanonical();
+      while (usedCanonicals.has(token)) token = mintCanonical();
+      usedCanonicals.add(token);
+      return token;
+    };
+    const canonicalByGuid = (guid) => {
+      if (typeof guid !== "string") return void 0;
+      for (const entry of Object.values(ctx.lock.objects)) {
+        if (entry.guid === guid && entry.canonical !== void 0) return entry.canonical;
+      }
+      return void 0;
+    };
+    const sourceByKey = /* @__PURE__ */ new Map();
+    for (const key of CANONICAL_PAYLOAD_KEYS) {
+      for (const obj2 of sections[key] ?? []) {
+        if (!obj2 || typeof obj2 !== "object") continue;
+        const o = obj2;
+        if (typeof o.name !== "string") continue;
+        if (o.canonical === "") {
+          const locked = ctx.lock.objects[lockKey(key, o.name)];
+          o.canonical = locked?.canonical ?? canonicalByGuid(o.guid) ?? mintUnique();
+          if (locked?.canonical !== void 0 && locked.canonical_source === "adopted") this.adoptedCanonicals.add(obj2);
+          this.filledCanonicals.add(obj2);
+        }
+        sourceByKey.set(
+          lockKey(key, o.name),
+          this.adoptedCanonicals.has(obj2) ? "adopted" : this.filledCanonicals.has(obj2) ? "minted" : "code"
+        );
+      }
+    }
+    const ws = this.workspaceConfig;
+    if (ws.canonical === "") {
+      ws.canonical = ctx.lock.objects[WORKSPACE_KEY]?.canonical ?? "";
+    }
+    if (typeof ws.canonical === "string" && ws.canonical !== "") {
+      recordObserved(ctx, WORKSPACE_KEY, { canonical: ws.canonical });
+    }
+    const appNames = identityNamesByGuid(sections);
+    const claimed = /* @__PURE__ */ new Map();
+    for (const [payloadKey, arr] of Object.entries(sections)) {
+      if (!LOCK_PAYLOAD_KEYS.has(payloadKey)) continue;
+      for (const obj2 of arr ?? []) {
+        if (!obj2 || typeof obj2 !== "object") continue;
+        const o = obj2;
+        if (typeof o.name !== "string" || typeof o.guid !== "string") continue;
+        const identity = { guid: o.guid };
+        if (this.codeGuids.has(o.guid)) identity.guid_source = "code";
+        const lockName = lockNameForObject(payloadKey, o, appNames);
+        const key = lockKey(payloadKey, lockName);
+        const label = `${sdkKindName(payloadKey, o)} "${o.name}"`;
+        const prior = claimed.get(key);
+        if (prior !== void 0 && prior.guid !== o.guid) {
+          const why = payloadKey === "toolset" ? "Agents and MCP servers share ONE name space." : `Two objects of one kind sharing a name behind explicit guids.`;
+          throw new Error(
+            `Two exported objects collapse onto lock key "${sdkKindName(payloadKey, o)}:${lockName}" \u2014 ${prior.label} and ${label}, with different guids (${prior.guid} vs ${o.guid}). ${why} A lock entry holds ONE guid per name, so an explicit \`guid\` cannot separate them: rename one.`
+          );
+        }
+        claimed.set(key, { label, guid: o.guid });
+        if (typeof o.canonical === "string" && o.canonical !== "") {
+          identity.canonical = o.canonical;
+          const source = sourceByKey.get(key);
+          if (source !== void 0) identity.canonical_source = source;
+        }
+        if (payloadKey === "toolset" && o.type === "agent") identity.type = "agent";
+        recordObserved(ctx, key, identity);
+      }
+    }
+  }
+};
+function workspace(name) {
+  if (typeof name !== "string" || name.trim() === "") {
+    throw new Error(
+      `workspace(name): the workspace name must be a non-empty string \u2014 got ${describeEntry(name)}. Name it: \`workspace("my-app")\`.`
+    );
+  }
+  const shorthand = { name };
+  SHORTHAND_CONFIGS.add(shorthand);
+  return new Xano().registerWorkspace(shorthand);
+}
+var SHORTHAND_CONFIGS = /* @__PURE__ */ new WeakSet();
+
+export {
+  refuseUnknown,
+  MCP_OAUTH_ENV_REF,
+  encodeMcpOauth,
+  checkFilterOperands,
+  XANO_ORIGIN,
+  standaloneDefKind,
+  Xano,
+  workspace
+};
+//# sourceMappingURL=chunk-CTMO46PK.js.map