@vxil/cli 0.8.0 → 0.10.0

package/dist/vxil.js

@@ -4044,9 +4044,12 @@ var PaymentsConfigSchema = Type.Object({
     //   { tier, durationDays }          (2026-09-25 F35+) a TIME-BOXED
     //     ENTITLEMENT: the buyer gets `tier` (a tierMap key — cross-checked
     //     below) for `durationDays`, as a charge-linked manual-style row that
-    //     STACKS on the user's live purchases of the same tier and is ENDED by
-    //     that charge's full refund / chargeback. No defaults in either shape,
-    //     so an existing manifest is byte-identical after Value.Default.
+    //     STACKS behind the user's live same-tier manual rows that have an end
+    //     (earlier passes AND comp grants since 2026-09-25 F38 — never a row
+    //     linked to the same charge, an open-ended grant or a provider
+    //     subscription) and is ENDED by that charge's full refund / chargeback.
+    //     No defaults in either shape, so an existing manifest is
+    //     byte-identical after Value.Default.
     productMap: Type.Record(Type.String(), Type.Union([
       Type.Object({
         creditType: Type.String({ minLength: 1 }),
@@ -4413,7 +4416,8 @@ function lowerAllTriggerBindings(def, name) {
 }
 var CONFIG_FILENAMES = ["vxil.config.ts", "vxil.config.mjs", "vxil.config.js"];
 var VXIL_CONFIG_PKG_VERSION = "0.6.0";
-var VXIL_SDK_PKG_VERSION = "0.8.0";
+var VXIL_SDK_PKG_VERSION = "0.10.0";
+var VXIL_CLI_PKG_VERSION = "0.10.0";
 function ensureScaffoldPackageJson(cwd, opts = {}) {
   const file = resolve(cwd, "package.json");
   const wanted = {
@@ -4614,13 +4618,11 @@ function makeApi({ apiKey, baseUrl, fetchImpl = fetch, retries = 4, sleep, apiVe
         continue;
       }
       const text = await res.text();
-      let json2;
       try {
-        json2 = JSON.parse(text);
+        return { status: res.status, body: JSON.parse(text) };
       } catch {
-        json2 = { error: { code: `http_${res.status}`, message: text.slice(0, 200) } };
+        return { status: res.status, body: { error: { code: `http_${res.status}`, message: text.slice(0, 200) } }, raw: text };
       }
-      return { status: res.status, body: json2 };
     }
   };
 }
@@ -7052,6 +7054,10 @@ function scopesForFunctionAudience(aud, scopes) {
 }
 var TENANT_SLUG_RE = /^[a-z0-9][a-z0-9-]{1,62}$/;
 var FUNCTION_SOURCE_MAX_BYTES = 512e3;
+var FUNCTIONS_RUNTIME = {
+  compatibilityDate: "2025-09-01",
+  compatibilityFlags: []
+};
 
 // ../runtime/src/hash.ts
 async function sha256Hex(input) {
@@ -7199,6 +7205,9 @@ async function signJobsCallbackWithTenantSecret(tenantSecret, params) {
   return `t=${t},v1=${v1}`;
 }
 
+// ../runtime/src/directLane.ts
+var DIRECT_FN_DECLARED_MAX_MS = 3e4;
+
 // src/apiState.ts
 var POLICY_LIST_CAP = 100;
 var CAMPAIGN_LIST_CAP = 200;
@@ -7676,7 +7685,10 @@ async function bundleFunction(entryPath, opts = {}) {
     format: "esm",
     platform: "browser",
     // Workers runtime (Web-standard globals; no node builtins)
-    target: "es2022",
+    // The runtime runs ES2024 natively (2026-09-25: was es2022 — every
+    // template function bundled byte-identical at both, so nothing redeployed;
+    // a function using post-ES2022 syntax now ships it as written).
+    target: "es2024",
     write: false,
     legalComments: "none",
     minify: min,
@@ -7861,7 +7873,7 @@ function formatFunctionsPreflight(e, opts) {
   }
   const plan = /'([a-z]+)' plan/.exec(e.message ?? "")?.[1];
   const planLabel = plan ? `the ${plan[0].toUpperCase()}${plan.slice(1)} plan` : "a paid plan";
-  return `functions need ${planLabel}${e.message ? ` (${e.message})` : ""} \u2014 ${n} would be refused with 402 tier_required. Upgrade in the dashboard (${billingPageFor(opts.tenantId, opts.baseUrl)})` + (opts.verb === "push" ? ", or run `vxil push --skip-functions` to push the cms schema and feature config without them" : "") + ".";
+  return `functions need ${planLabel}${e.message ? ` (${e.message})` : ""} \u2014 ${n} would be refused with 402 tier_required. Upgrade in the dashboard (${billingPageFor(opts.tenantId, opts.baseUrl)}) or with \`vxil billing upgrade --tier ${plan ?? "<tier>"}\` (it needs your dashboard session \u2014 \`vxil login\` \u2014 not the project key)` + (opts.verb === "push" ? ", or run `vxil push --skip-functions` to push the cms schema and feature config without them" : "") + ".";
 }
 function formatLogLines(lines) {
   const out = [];
@@ -8340,25 +8352,101 @@ function formatCollectionDrop(collection, plan, declaredLocally) {
 // src/apiCmd.ts
 var API_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
 var API_USAGE = "usage: vxil api <GET|POST|PUT|PATCH|DELETE> </v1/...> ['<json body>' | --data '<json body>']  (`vxil api --help` lists the operator actions)";
-function parseApiArgs(positionals, dataFlag) {
-  const [rawMethod, path, ...extra] = positionals;
-  const method = (rawMethod ?? "").toUpperCase();
-  if (!rawMethod || !API_METHODS.includes(method)) throw new Error(API_USAGE);
-  if (!path || !path.startsWith("/")) throw new Error(API_USAGE);
+function parseJsonBodyArg(extra, dataFlag, o) {
   const positionalBody = extra[0];
-  if (extra.length > 1) throw new Error(`${API_USAGE} \u2014 too many arguments (${extra.length} after the path; quote the JSON body as ONE argument)`);
+  if (extra.length > 1) throw new Error(`${o.usage} \u2014 too many arguments (${extra.length} after ${o.after}; quote the JSON body as ONE argument)`);
   if (positionalBody !== void 0 && dataFlag !== void 0) {
-    throw new Error("pass the body either as the third argument or with --data, not both");
+    throw new Error(`pass the body either as ${o.argName} or with --data, not both`);
   }
   const raw = positionalBody ?? dataFlag;
-  if (raw === void 0) return { method, path };
+  if (raw === void 0) return {};
   try {
-    return { method, path, body: JSON.parse(raw) };
+    return { body: JSON.parse(raw) };
   } catch {
     const via = positionalBody !== void 0 ? "the body argument" : "--data";
     throw new Error(`${via} must be valid JSON (got ${JSON.stringify(raw.length > 60 ? `${raw.slice(0, 57)}\u2026` : raw)})`);
   }
 }
+function parseApiArgs(positionals, dataFlag) {
+  const [rawMethod, path, ...extra] = positionals;
+  const method = (rawMethod ?? "").toUpperCase();
+  if (!rawMethod || !API_METHODS.includes(method)) throw new Error(API_USAGE);
+  if (!path || !path.startsWith("/")) throw new Error(API_USAGE);
+  const { body } = parseJsonBodyArg(extra, dataFlag, { usage: API_USAGE, after: "the path", argName: "the third argument" });
+  return body === void 0 ? { method, path } : { method, path, body };
+}
+var VALUE_NOUN = { target: "a slot name" };
+function looksLikeJson(t) {
+  const c = t.trimStart()[0];
+  return c === "{" || c === "[" || c === '"';
+}
+function scanBodyVerbArgv(argv, spec) {
+  const positionals = [];
+  const values2 = {};
+  const booleans = [];
+  for (let i = 0; i < argv.length; i++) {
+    const t = argv[i];
+    if (!t.startsWith("--")) {
+      positionals.push(t);
+      continue;
+    }
+    const flagName = t.slice(2);
+    const next = argv[i + 1];
+    if (spec.booleans.has(flagName)) {
+      if (!booleans.includes(flagName)) booleans.push(flagName);
+      continue;
+    }
+    if (spec.values.has(flagName)) {
+      if (next === void 0 || next.startsWith("--")) {
+        if (flagName === "data") throw new Error(`--data needs a value \u2014 ${spec.usage}`);
+        continue;
+      }
+      if (flagName !== "data" && looksLikeJson(next)) {
+        throw new Error(`'${t}' needs ${VALUE_NOUN[flagName] ?? "a value"}, not the JSON body \u2014 ${spec.usage}`);
+      }
+      values2[flagName] = next;
+      i++;
+      continue;
+    }
+    if (next !== void 0 && !next.startsWith("--")) {
+      if (looksLikeJson(next)) {
+        throw new Error(`'${t}' is followed by the JSON body and would take it as its value \u2014 put the body ${spec.bodyPlace}, or pass it with --data`);
+      }
+      i++;
+    }
+  }
+  return { positionals, values: values2, booleans };
+}
+var API_BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["json", "dev", "yes", "help"]);
+var API_VALUE_FLAGS = /* @__PURE__ */ new Set(["data", "target"]);
+function parseApiArgv(argv) {
+  const { positionals, values: values2 } = scanBodyVerbArgv(argv, {
+    booleans: API_BOOLEAN_FLAGS,
+    values: API_VALUE_FLAGS,
+    usage: API_USAGE,
+    bodyPlace: "right after the path"
+  });
+  return parseApiArgs(positionals, values2.data);
+}
+var INVOKE_USAGE = "usage: vxil functions invoke <name> ['<json body>' | --data '<json body>'] [--async] [--dev | --target <name>]";
+var INVOKE_BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["async", "json", "dev", "yes", "help"]);
+var INVOKE_VALUE_FLAGS = /* @__PURE__ */ new Set(["data", "target"]);
+function parseInvokeArgs(argv) {
+  const { positionals, values: values2, booleans } = scanBodyVerbArgv(argv, {
+    booleans: INVOKE_BOOLEAN_FLAGS,
+    values: INVOKE_VALUE_FLAGS,
+    usage: INVOKE_USAGE,
+    bodyPlace: "right after the function name"
+  });
+  const [sub, name, ...extra] = positionals;
+  if (sub !== "invoke" || !name) throw new Error(INVOKE_USAGE);
+  const { body } = parseJsonBodyArg(extra, values2.data, {
+    usage: INVOKE_USAGE,
+    after: "the function name",
+    argName: "the argument after the function name"
+  });
+  return { name, body: body === void 0 ? {} : body, async: booleans.includes("async") };
+}
 var API_CHEATSHEET = [
   // cms
   { feature: "cms", what: "materialize a declared read model now", cmd: "vxil api POST /v1/cms/read-models/<name>/materialize" },
@@ -8432,8 +8520,10 @@ function apiCheatSheet() {
     API_USAGE,
     "",
     "Calls any /v1 route with the bound project key (--dev / --target <name> pick the slot). The body is the third",
-    "argument OR --data, never both; the response `data` prints as bare JSON on stdout (`| jq` works), the target",
-    "banner goes to stderr; a GET prints no banner. Exit 1 on an error envelope.",
+    "argument OR --data, never both, and a flag between the path and the body never takes it (an unknown one there",
+    "is refused); the response `data` prints as bare JSON on stdout (`| jq` works; a body with",
+    "no `data` key \u2014 a function's own answer on /v1/fn/<name> \u2014 prints whole), the target banner goes to stderr;",
+    "a GET prints no banner. Exit 1 on an error envelope or any non-2xx status.",
     "",
     "Operator actions from the CLI \u2014 the dashboard's per-feature actions and the line that does each one:"
   ];
@@ -8454,190 +8544,714 @@ function apiCheatSheet() {
   return lines.join("\n");
 }
 
-// src/link.ts
-function data(r) {
-  return r.json.data ?? r.json;
+// src/envelopeOutput.ts
+var DEFAULT_IO = {
+  out: (t) => console.log(t),
+  err: (l) => console.error(l),
+  exit: (c) => process.exit(c)
+};
+var RAW_ERROR_MAX_CHARS = 2e3;
+var is2xx = (status) => status >= 200 && status < 300;
+function isRecord(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
 }
-function errText(r) {
-  const e = r.json.error;
-  if (!e) return `${r.status}`;
-  return `${e.code ?? r.status}${e.message ? ` \u2014 ${e.message}` : ""}${e.hint ? `
-hint: ${e.hint}` : ""}`;
+function errorEnvelopeOf(body) {
+  if (!isRecord(body) || !isRecord(body.error) || typeof body.error.code !== "string") return null;
+  const e = body.error;
+  return {
+    code: e.code,
+    ...typeof e.message === "string" ? { message: e.message } : {},
+    ...typeof e.hint === "string" ? { hint: e.hint } : {}
+  };
 }
-async function findTenantViaSession(dash, cookie, slug) {
-  const list = await dash("GET", "/dashboard/tenants", void 0, cookie);
-  if (list.status === 401) return { unauthorized: true };
-  if (list.status !== 200) throw new Error(`could not list projects (${errText(list)})`);
-  const tenants = data(list).tenants ?? [];
-  const t = tenants.find((x) => x.slug === slug);
-  if (!t) {
-    throw new Error(
-      `no project '${slug}' on this account \u2014 run \`vxil quickstart\`, or ask an admin to add you as a member`
-    );
-  }
-  return { tenant: t };
+function envelopeLines(status, e) {
+  return [
+    `error ${status}: ${e.code}${e.message !== void 0 ? ` \u2014 ${e.message}` : ""}`,
+    ...e.hint !== void 0 ? [`hint: ${e.hint}`] : []
+  ];
 }
-async function linkViaSession(dash, cookie, slug, keyName) {
-  const found = await findTenantViaSession(dash, cookie, slug);
-  if ("unauthorized" in found) return found;
-  const t = found.tenant;
-  const mint = await dash("POST", `/dashboard/tenants/${t.id}/api-keys`, { name: keyName }, cookie);
-  if (mint.status === 401) return { unauthorized: true };
-  if (mint.status !== 201 && mint.status !== 200) {
-    throw new Error(`could not mint a key for '${slug}' (${errText(mint)})`);
-  }
-  const apiKey = data(mint).api_key;
-  if (!apiKey) throw new Error("mint returned no api_key");
-  return { result: { slug, tenant_id: t.id, api_key: apiKey } };
+var pretty = (v) => JSON.stringify(v, null, 2) ?? String(v);
+function clip(text) {
+  return text.length > RAW_ERROR_MAX_CHARS ? `${text.slice(0, RAW_ERROR_MAX_CHARS)}\u2026 (${text.length - RAW_ERROR_MAX_CHARS} more characters)` : text;
+}
+function formatEnvelope(res, opts = {}) {
+  if (opts.rawText && res.raw !== void 0 && is2xx(res.status)) return { stdout: res.raw, stderr: [], exitCode: 0 };
+  const e = errorEnvelopeOf(res.body);
+  if (e) return { stderr: envelopeLines(res.status, e), exitCode: 1 };
+  if (!is2xx(res.status)) return { stderr: [`error ${res.status}:`, pretty(res.body)], exitCode: 1 };
+  const b2 = res.body;
+  const envelopeData = isRecord(b2) && "data" in b2 && (b2.error === void 0 || b2.error === null);
+  return { stdout: pretty(envelopeData ? b2.data : b2), stderr: [], exitCode: 0 };
+}
+function formatFnAnswer(name, res) {
+  if (is2xx(res.status)) {
+    if (res.raw !== void 0) return { stdout: res.raw, stderr: [], exitCode: 0 };
+    const b2 = res.body;
+    const data2 = isRecord(b2) ? b2.data : void 0;
+    return { stdout: pretty(data2 ?? b2), stderr: [], exitCode: 0 };
+  }
+  const hint = errorEnvelopeOf(res.body)?.hint;
+  return {
+    stderr: [
+      `error ${res.status} from function '${name}':`,
+      res.raw !== void 0 ? clip(res.raw) : pretty(res.body),
+      ...hint !== void 0 ? [`hint: ${hint}`] : []
+    ],
+    exitCode: 1
+  };
 }
-async function linkViaDeviceFlow(dash, slug, io) {
-  const now = io.now ?? Date.now;
-  const start = await dash("POST", "/dashboard/cli/link", { slug });
-  if (start.status !== 201 && start.status !== 200) {
-    throw new Error(`could not start the link (${errText(start)})`);
-  }
-  const d = data(start);
-  if (!d.device_code || !d.user_code) throw new Error("link start returned no device_code");
-  io.log("");
-  io.log(`To link '${slug}', approve this request in your browser:`);
-  io.log("");
-  io.log(`  ${d.verification_uri_complete ?? d.verification_uri ?? "(open the dashboard \u2192 CLI link)"}`);
-  io.log(`  code: ${d.user_code}`);
-  io.log("");
-  io.log("Waiting for approval (Ctrl-C to cancel)\u2026");
-  const intervalMs = Math.max(1, d.interval ?? 5) * 1e3;
-  const deadline = now() + Math.max(1, d.expires_in ?? 900) * 1e3;
-  while (now() < deadline) {
-    await io.sleep(intervalMs);
-    const poll = await dash("POST", "/dashboard/cli/link/token", { device_code: d.device_code });
-    if (poll.status === 428) continue;
-    if (poll.status === 200) {
-      const p = data(poll);
-      if (!p.api_key || !p.tenant_id) throw new Error("approval returned no api_key");
-      return { slug: p.slug || slug, tenant_id: p.tenant_id, api_key: p.api_key };
-    }
-    throw new Error(`link failed (${errText(poll)})`);
-  }
-  throw new Error("link timed out waiting for browser approval \u2014 run `vxil link <slug>` again");
+function emitOutput(o, io = DEFAULT_IO) {
+  if (o.stdout !== void 0) io.out(o.stdout);
+  for (const l of o.stderr) io.err(l);
+  if (o.exitCode !== 0) io.exit(o.exitCode);
 }
-async function linkViaStoredKey(api, slug, storedKey) {
-  let res;
-  try {
-    res = await api("GET", "/v1/features");
-  } catch (e2) {
-    return { invalid: `could not reach the edge (${e2.message})` };
-  }
-  if (res.status === 200) {
-    const tenantId = res.body.meta?.tenant_id;
-    return { result: { slug, tenant_id: tenantId && tenantId.length ? tenantId : "(unknown)", api_key: storedKey } };
-  }
-  const e = res.body.error;
-  return { invalid: `${e?.code ?? res.status}${e?.message ? ` \u2014 ${e.message}` : ""}` };
+function printEnvelope(res, io = DEFAULT_IO) {
+  emitOutput(formatEnvelope(res), io);
 }
 
-// src/members.ts
-var MEMBER_ROLES = ["viewer", "developer", "admin", "owner"];
-function parseMemberRole(raw) {
-  if (raw === void 0 || !raw.trim()) return { error: `--role is required \u2014 one of ${MEMBER_ROLES.join("|")}` };
-  const r = raw.trim();
-  if (!MEMBER_ROLES.includes(r)) {
-    return { error: `--role must be one of ${MEMBER_ROLES.join("|")} (got '${r}')` };
+// src/store.ts
+import { homedir as homedir2 } from "node:os";
+import { join as join2, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2, chmodSync } from "node:fs";
+function dashboardOrigin(base2) {
+  try {
+    return new URL(base2).origin.toLowerCase();
+  } catch {
+    return base2.trim().replace(/\/+$/, "").toLowerCase();
   }
-  return { role: r };
 }
-function parseMemberEmail(raw) {
-  const e = (raw ?? "").trim();
-  if (!e || !e.includes("@")) return { error: "an e-mail address is required, e.g. vxil members invite ada@example.com --role developer" };
-  return { email: e };
+function storedSessionFor(creds, dashBase) {
+  if (!creds.session) return { session: null, reason: "no-session" };
+  if (!creds.session_host) return { session: null, reason: "unbound" };
+  const host = dashboardOrigin(creds.session_host);
+  if (host !== dashboardOrigin(dashBase)) return { session: null, reason: "other-host", host };
+  return { session: creds.session, host };
 }
-function parseInviteToken(raw) {
-  const s = (raw ?? "").trim();
-  if (!s) return { error: "usage: vxil invites accept <token | invite-url> [--json] \u2014 the token from the invitation e-mail" };
-  if (/^https?:\/\//i.test(s)) {
-    try {
-      const t = new URL(s).searchParams.get("token");
-      if (t && t.trim()) return { token: t.trim() };
-    } catch {
-    }
-    return { error: "that URL carries no ?token= \u2014 paste the invitation link from the e-mail, or the token itself" };
-  }
-  return { token: s };
+function sessionNotForTarget(s, target) {
+  if (s.reason === "other-host") return `the stored dashboard session belongs to ${s.host}, not this target (${dashboardOrigin(target)}) \u2014 run \`vxil login\` against this target to use it here`;
+  if (s.reason === "unbound") return `the stored dashboard session has no recorded host (written by an older CLI) and is not sent anywhere \u2014 run \`vxil login\` again to bind it`;
+  return "no dashboard session \u2014 run `vxil login`";
 }
-async function listMembersViaSession(dash, cookie, tenantId) {
-  const m = await dash("GET", `/dashboard/tenants/${tenantId}/members`, void 0, cookie);
-  if (m.status === 401) return { unauthorized: true };
-  if (m.status !== 200) throw new Error(`could not list the members (${errText(m)})`);
-  const p = await dash("GET", `/dashboard/tenants/${tenantId}/members/pending`, void 0, cookie);
-  if (p.status === 401) return { unauthorized: true };
-  const invites = p.status === 200 ? data(p).invites ?? [] : [];
-  return { members: data(m).members ?? [], invites };
+function credDir() {
+  return join2(homedir2(), ".vxil");
 }
-function inviteExpired(row2, now = Date.now()) {
-  const t = Date.parse(row2.expires_at);
-  return Number.isFinite(t) && t <= now;
+function credFile() {
+  return join2(credDir(), "credentials.json");
 }
-function renderMembers(members, invites, now = Date.now()) {
-  const lines = [];
-  if (!members.length) lines.push("(no members)");
-  for (const m of members) {
-    lines.push(`${m.role.padEnd(9)} ${m.email}${m.display_name ? ` (${m.display_name})` : ""}  ${m.user_id}`);
-  }
-  if (invites.length) {
-    lines.push("");
-    lines.push(`pending invitations (${invites.length}):`);
-    for (const i of invites) {
-      const state = inviteExpired(i, now) ? "EXPIRED" : `expires ${i.expires_at}`;
-      lines.push(`  ${i.role.padEnd(9)} ${i.email}  ${i.id}  ${state}`);
-    }
+function loadCredentials() {
+  try {
+    return JSON.parse(readFileSync3(credFile(), "utf8"));
+  } catch {
+    return {};
   }
-  return lines;
 }
-async function inviteMemberViaSession(dash, cookie, tenantId, req) {
-  const r = await dash("POST", `/dashboard/tenants/${tenantId}/members/invite`, { email: req.email, role: req.role }, cookie);
-  if (r.status === 401) return { unauthorized: true };
-  if (r.status !== 202 && r.status !== 200 && r.status !== 201) {
-    throw new Error(`could not invite ${req.email} (${errText(r)})`);
+function saveCredentials(c) {
+  mkdirSync(credDir(), { recursive: true });
+  writeFileSync2(credFile(), JSON.stringify(c, null, 2));
+  try {
+    chmodSync(credFile(), 384);
+  } catch {
   }
-  const d = data(r);
-  return { email: d.email ?? req.email, role: d.role ?? req.role };
-}
-async function addMemberViaSession(dash, cookie, tenantId, req) {
-  const r = await dash("POST", `/dashboard/tenants/${tenantId}/members`, { email: req.email, role: req.role }, cookie);
-  if (r.status === 401) return { unauthorized: true };
-  if (r.status !== 201 && r.status !== 200) throw new Error(`could not add ${req.email} (${errText(r)})`);
-  const d = data(r);
-  if (!d.user_id) throw new Error("the add returned no user_id");
-  return { user_id: d.user_id, role: d.role ?? req.role };
 }
-function findMember(members, ref) {
-  const r = ref.trim();
-  const byId = members.find((m) => m.user_id === r);
-  if (byId) return byId;
-  const lower = r.toLowerCase();
-  return members.find((m) => m.email.toLowerCase() === lower) ?? null;
+function projectFile(cwd = process.cwd()) {
+  return resolve3(cwd, ".vxil", "project.json");
 }
-async function removeMemberViaSession(dash, cookie, tenantId, userId) {
-  const r = await dash("DELETE", `/dashboard/tenants/${tenantId}/members/${encodeURIComponent(userId)}`, void 0, cookie);
-  if (r.status === 401) return { unauthorized: true };
-  if (r.status !== 200 && r.status !== 204) throw new Error(`could not remove the member (${errText(r)})`);
-  return { removed: userId };
+function loadProject(cwd = process.cwd()) {
+  try {
+    return JSON.parse(readFileSync3(projectFile(cwd), "utf8"));
+  } catch {
+    return null;
+  }
 }
-function findPendingInvite(invites, ref) {
-  const r = ref.trim();
-  const byId = invites.find((i) => i.id === r);
-  if (byId) return byId;
-  const lower = r.toLowerCase();
-  return invites.find((i) => i.email.toLowerCase() === lower) ?? null;
+function saveProject(binding, cwd = process.cwd()) {
+  const dir = resolve3(cwd, ".vxil");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync2(projectFile(cwd), JSON.stringify(binding, null, 2));
 }
-async function revokeInviteViaSession(dash, cookie, tenantId, inviteId) {
-  const r = await dash("DELETE", `/dashboard/tenants/${tenantId}/members/pending/${encodeURIComponent(inviteId)}`, void 0, cookie);
-  if (r.status === 401) return { unauthorized: true };
-  if (r.status !== 200) throw new Error(`could not revoke the invitation (${errText(r)})`);
-  const d = data(r);
-  return { revoked: d.revoked ?? inviteId };
+function envLabelFor(base2) {
+  try {
+    return /(^|\.)api\.vxil\.com$/.test(new URL(base2).hostname) ? "production" : "staging";
+  } catch {
+    return "staging";
+  }
 }
-async function lookupInvite(dash, token) {
-  const r = await dash("GET", `/dashboard/invites/pending?token=${encodeURIComponent(token)}`);
+function mergePrimaryBinding(existing, primary) {
+  const { ephemeral: _e, expires_at: _x, ...keep } = existing ?? {};
+  void _e;
+  void _x;
+  return {
+    ...keep,
+    tenant_id: primary.tenant_id,
+    slug: primary.slug,
+    edge_url: primary.edge_url,
+    ...primary.env !== void 0 ? { env: primary.env } : {}
+  };
+}
+function bindNamedSlot(existing, name, slot) {
+  if (!existing) {
+    throw new Error(
+      `no project bound in this directory yet \u2014 run \`vxil link <slug>\` (or \`vxil quickstart\`) first, then \`vxil link <other-slug> --as ${name}\``
+    );
+  }
+  if (name === "dev") {
+    return {
+      ...existing,
+      dev: {
+        tenant_id: slot.tenant_id,
+        slug: slot.slug,
+        edge_url: slot.edge_url,
+        ...slot.expires_at ? { expires_at: slot.expires_at } : {}
+      }
+    };
+  }
+  const { expires_at: _x, ...permanent } = slot;
+  void _x;
+  return { ...existing, targets: { ...existing.targets, [name]: permanent } };
+}
+var TARGET_NAME_RE = /^[a-z][a-z0-9-]{0,39}$/;
+function selectorFrom(flags) {
+  if (flags.target !== void 0) return { kind: "named", name: flags.target };
+  if (flags.dev) return { kind: "dev" };
+  return { kind: "primary" };
+}
+function describeSelector(sel) {
+  return sel.kind === "primary" ? "primary" : sel.kind === "dev" ? "--dev" : `--target ${sel.name}`;
+}
+var TargetUnboundError = class extends Error {
+  constructor(selector2, fix) {
+    super(
+      sel_msg(selector2) + ` \u2014 ${fix}`
+    );
+    this.selector = selector2;
+    this.fix = fix;
+    this.name = "TargetUnboundError";
+  }
+  selector;
+  fix;
+};
+function sel_msg(sel) {
+  if (sel.kind === "dev") return "no dev tenant is bound in .vxil/project.json";
+  if (sel.kind === "named") return `no target '${sel.name}' is bound in .vxil/project.json`;
+  return "no project is bound";
+}
+function resolve_target(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const proj = opts.project !== void 0 ? opts.project : loadProject(cwd);
+  const creds = opts.credentials ?? loadCredentials();
+  const env = opts.env ?? process.env;
+  const envKey = env.VXIL_API_KEY || void 0;
+  const envBase = env.VXIL_BASE_URL || void 0;
+  const selector2 = selectorFrom({ dev: opts.which === "dev", target: opts.target });
+  if (selector2.kind === "dev") {
+    const slot = proj?.dev;
+    if (!slot) {
+      throw new TargetUnboundError(
+        selector2,
+        "run `vxil dev up`, `vxil dev branch <name>`, or `vxil link <slug> --as dev` to bind one (the primary/production key is never used for --dev)"
+      );
+    }
+    const devKey = env.VXIL_DEV_KEY || void 0;
+    const stored = creds.keys?.[slot.slug];
+    const baseUrl2 = envBase ?? slot.edge_url ?? opts.defaultBase;
+    return {
+      apiKey: devKey ?? stored,
+      baseUrl: baseUrl2,
+      tenantSlug: slot.slug,
+      tenantId: slot.tenant_id,
+      slot: "dev",
+      envLabel: envLabelFor(baseUrl2),
+      keySource: devKey ? "VXIL_DEV_KEY" : stored ? "credentials" : "none",
+      selector: selector2
+    };
+  }
+  if (selector2.kind === "named") {
+    const name = selector2.name;
+    const slot = proj?.targets?.[name] ?? proj?.branches?.[name] ?? (name === "dev" ? proj?.dev : void 0);
+    if (!slot) {
+      throw new TargetUnboundError(
+        selector2,
+        `run \`vxil link <slug> --as ${name}\` to bind it (or \`vxil dev branch ${name}\` for an ephemeral one); the primary key is never substituted for a missing target`
+      );
+    }
+    const stored = creds.keys?.[slot.slug];
+    const baseUrl2 = envBase ?? slot.edge_url ?? opts.defaultBase;
+    return {
+      apiKey: stored,
+      baseUrl: baseUrl2,
+      tenantSlug: slot.slug,
+      tenantId: slot.tenant_id,
+      slot: "named",
+      slotName: name,
+      envLabel: slot.env ?? envLabelFor(baseUrl2),
+      keySource: stored ? "credentials" : "none",
+      selector: selector2
+    };
+  }
+  if (envKey) {
+    const baseUrl2 = envBase ?? proj?.edge_url ?? opts.defaultBase;
+    return {
+      apiKey: envKey,
+      baseUrl: baseUrl2,
+      tenantSlug: proj?.slug,
+      tenantId: proj?.tenant_id,
+      slot: proj ? "primary" : "env",
+      envLabel: proj?.env ?? envLabelFor(baseUrl2),
+      keySource: "VXIL_API_KEY",
+      selector: selector2
+    };
+  }
+  if (proj) {
+    const key = creds.keys?.[proj.slug];
+    const baseUrl2 = envBase ?? proj.edge_url ?? opts.defaultBase;
+    return {
+      apiKey: key,
+      baseUrl: baseUrl2,
+      tenantSlug: proj.slug,
+      tenantId: proj.tenant_id,
+      slot: "primary",
+      envLabel: proj.env ?? envLabelFor(baseUrl2),
+      keySource: key ? "credentials" : "none",
+      selector: selector2
+    };
+  }
+  const baseUrl = envBase ?? opts.defaultBase;
+  return {
+    apiKey: void 0,
+    baseUrl,
+    tenantSlug: void 0,
+    tenantId: void 0,
+    slot: "none",
+    envLabel: envLabelFor(baseUrl),
+    keySource: "none",
+    selector: selector2
+  };
+}
+function targetBanner(t, verb) {
+  const host = (() => {
+    try {
+      return new URL(t.baseUrl).host;
+    } catch {
+      return t.baseUrl;
+    }
+  })();
+  const slot = t.slot === "named" ? `target '${t.slotName}'` : t.slot === "dev" ? "dev slot" : t.slot === "env" ? "VXIL_API_KEY (no project binding)" : t.slot === "primary" ? "primary" : "unbound";
+  const tenant = t.tenantSlug ? `tenant '${t.tenantSlug}'` : "tenant (unknown slug)";
+  return `vxil ${verb} \u2192 ${tenant} \xB7 ${t.envLabel.toUpperCase()} \xB7 ${host} [${slot}]`;
+}
+function bindingSlots(proj) {
+  if (!proj) return [];
+  const out = [
+    { label: "primary", slug: proj.slug, tenant_id: proj.tenant_id, edge_url: proj.edge_url }
+  ];
+  const seen = /* @__PURE__ */ new Set([proj.slug]);
+  const push = (label, s) => {
+    if (seen.has(s.slug)) return;
+    seen.add(s.slug);
+    out.push({ label, slug: s.slug, tenant_id: s.tenant_id, edge_url: s.edge_url });
+  };
+  if (proj.dev) push("dev", proj.dev);
+  for (const [n, s] of Object.entries(proj.targets ?? {})) push(`target:${n}`, s);
+  for (const [n, s] of Object.entries(proj.branches ?? {})) push(`branch:${n}`, s);
+  return out;
+}
+
+// src/promotionGate.ts
+var NON_PRODUCTION_ENV_LABELS = /* @__PURE__ */ new Set([
+  "staging",
+  "stage",
+  "dev",
+  "development",
+  "test",
+  "qa",
+  "preview",
+  "sandbox",
+  "local"
+]);
+function normalizeLabel(label) {
+  return label.trim().toLowerCase();
+}
+function isNonProductionLabel(label) {
+  return NON_PRODUCTION_ENV_LABELS.has(normalizeLabel(label));
+}
+function isDevSlot(t) {
+  return t.slot === "dev" || t.slot === "named" && t.selector.kind === "named" && t.selector.name === "dev";
+}
+function isProductionTarget(t) {
+  if (isDevSlot(t)) return false;
+  if (normalizeLabel(t.envLabel) === "production") return true;
+  return envLabelFor(t.baseUrl) === "production" && !isNonProductionLabel(t.envLabel);
+}
+function hostOf(baseUrl) {
+  try {
+    return new URL(baseUrl).host;
+  } catch {
+    return baseUrl;
+  }
+}
+function unrecognizedLabelNotice(t) {
+  if (isDevSlot(t)) return null;
+  if (normalizeLabel(t.envLabel) === "production") return null;
+  if (envLabelFor(t.baseUrl) !== "production") return null;
+  if (isNonProductionLabel(t.envLabel)) return null;
+  return `env label '${t.envLabel}' is not a recognized environment and the host is ${hostOf(t.baseUrl)} \u2014 treating this target as PRODUCTION (use --env staging|dev|test|qa|preview|sandbox|local to say otherwise)`;
+}
+function envLabelWarning(label, baseUrl) {
+  const l = normalizeLabel(label);
+  const host = hostOf(baseUrl);
+  if (envLabelFor(baseUrl) === "production") {
+    if (l === "production") return null;
+    if (isNonProductionLabel(l)) {
+      return `slot labelled '${label}' on the PRODUCTION host ${host} \u2014 the push promotion gate will NOT fire for it (the documented staging-twin pattern; re-link with --env production if this IS a production tenant)`;
+    }
+    return `env label '${label}' is not a recognized environment \u2014 on the PRODUCTION host ${host} it is treated as PRODUCTION (the push promotion gate WILL fire). Use production|staging|dev|test|qa|preview|sandbox|local.`;
+  }
+  if (l === "production") {
+    return `slot labelled 'production' on the non-production host ${host} \u2014 the push promotion gate WILL fire for it`;
+  }
+  return null;
+}
+function quickstartEnvNotice(envFlag, baseUrl, slug, opts = {}) {
+  if (envFlag !== void 0) return envLabelWarning(envFlag, baseUrl);
+  if (envLabelFor(baseUrl) !== "production") return null;
+  const label = opts.dev ? "dev" : "staging";
+  return `bound '${slug}' as 'production' \u2014 the host is ${hostOf(baseUrl)} and no --env was given, so \`vxil push\` runs the production promotion gate for it (mock/sandbox refusals, the typed confirmation). If this is a staging or dev project, relabel it now with \`vxil link ${slug} --env ${label}\` (it reuses the stored key), or next time run \`vxil quickstart --env ${label}\`.`;
+}
+function namedSlotConflict(existing, slug, as) {
+  if (existing?.slug !== slug) return null;
+  const why = `'${slug}' is already this repo's PRIMARY binding \u2014 a named slot must be a different tenant (one tenant in two slots would carry two labels, and whether the push promotion gate fires would depend on which slot you selected).`;
+  if (as === "dev") return `${why} For a disposable dev tenant beside it, run \`vxil dev up\`.`;
+  const label = isNonProductionLabel(as) ? as : "staging";
+  return `${why} To change the primary's label instead, re-link it: \`vxil link ${slug} --env ${label}\` (it reuses the stored key and keeps every other slot).`;
+}
+function isPlainObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function leafAt(manifest, dotted) {
+  let cur = manifest;
+  for (const seg of dotted.split(".")) {
+    if (!isPlainObject(cur)) return void 0;
+    cur = cur[seg];
+  }
+  return cur;
+}
+function mockFeatures(cfg) {
+  return Object.entries(cfg.features ?? {}).filter(([, conf]) => {
+    if (!isPlainObject(conf)) return false;
+    const c = conf;
+    return c.provider === "mock" || c.defaultProvider === "mock" || (isPlainObject(c.embed) ? c.embed.provider === "mock" : false);
+  }).map(([f]) => f);
+}
+var SANDBOX_LEAVES = [
+  { feature: "payments", path: "paddle.sandbox" },
+  { feature: "payments", path: "paypal.sandbox" },
+  { feature: "payments", path: "revenuecat.acceptSandbox" }
+];
+function sandboxFeatures(cfg) {
+  const out = [];
+  for (const leaf of SANDBOX_LEAVES) {
+    const manifest = (cfg.features ?? {})[leaf.feature];
+    if (leafAt(manifest, leaf.path) === true) out.push(`${leaf.feature}.${leaf.path}`);
+  }
+  return out;
+}
+function isDevHost(host) {
+  const h = host.toLowerCase().replace(/:\d+$/, "").replace(/^\[|\]$/g, "");
+  if (h === "localhost" || h.endsWith(".localhost")) return true;
+  if (h === "127.0.0.1" || h.startsWith("127.")) return true;
+  if (h === "::1") return true;
+  if (h === "local" || h.endsWith(".local")) return true;
+  if (/^10\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h)) return true;
+  if (/^192\.168\.\d{1,3}\.\d{1,3}$/.test(h)) return true;
+  if (/^172\.(1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}$/.test(h)) return true;
+  return false;
+}
+function devRedirectOrigins(origins = []) {
+  const out = [];
+  for (const raw of origins) {
+    if (typeof raw !== "string" || !raw) continue;
+    if (/^http:\/\//i.test(raw)) {
+      out.push(raw);
+      continue;
+    }
+    const host = raw.replace(/^[a-z][a-z0-9+.-]*:\/\//i, "").replace(/[/?#].*$/, "");
+    if (host && isDevHost(host)) out.push(raw);
+  }
+  return out;
+}
+function redirectOrigins(cfg) {
+  const v = leafAt((cfg.features ?? {}).auth, "security.allowedRedirectOrigins");
+  return Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+}
+var PROMOTION_OVERRIDE_FLAGS = {
+  mock: "allow-mock-in-prod",
+  sandbox: "allow-sandbox-in-prod",
+  origins: "allow-dev-origins-in-prod"
+};
+function promotionRefusals(cfg, allowed) {
+  const out = [];
+  const mocks = mockFeatures(cfg);
+  if (mocks.length && !allowed(PROMOTION_OVERRIDE_FLAGS.mock)) {
+    out.push({
+      kind: "mock",
+      flag: PROMOTION_OVERRIDE_FLAGS.mock,
+      message: `mock providers on [${mocks.join(", ")}] would ship to production (mock email/payments silently no-op). Set a real provider, or override with --${PROMOTION_OVERRIDE_FLAGS.mock}.`
+    });
+  }
+  const sandboxes = sandboxFeatures(cfg);
+  if (sandboxes.length && !allowed(PROMOTION_OVERRIDE_FLAGS.sandbox)) {
+    out.push({
+      kind: "sandbox",
+      flag: PROMOTION_OVERRIDE_FLAGS.sandbox,
+      message: `sandbox provider flags [${sandboxes.join(", ")}] would ship to a live money path (a sandbox key signs with the wrong secret; RevenueCat folds test purchases as outcome rejected_environment). Set them false, or override with --${PROMOTION_OVERRIDE_FLAGS.sandbox}.`
+    });
+  }
+  const devOrigins = devRedirectOrigins(redirectOrigins(cfg));
+  if (devOrigins.length && !allowed(PROMOTION_OVERRIDE_FLAGS.origins)) {
+    out.push({
+      kind: "origins",
+      flag: PROMOTION_OVERRIDE_FLAGS.origins,
+      message: `auth.security.allowedRedirectOrigins contains non-production origin(s) [${devOrigins.join(", ")}] \u2014 a loopback / .local / http:// redirect target on a production auth tenant is a token-exfiltration footgun. Remove them, or override with --${PROMOTION_OVERRIDE_FLAGS.origins}.`
+    });
+  }
+  return out;
+}
+function redirectOriginNotice(cfg) {
+  const origins = redirectOrigins(cfg);
+  if (!origins.length) return null;
+  return `auth.security.allowedRedirectOrigins (${origins.length}): ${origins.join(", ")}`;
+}
+
+// src/link.ts
+function data(r) {
+  return r.json.data ?? r.json;
+}
+function errText(r) {
+  const e = r.json.error;
+  if (!e) return `${r.status}`;
+  return `${e.code ?? r.status}${e.message ? ` \u2014 ${e.message}` : ""}${e.hint ? `
+hint: ${e.hint}` : ""}`;
+}
+async function findTenantViaSession(dash, cookie, slug) {
+  const list = await dash("GET", "/dashboard/tenants", void 0, cookie);
+  if (list.status === 401) return { unauthorized: true };
+  if (list.status !== 200) throw new Error(`could not list projects (${errText(list)})`);
+  const tenants = data(list).tenants ?? [];
+  const t = tenants.find((x) => x.slug === slug);
+  if (!t) {
+    throw new Error(
+      `no project '${slug}' on this account \u2014 run \`vxil quickstart\`, or ask an admin to add you as a member`
+    );
+  }
+  return { tenant: t };
+}
+async function linkViaSession(dash, cookie, slug, keyName) {
+  const found = await findTenantViaSession(dash, cookie, slug);
+  if ("unauthorized" in found) return found;
+  const t = found.tenant;
+  const mint = await dash("POST", `/dashboard/tenants/${t.id}/api-keys`, { name: keyName }, cookie);
+  if (mint.status === 401) return { unauthorized: true };
+  if (mint.status !== 201 && mint.status !== 200) {
+    throw new Error(`could not mint a key for '${slug}' (${errText(mint)})`);
+  }
+  const apiKey = data(mint).api_key;
+  if (!apiKey) throw new Error("mint returned no api_key");
+  return { result: { slug, tenant_id: t.id, api_key: apiKey } };
+}
+async function linkViaDeviceFlow(dash, slug, io) {
+  const now = io.now ?? Date.now;
+  const start = await dash("POST", "/dashboard/cli/link", { slug });
+  if (start.status !== 201 && start.status !== 200) {
+    throw new Error(`could not start the link (${errText(start)})`);
+  }
+  const d = data(start);
+  if (!d.device_code || !d.user_code) throw new Error("link start returned no device_code");
+  io.log("");
+  io.log(`To link '${slug}', approve this request in your browser:`);
+  io.log("");
+  io.log(`  ${d.verification_uri_complete ?? d.verification_uri ?? "(open the dashboard \u2192 CLI link)"}`);
+  io.log(`  code: ${d.user_code}`);
+  io.log("");
+  io.log("Waiting for approval (Ctrl-C to cancel)\u2026");
+  const intervalMs = Math.max(1, d.interval ?? 5) * 1e3;
+  const deadline = now() + Math.max(1, d.expires_in ?? 900) * 1e3;
+  while (now() < deadline) {
+    await io.sleep(intervalMs);
+    const poll = await dash("POST", "/dashboard/cli/link/token", { device_code: d.device_code });
+    if (poll.status === 428) continue;
+    if (poll.status === 200) {
+      const p = data(poll);
+      if (!p.api_key || !p.tenant_id) throw new Error("approval returned no api_key");
+      return { slug: p.slug || slug, tenant_id: p.tenant_id, api_key: p.api_key };
+    }
+    throw new Error(`link failed (${errText(poll)})`);
+  }
+  throw new Error("link timed out waiting for browser approval \u2014 run `vxil link <slug>` again");
+}
+function reconcileLinkTenant(flagTenant, verified) {
+  if (verified === "(unknown)") return { tenantId: flagTenant ?? "(unknown)" };
+  if (flagTenant !== void 0 && flagTenant !== verified) {
+    return {
+      error: `--tenant ${flagTenant} does not match the key's own tenant ${verified} (GET /v1/features meta.tenant_id) \u2014 nothing was linked. Check which key you passed, or drop --tenant to record the key's tenant.`
+    };
+  }
+  return { tenantId: verified };
+}
+function knownTenant(id) {
+  return typeof id === "string" && id.length > 0 && id !== "(unknown)";
+}
+function everySlot(p) {
+  const out = [{ id: "primary", where: "the primary binding", slug: p.slug, tenant_id: p.tenant_id }];
+  if (p.dev) out.push({ id: "dev", where: "the dev slot", slug: p.dev.slug, tenant_id: p.dev.tenant_id });
+  for (const [n, s] of Object.entries(p.targets ?? {})) out.push({ id: `target:${n}`, where: `target '${n}'`, slug: s.slug, tenant_id: s.tenant_id });
+  for (const [n, s] of Object.entries(p.branches ?? {})) out.push({ id: `branch:${n}`, where: `branch '${n}'`, slug: s.slug, tenant_id: s.tenant_id });
+  return out;
+}
+function planLinkBinding(existing, req) {
+  const { slug, tenantId, edgeUrl, env, as } = req;
+  if (as !== void 0 && !TARGET_NAME_RE.test(as)) {
+    return { error: `--as '${as}': a target name is 1\u201340 chars of [a-z0-9-], starting with a letter` };
+  }
+  const rewritten = as === void 0 ? "primary" : as === "dev" ? "dev" : `target:${as}`;
+  if (existing && knownTenant(tenantId)) {
+    const clash = everySlot(existing).find((s) => s.id !== rewritten && s.slug === slug && knownTenant(s.tenant_id) && s.tenant_id !== tenantId);
+    if (clash) {
+      return {
+        error: `'${slug}' already names tenant ${clash.tenant_id} in this repo (${clash.where}), and this key belongs to tenant ${tenantId}. API keys are stored per slug (~/.vxil/credentials.json), so storing this one would silently point ${clash.where} at the other tenant under its old label \u2014 nothing was linked. Bind the other tenant under its own slug: \`vxil link <its-slug> --key <key>${as !== void 0 ? ` --as ${as}` : ""}\`.`
+      };
+    }
+  }
+  if (as !== void 0) {
+    const conflict = namedSlotConflict(existing, slug, as);
+    if (conflict) return { error: conflict };
+    try {
+      const binding2 = bindNamedSlot(existing, as, { tenant_id: tenantId, slug, edge_url: edgeUrl, env });
+      return { binding: binding2, label: as === "dev" ? "as the dev slot (--dev)" : `as target '${as}' (--target ${as})` };
+    } catch (e) {
+      return { error: e.message };
+    }
+  }
+  const binding = mergePrimaryBinding(existing, { tenant_id: tenantId, slug, edge_url: edgeUrl, env });
+  const kept = bindingSlots(binding).slice(1).map((s) => s.label);
+  return { binding, label: kept.length ? `as the primary binding (kept: ${kept.join(", ")})` : "as the primary binding" };
+}
+async function linkViaStoredKey(api, slug, storedKey) {
+  let res;
+  try {
+    res = await api("GET", "/v1/features");
+  } catch (e2) {
+    return { invalid: `could not reach the edge (${e2.message})` };
+  }
+  if (res.status === 200) {
+    const tenantId = res.body.meta?.tenant_id;
+    return { result: { slug, tenant_id: tenantId && tenantId.length ? tenantId : "(unknown)", api_key: storedKey } };
+  }
+  const e = res.body.error;
+  return { invalid: `${e?.code ?? res.status}${e?.message ? ` \u2014 ${e.message}` : ""}` };
+}
+
+// src/members.ts
+var MEMBER_ROLES = ["viewer", "developer", "admin", "owner"];
+function parseMemberRole(raw) {
+  if (raw === void 0 || !raw.trim()) return { error: `--role is required \u2014 one of ${MEMBER_ROLES.join("|")}` };
+  const r = raw.trim();
+  if (!MEMBER_ROLES.includes(r)) {
+    return { error: `--role must be one of ${MEMBER_ROLES.join("|")} (got '${r}')` };
+  }
+  return { role: r };
+}
+function parseMemberEmail(raw) {
+  const e = (raw ?? "").trim();
+  if (!e || !e.includes("@")) return { error: "an e-mail address is required, e.g. vxil members invite ada@example.com --role developer" };
+  return { email: e };
+}
+function parseInviteToken(raw) {
+  const s = (raw ?? "").trim();
+  if (!s) return { error: "usage: vxil invites accept <token | invite-url> [--json] \u2014 the token from the invitation e-mail" };
+  if (/^https?:\/\//i.test(s)) {
+    try {
+      const t = new URL(s).searchParams.get("token");
+      if (t && t.trim()) return { token: t.trim() };
+    } catch {
+    }
+    return { error: "that URL carries no ?token= \u2014 paste the invitation link from the e-mail, or the token itself" };
+  }
+  return { token: s };
+}
+async function listMembersViaSession(dash, cookie, tenantId) {
+  const m = await dash("GET", `/dashboard/tenants/${tenantId}/members`, void 0, cookie);
+  if (m.status === 401) return { unauthorized: true };
+  if (m.status !== 200) throw new Error(`could not list the members (${errText(m)})`);
+  const p = await dash("GET", `/dashboard/tenants/${tenantId}/members/pending`, void 0, cookie);
+  if (p.status === 401) return { unauthorized: true };
+  const invites = p.status === 200 ? data(p).invites ?? [] : [];
+  return { members: data(m).members ?? [], invites };
+}
+function inviteExpired(row2, now = Date.now()) {
+  const t = Date.parse(row2.expires_at);
+  return Number.isFinite(t) && t <= now;
+}
+function renderMembers(members, invites, now = Date.now()) {
+  const lines = [];
+  if (!members.length) lines.push("(no members)");
+  for (const m of members) {
+    lines.push(`${m.role.padEnd(9)} ${m.email}${m.display_name ? ` (${m.display_name})` : ""}  ${m.user_id}`);
+  }
+  if (invites.length) {
+    lines.push("");
+    lines.push(`pending invitations (${invites.length}):`);
+    for (const i of invites) {
+      const state = inviteExpired(i, now) ? "EXPIRED" : `expires ${i.expires_at}`;
+      lines.push(`  ${i.role.padEnd(9)} ${i.email}  ${i.id}  ${state}`);
+    }
+  }
+  return lines;
+}
+async function inviteMemberViaSession(dash, cookie, tenantId, req) {
+  const r = await dash("POST", `/dashboard/tenants/${tenantId}/members/invite`, { email: req.email, role: req.role }, cookie);
+  if (r.status === 401) return { unauthorized: true };
+  if (r.status !== 202 && r.status !== 200 && r.status !== 201) {
+    throw new Error(`could not invite ${req.email} (${errText(r)})`);
+  }
+  const d = data(r);
+  return { email: d.email ?? req.email, role: d.role ?? req.role };
+}
+async function addMemberViaSession(dash, cookie, tenantId, req) {
+  const r = await dash("POST", `/dashboard/tenants/${tenantId}/members`, { email: req.email, role: req.role }, cookie);
+  if (r.status === 401) return { unauthorized: true };
+  if (r.status !== 201 && r.status !== 200) throw new Error(`could not add ${req.email} (${errText(r)})`);
+  const d = data(r);
+  if (!d.user_id) throw new Error("the add returned no user_id");
+  return { user_id: d.user_id, role: d.role ?? req.role };
+}
+function findMember(members, ref) {
+  const r = ref.trim();
+  const byId = members.find((m) => m.user_id === r);
+  if (byId) return byId;
+  const lower = r.toLowerCase();
+  return members.find((m) => m.email.toLowerCase() === lower) ?? null;
+}
+async function removeMemberViaSession(dash, cookie, tenantId, userId) {
+  const r = await dash("DELETE", `/dashboard/tenants/${tenantId}/members/${encodeURIComponent(userId)}`, void 0, cookie);
+  if (r.status === 401) return { unauthorized: true };
+  if (r.status !== 200 && r.status !== 204) throw new Error(`could not remove the member (${errText(r)})`);
+  return { removed: userId };
+}
+function findPendingInvite(invites, ref) {
+  const r = ref.trim();
+  const byId = invites.find((i) => i.id === r);
+  if (byId) return byId;
+  const lower = r.toLowerCase();
+  return invites.find((i) => i.email.toLowerCase() === lower) ?? null;
+}
+async function revokeInviteViaSession(dash, cookie, tenantId, inviteId) {
+  const r = await dash("DELETE", `/dashboard/tenants/${tenantId}/members/pending/${encodeURIComponent(inviteId)}`, void 0, cookie);
+  if (r.status === 401) return { unauthorized: true };
+  if (r.status !== 200) throw new Error(`could not revoke the invitation (${errText(r)})`);
+  const d = data(r);
+  return { revoked: d.revoked ?? inviteId };
+}
+async function lookupInvite(dash, token) {
+  const r = await dash("GET", `/dashboard/invites/pending?token=${encodeURIComponent(token)}`);
   if (r.status !== 200) return { refused: errText(r) };
   const d = data(r);
   return {
@@ -9094,24 +9708,269 @@ function parseUsersFile(text, filename) {
       const name = nameCol >= 0 ? cells[nameCol] : void 0;
       users.push({ id, ...email ? { email } : {}, ...name ? { display_name: name } : {} });
     }
-    return { users };
+    return { users };
+  }
+  return { error: `${filename}: expected a .json or .csv file` };
+}
+var USERS_IMPORT_CHUNK = 100;
+async function importUsers(api, users, opts = {}) {
+  const size2 = Math.max(1, Math.min(USERS_IMPORT_CHUNK, opts.chunk ?? USERS_IMPORT_CHUNK));
+  let upserted = 0;
+  let chunks = 0;
+  for (let i = 0; i < users.length; i += size2) {
+    const slice = users.slice(i, i + size2);
+    const r = await api("POST", "/v1/users/bulk", { users: slice });
+    if (!ok2xx(r)) throw new Error(`users import failed at user ${i + 1} of ${users.length} (${apiErrText(r)}) \u2014 ${upserted} already upserted; the call is an upsert, so re-running is safe`);
+    upserted += dataOf(r).upserted ?? slice.length;
+    chunks++;
+    opts.onProgress?.(Math.min(i + size2, users.length), users.length);
+  }
+  return { upserted, chunks };
+}
+
+// src/fnLanes.ts
+var LOCAL_LANES = ["http", "webhook", "cms-hook", "auth-hook", "queue", "cron"];
+function parseLane(raw) {
+  const v = raw === "cmsHook" ? "cms-hook" : raw === "authHook" ? "auth-hook" : raw;
+  return LOCAL_LANES.includes(v) ? v : null;
+}
+function resolveTriggerKind(inner, bindings) {
+  const declared = bindings ?? [];
+  const has = (k) => declared.some((b3) => b3.kind === k);
+  const first = (k) => declared.find((b3) => b3.kind === k);
+  const isFanout = typeof inner.webhook_event === "string" && inner.trigger === void 0;
+  if (isFanout && has("webhook")) {
+    const event = inner.webhook_event;
+    const webhooks = declared.filter((b3) => b3.kind === "webhook");
+    const matched = webhooks.find((b3) => typeof b3.source !== "string" || !b3.source || event.startsWith(b3.source));
+    if (matched) return { ok: true, trigger: "webhook", binding: matched };
+    const fallback = inner.trigger === "queue" ? "queue" : "cron";
+    const fb = first(fallback);
+    if (fb) return { ok: true, trigger: fallback, binding: fb };
+    return { ok: false, skipped: "webhook_event does not match binding source" };
+  }
+  const trigger = inner.trigger === "queue" ? "queue" : "cron";
+  const b2 = first(trigger);
+  if (!b2) return { ok: false, skipped: `no '${trigger}' binding declared` };
+  return { ok: true, trigger, binding: b2 };
+}
+var CMS_HOOK_EVENTS_FOR = {
+  beforeCreate: ["cms.item.created"],
+  beforeUpdate: ["cms.item.updated"],
+  beforeWrite: ["cms.item.created", "cms.item.updated"]
+};
+function cmsHookBindingMatches(bindings, event, collection) {
+  const hooks = (bindings ?? []).filter((b2) => b2.kind === "cmsHook" || b2.kind === "cms-hook");
+  if (hooks.length === 0) return { ok: true, passthrough: "no cmsHook binding (legacy hand-wired)" };
+  if (hooks.some((b2) => typeof b2.collection !== "string" || !b2.collection)) {
+    return { ok: true, passthrough: "legacy binding without collection", binding: hooks[0] };
+  }
+  if (typeof collection !== "string" || typeof event !== "string") {
+    return { ok: true, passthrough: "delivery lacks collection/event", binding: hooks[0] };
+  }
+  const admitted = hooks.find((b2) => b2.collection === collection && (CMS_HOOK_EVENTS_FOR[b2.event ?? "beforeWrite"] ?? CMS_HOOK_EVENTS_FOR.beforeWrite).includes(event));
+  return admitted ? { ok: true, binding: admitted } : { ok: false, skipped: "binding filter" };
+}
+function authHookBindingFor(bindings, event) {
+  if (typeof event !== "string") return void 0;
+  return (bindings ?? []).find((b2) => b2.kind === "authHook" && `auth.${b2.event ?? "user.created"}` === event);
+}
+function retryFor(binding, attempt) {
+  const n = binding?.retry?.maxAttempts;
+  if (typeof n !== "number" || !Number.isInteger(n) || n < 1) return void 0;
+  return { maxAttempts: Math.min(n, FN_RETRY_MAX_ATTEMPTS), attempt };
+}
+var WEBHOOK_PAYLOAD_MAX_BYTES = 65536;
+function boundedData(data2, maxBytes, onTruncate) {
+  if (data2 === void 0 || data2 === null) return null;
+  let text;
+  try {
+    text = JSON.stringify(data2) ?? "null";
+  } catch {
+    return { truncated: true };
+  }
+  const bytes = new TextEncoder().encode(text).length;
+  if (bytes > maxBytes) {
+    onTruncate?.(bytes);
+    return { truncated: true };
+  }
+  return data2;
+}
+function webhookPayload(inner, maxBytes = WEBHOOK_PAYLOAD_MAX_BYTES) {
+  return {
+    event: inner.webhook_event,
+    audit_id: inner.audit_id ?? null,
+    occurred_at: inner.occurred_at ?? null,
+    actor: inner.actor ?? null,
+    surface: inner.surface ?? null,
+    data: boundedData(inner.data, maxBytes)
+  };
+}
+var LANE_IDEMPOTENCY_PREFIX = {
+  webhook: "whook",
+  queue: "fntrig",
+  cron: "fntrig",
+  "cms-hook": "cmshook",
+  "auth-hook": "authhook"
+};
+function laneIdempotencyKey(lane, fnName, runId, callerKey) {
+  return lane === "http" ? callerKey ?? runId : `${LANE_IDEMPOTENCY_PREFIX[lane]}:${fnName}:${runId}`;
+}
+function auditRowToInner(row2) {
+  return {
+    webhook_event: row2.event,
+    audit_id: Number(row2.id),
+    occurred_at: row2.created_at,
+    actor: row2.actor,
+    surface: row2.surface,
+    data: row2.payload
+  };
+}
+function isRecord2(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function isAuditRow(v) {
+  return typeof v.event === "string" && "created_at" in v && "payload" in v && !("data" in v);
+}
+function parseEventFile(json2, laneFlag) {
+  let flagLane;
+  if (laneFlag !== void 0) {
+    const l = parseLane(laneFlag);
+    if (!l) return { error: `--trigger '${laneFlag}' is not a lane \u2014 use one of ${LOCAL_LANES.join(" | ")}` };
+    flagLane = l;
+  }
+  if (isRecord2(json2) && typeof json2.trigger === "string" && "payload" in json2) {
+    const l = parseLane(json2.trigger);
+    if (!l) return { error: `the event file's trigger '${json2.trigger}' is not a lane \u2014 use one of ${LOCAL_LANES.join(" | ")}` };
+    if (flagLane && flagLane !== l) return { error: `--trigger ${flagLane} disagrees with the event file's trigger '${l}'` };
+    return { lane: l, input: json2.payload };
+  }
+  if (isRecord2(json2) && isAuditRow(json2)) {
+    if (flagLane && flagLane !== "webhook") {
+      return { error: `the event file is an audit row, which reaches a function only on the webhook lane (got --trigger ${flagLane})` };
+    }
+    return { lane: "webhook", input: auditRowToInner(json2) };
+  }
+  return { lane: flagLane ?? "http", input: json2 };
+}
+var kindOf = {
+  webhook: "webhook",
+  queue: "queue",
+  cron: "cron",
+  "cms-hook": "cmsHook",
+  "auth-hook": "authHook"
+};
+function laneRefusal(lane, bindings, fnName) {
+  if (lane === "http") return null;
+  const kind = kindOf[lane];
+  if (bindings.some((b2) => b2.kind === kind || lane === "cms-hook" && b2.kind === "cms-hook")) return null;
+  const declared = bindings.map((b2) => b2.kind).filter(Boolean).join(", ") || "http";
+  return `'${fnName}' declares no ${kind} binding (it has: ${declared}) \u2014 deployed, the platform never delivers a ${lane} invocation to it. Add \`trigger: { kind: '${kind}', \u2026 }\` (or a triggers[] entry) in vxil.config.ts, or pick a lane it declares.`;
+}
+function webhookInner(input) {
+  if (!isRecord2(input)) return null;
+  if (typeof input.webhook_event === "string") {
+    const { trigger: _t, payload: _p, ...rest2 } = input;
+    void _t;
+    void _p;
+    return rest2;
+  }
+  if (typeof input.event === "string") {
+    return {
+      webhook_event: input.event,
+      audit_id: input.audit_id,
+      occurred_at: input.occurred_at,
+      actor: input.actor,
+      surface: input.surface,
+      data: input.data
+    };
+  }
+  return null;
+}
+function planLocalDelivery(opts) {
+  const { lane, input, bindings, fnName } = opts;
+  if (lane === "http") return { ok: true, lane, payload: input };
+  const refused = laneRefusal(lane, bindings, fnName);
+  if (refused) return { ok: false, refusal: refused };
+  if (lane === "queue" || lane === "cron") {
+    const inner = { trigger: lane, ...input !== void 0 ? { payload: input } : {} };
+    const r = resolveTriggerKind(inner, bindings);
+    if (!r.ok) return { ok: false, refusal: `deployed, this ${lane} delivery is ACK-200 skipped (${r.skipped})` };
+    return { ok: true, lane, payload: inner.payload ?? {}, ...r.binding ? { binding: r.binding } : {} };
+  }
+  if (lane === "webhook") {
+    const inner = webhookInner(input);
+    if (!inner) {
+      return { ok: false, refusal: 'a webhook delivery needs the event name \u2014 `{ "event": "payments.charge.succeeded", "data": { \u2026 } }` (or a GET /v1/audit row)' };
+    }
+    const event2 = inner.webhook_event;
+    const r = resolveTriggerKind(inner, bindings);
+    if (!r.ok) {
+      const sources = bindings.filter((b3) => b3.kind === "webhook").map((b3) => `'${b3.source ?? ""}'`).join(", ");
+      return { ok: false, refusal: `deployed, '${event2}' is ACK-200 skipped: no webhook binding's source (${sources}) is a prefix of it, and there is no cron/queue binding to fall back to` };
+    }
+    if (r.trigger !== "webhook") {
+      return {
+        ok: false,
+        refusal: `deployed, '${event2}' matches no webhook binding's source, so it falls through to the '${r.trigger}' binding and arrives as trigger '${r.trigger}' with payload {} \u2014 run --trigger ${r.trigger} to exercise that, or widen the binding's source`
+      };
+    }
+    return { ok: true, lane, payload: webhookPayload(inner), ...r.binding ? { binding: r.binding } : {} };
   }
-  return { error: `${filename}: expected a .json or .csv file` };
+  if (lane === "cms-hook") {
+    const rec2 = isRecord2(input) ? input : {};
+    const data2 = isRecord2(rec2.data) ? rec2.data : {};
+    const event2 = typeof rec2.webhook_event === "string" ? rec2.webhook_event : typeof rec2.event === "string" ? rec2.event : "cms.item.created";
+    const collection = typeof rec2.collection === "string" ? rec2.collection : data2.collection;
+    const itemId = typeof rec2.item_id === "string" ? rec2.item_id : data2.item_id;
+    if (typeof collection !== "string" || typeof itemId !== "string") {
+      return { ok: false, refusal: 'a cms-hook delivery needs `{ "event": "cms.item.created", "collection": "<slug>", "item_id": "<id>" }` (event defaults to cms.item.created)' };
+    }
+    const f = cmsHookBindingMatches(bindings, event2, collection);
+    if (!f.ok) {
+      const admits = bindings.filter((b3) => b3.kind === "cmsHook" || b3.kind === "cms-hook").map((b3) => `${b3.collection}: ${(CMS_HOOK_EVENTS_FOR[b3.event ?? "beforeWrite"] ?? []).join("|")}`).join("; ");
+      return { ok: false, refusal: `deployed, ${event2} on '${collection}' is ACK-200 skipped by the binding filter (the cmsHook bindings admit ${admits})` };
+    }
+    return {
+      ok: true,
+      lane,
+      payload: { event: event2, collection, item_id: itemId },
+      ...f.binding ? { binding: f.binding } : {}
+    };
+  }
+  const rec = isRecord2(input) ? input : {};
+  const event = typeof rec.webhook_event === "string" ? rec.webhook_event : typeof rec.event === "string" ? rec.event : "auth.user.created";
+  const fields = typeof rec.webhook_event === "string" ? isRecord2(rec.data) ? rec.data : {} : rec;
+  const b2 = authHookBindingFor(bindings, event);
+  if (!b2) {
+    const subscribed = bindings.filter((x) => x.kind === "authHook").map((x) => `auth.${x.event ?? "user.created"}`).join(", ");
+    return { ok: false, refusal: `no authHook binding subscribes to '${event}' (declared: ${subscribed}) \u2014 deployed, the platform wires one subscription per declared authHook event, so this delivery never happens` };
+  }
+  const { event: _e, ...rest2 } = fields;
+  void _e;
+  return { ok: true, lane, payload: { ...rest2, event }, binding: b2 };
 }
-var USERS_IMPORT_CHUNK = 100;
-async function importUsers(api, users, opts = {}) {
-  const size2 = Math.max(1, Math.min(USERS_IMPORT_CHUNK, opts.chunk ?? USERS_IMPORT_CHUNK));
-  let upserted = 0;
-  let chunks = 0;
-  for (let i = 0; i < users.length; i += size2) {
-    const slice = users.slice(i, i + size2);
-    const r = await api("POST", "/v1/users/bulk", { users: slice });
-    if (!ok2xx(r)) throw new Error(`users import failed at user ${i + 1} of ${users.length} (${apiErrText(r)}) \u2014 ${upserted} already upserted; the call is an upsert, so re-running is safe`);
-    upserted += dataOf(r).upserted ?? slice.length;
-    chunks++;
-    opts.onProgress?.(Math.min(i + size2, users.length), users.length);
+function deployedVerdict(lane, binding, timeoutMs) {
+  if (lane === "http") {
+    return ["deployed: the sync lane hands your caller this status and body as-is; the async lane records a non-2xx as a dead run"];
   }
-  return { upserted, chunks };
+  const out = [];
+  if (lane === "cron") {
+    out.push("deployed: ACKs 200 whatever this returns \u2014 a cron tick is never retried; the first failure after a clean run emits functions.run.failed");
+  } else {
+    const r = retryFor(binding, 1);
+    out.push(r ? `deployed: retry on \u2014 a non-2xx is attempt 1 of ${r.maxAttempts} (never more than the project's jobs.retry.defaultMaxAttempts); every attempt carries the same idempotency_key` : "deployed: ACKs 200 whatever this returns \u2014 the binding declares no retry, so a non-2xx is not redelivered");
+  }
+  if ((lane === "webhook" || lane === "cms-hook" || lane === "auth-hook") && typeof timeoutMs === "number" && timeoutMs > DIRECT_FN_DECLARED_MAX_MS) {
+    out.push(`limits.timeoutMs ${timeoutMs} > ${DIRECT_FN_DECLARED_MAX_MS}: deployed deliveries skip the direct first attempt and ride the queue with the full 60 s`);
+  }
+  return out;
+}
+function productionLaneGuard(o) {
+  if (!o.production || o.explicitSelector) return null;
+  if (o.lane === "http" && !o.oneShot) return null;
+  const what = o.oneShot ? `this --event delivery (${o.lane})` : `every ${o.lane} delivery of the local server`;
+  return `no dev tenant is bound, so ${what} would run '${o.fnName}' against the PRODUCTION binding '${o.tenant}' \u2014 its feature calls land there for real, and each local delivery carries a fresh idempotency_key, so a money-lane function grants, refunds or mails again even for an event production already handled. Bind a dev tenant (\`vxil dev up\`), or aim on purpose with --target <name>`;
 }
 
 // src/fnDev.ts
@@ -9121,11 +9980,12 @@ var MINTABLE_AUDS = new Set(Object.values(FUNCTION_SCOPE_AUDIENCE));
 function buildEnvelope(opts) {
   const scopedJwts = {};
   for (const aud of functionCallbackAudiences(opts.scopes)) scopedJwts[aud] = `${PLACEHOLDER_PREFIX}${aud}`;
+  const trigger = opts.trigger ?? "http";
   return {
-    trigger: "http",
+    trigger,
     tenant_id: opts.tenantId,
     request_id: opts.requestId,
-    idempotency_key: opts.idempotencyKey ?? opts.requestId,
+    idempotency_key: laneIdempotencyKey(trigger, opts.fnName, opts.runId ?? opts.requestId, opts.idempotencyKey),
     vxil_base: DEV_VXIL_BASE,
     scoped_jwts: scopedJwts,
     secrets: opts.secrets ?? {},
@@ -9429,10 +10289,15 @@ function stripApiVersionsBlock(src) {
 function canonicalCollections(collections) {
   return [...collections].sort((a, b2) => compareCodePoints(a.collection, b2.collection)).map((c) => ({ ...c, fields: [...c.fields].sort((a, b2) => compareCodePoints(a.field, b2.field)) }));
 }
+function liveFeatureKeys(cfg) {
+  const keys = Object.entries(cfg.features ?? {}).filter(([k, v]) => k !== "functions" && !(v !== null && typeof v === "object" && v.enabled === false)).map(([k]) => k);
+  if (Object.keys(cfg.functions ?? {}).length > 0) keys.push("functions");
+  return keys;
+}
 function genInputFromConfig(cfg) {
   return {
     ...cfg.env ? { env: cfg.env } : {},
-    features: Object.keys(cfg.features),
+    features: liveFeatureKeys(cfg),
     collections: Object.entries(cfg.cms?.collections ?? {}).map(([collection, def]) => ({
       collection,
       ...def.singular ? { singular: def.singular } : {},
@@ -9974,15 +10839,15 @@ var TOOLS = [
   {
     name: "rate_limits_check",
     feature: "rate-limits",
-    description: "Consume budget against a policy. Returns allowed/remaining/reset_seconds (429 on block-behavior exceed).",
+    description: "Consume budget against a policy, named by EXACTLY ONE of policy_id or policy (its name \u2014 unique per project; both or neither is 422). Returns allowed/remaining/reset_seconds (429 on block-behavior exceed). An unknown name is 404 not_found, like an unknown id; a policy created before 2026-09-23 is found by name only after it is saved or listed again.",
     inputSchema: {
       type: "object",
       properties: {
-        policy_id: { type: "string" },
+        policy_id: { type: "string", description: "the policy id (rl_\u2026); omit when you pass policy" },
+        policy: { type: "string", description: "the policy NAME; omit when you pass policy_id" },
         key_values: { type: "object", additionalProperties: { type: "string" } },
         cost: { type: "number", default: 1 }
-      },
-      required: ["policy_id"]
+      }
     },
     method: "POST",
     path: "/v1/rate-limits/check"
@@ -11192,436 +12057,190 @@ function buildMcpCatalog(input, tools = TOOLS) {
     tools: catalogTools,
     cms_collections: cmsCollections,
     functions_note: "deployed tenant functions are invoked via REST (POST /v1/fn/<name>) \u2014 the MCP server exposes no function-invoke tools",
-    functions: fns.map((f) => ({
-      name: f.name,
-      invoke: `POST /v1/fn/${f.name}`,
-      // keys sorted at every depth: online reads the signature back in the
-      // stored manifest's key order, offline in declaration order (F2)
-      signature: f.signature ? sortKeysDeep(f.signature) : null
-    }))
-  };
-}
-var MCP_CHECK_IGNORED_KEYS = ["generated_at", "tenant", "env"];
-function mcpCatalogUpToDate(existing, catalog) {
-  if (existing === null) return false;
-  const strip = (o) => {
-    for (const k of MCP_CHECK_IGNORED_KEYS) delete o[k];
-    return canonicalJson(o);
-  };
-  try {
-    const cur = JSON.parse(existing);
-    if (!cur || typeof cur !== "object" || Array.isArray(cur)) return false;
-    return strip(cur) === strip(JSON.parse(JSON.stringify(catalog)));
-  } catch {
-    return false;
-  }
-}
-
-// src/exportUrls.ts
-var EXPORT_429_RETRIES = 6;
-var EXPORT_429_MAX_WAIT_MS = 12e4;
-var EXPORT_URL_PACE_DEFAULT_S = 30;
-var EXPORT_URL_PACE_MAX_S = 600;
-var EXPORT_EXIT_URLS_EXPIRED = 3;
-var EXPORT_NET_RETRIES = 3;
-function retryAfterMs(retryAfter, attempt) {
-  const ra = Number(retryAfter);
-  if (Number.isFinite(ra) && ra > 0) return Math.min(ra * 1e3, EXPORT_429_MAX_WAIT_MS);
-  return Math.min(2 ** attempt, 30) * 1e3;
-}
-function describeFetchError(e) {
-  if (!(e instanceof Error)) return String(e);
-  const cause = e.cause;
-  if (!(cause instanceof Error)) return e.message;
-  const code = cause.code;
-  const detail = typeof code === "string" && code && !cause.message.includes(code) ? `${cause.message}, ${code}` : cause.message;
-  return detail ? `${e.message} (${detail})` : e.message;
-}
-function incompleteExportMessage(a) {
-  const lines = `${a.written} line${a.written === 1 ? "" : "s"}`;
-  const where = a.out ? `${a.out.path} was ${a.out.existed ? "left untouched (it still holds what it held before this run)" : "not created"}; the ${lines} written before the failure are in ${a.out.partial}` : `the ${lines} already on stdout stop there, and nothing in the stream marks the cut \u2014 a reader must treat it as partial`;
-  const resume = a.resume.length ? ` Resume by hand from ${a.resume.map((r) => `GET /v1/export/${a.feature}?format=ndjson&table=${encodeURIComponent(r.table)}&after=${encodeURIComponent(r.after)}${a.urls && r.table === "objects" ? "&include=urls" : ""}`).join(", then ")} (follow x-vxil-next-after and drop each page's header line), or re-run the export.` : " Re-run the export.";
-  return `${a.reason} \u2014 the export is INCOMPLETE: ${where}.${resume}`;
-}
-function parsePace(raw) {
-  if (raw === void 0) return { ms: EXPORT_URL_PACE_DEFAULT_S * 1e3 };
-  const s = Number(raw);
-  if (raw.trim() === "" || !Number.isFinite(s) || s < 0 || s > EXPORT_URL_PACE_MAX_S) {
-    return { err: `--pace takes seconds between two download-URL pages, 0..${EXPORT_URL_PACE_MAX_S} (default ${EXPORT_URL_PACE_DEFAULT_S}; 0 = as fast as the rate limiter allows) \u2014 got '${raw}'` };
-  }
-  return { ms: Math.round(s * 1e3) };
-}
-function paceWaitMs(lastStartMs, nowMs, paceMs) {
-  if (lastStartMs === null || paceMs <= 0) return 0;
-  return Math.max(0, lastStartMs + paceMs - nowMs);
-}
-function ndjsonDownloads(lines) {
-  const out = [];
-  for (const l of lines) {
-    if (!l.includes('"download"')) continue;
-    try {
-      const d = JSON.parse(l).download;
-      if (d && typeof d === "object" && "url" in d) out.push(d);
-    } catch {
-    }
-  }
-  return out;
-}
-function newDownloadTally() {
-  return { total: 0, missing: /* @__PURE__ */ new Map(), expiries: [] };
-}
-function tallyDownloads(t, entries) {
-  for (const e of entries) {
-    t.total += 1;
-    if (e.url === null) {
-      const r = e.reason ?? "unknown";
-      t.missing.set(r, (t.missing.get(r) ?? 0) + 1);
-      continue;
-    }
-    const at = typeof e.expires_at === "string" ? Date.parse(e.expires_at) : NaN;
-    if (Number.isFinite(at)) t.expiries.push(at);
-  }
-  return t;
-}
-function missingSummary(t) {
-  const missing = [...t.missing.values()].reduce((a, b2) => a + b2, 0);
-  if (!missing) return null;
-  const parts = [...t.missing.entries()].sort((a, b2) => b2[1] - a[1]).map(([r, n]) => `${r} \xD7${n}`);
-  return `vxil: ${missing} of ${t.total} object${t.total === 1 ? "" : "s"} carry NO download URL (${parts.join(", ")}) \u2014 status:* rows have no confirmed bytes yet (or are deleted); insufficient_scope needs files:read on the key; re-run for network_error`;
-}
-function expiredReport(t, nowMs, startedMs, readLive) {
-  let deadCount = 0;
-  let oldestAt = Infinity;
-  for (const at of t.expiries) {
-    if (at > nowMs) continue;
-    deadCount += 1;
-    if (at < oldestAt) oldestAt = at;
-  }
-  if (!deadCount) return null;
-  const minted = t.expiries.length;
-  const ranMin = Math.max(1, Math.round((nowMs - startedMs) / 6e4));
-  const oldest = new Date(oldestAt).toISOString();
-  const remedy = "raise `features.files.downloadUrlTtl` (seconds, max 86400) above the export's run time (~0.3 s per object at the default --pace), read the NDJSON as it streams (pipe it to your fetcher), or mint per object at fetch time with GET /v1/files/{id}/download-url";
-  if (readLive) {
-    return {
-      exitCode: 0,
-      message: `vxil: ${deadCount} of ${minted} download URL${minted === 1 ? "" : "s"} had expired by the time the export finished (it ran ~${ranMin} min; the oldest died at ${oldest}) \u2014 fine if your reader fetched each page as it streamed; a reader that waits for the end gets 403 on them. To keep them alive: ${remedy}.`
-    };
-  }
-  return {
-    exitCode: EXPORT_EXIT_URLS_EXPIRED,
-    message: `vxil: ${deadCount} of ${minted} download URL${minted === 1 ? "" : "s"} had ALREADY EXPIRED when the export finished (it ran ~${ranMin} min; the oldest died at ${oldest}) \u2014 a GET on them answers 403, so those objects' bytes are NOT one fetch away. The metadata is complete (exit ${EXPORT_EXIT_URLS_EXPIRED}, not 1). Fix: ${remedy}.`
-  };
-}
-var OBJECTS_TRUNCATED = /^objects: truncated at /;
-function objectsCut(b2) {
-  const tr = Array.isArray(b2.truncated) ? b2.truncated.find((t) => t.table === "objects") : void 0;
-  if (tr) return typeof tr.after === "string" && tr.after ? { after: tr.after } : { unresumable: true };
-  if (Array.isArray(b2.skipped) && b2.skipped.some((s) => OBJECTS_TRUNCATED.test(s))) return { unresumable: true };
-  return null;
-}
-function mergeObjectsPage(b2, lines) {
-  b2.tables ??= [];
-  let objects = b2.tables.find((t) => t.name === "objects");
-  if (!objects) {
-    objects = { name: "objects", rows: [] };
-    b2.tables.push(objects);
-  }
-  b2.downloads ??= [];
-  let n = 0;
-  for (const l of lines) {
-    let parsed;
-    try {
-      parsed = JSON.parse(l);
-    } catch {
-      continue;
-    }
-    if (parsed.t !== "objects" || !parsed.r || typeof parsed.r !== "object") continue;
-    objects.rows.push(parsed.r);
-    n += 1;
-    const d = parsed.download;
-    if (d && typeof d === "object" && "url" in d) {
-      b2.downloads.push({
-        object_id: String(parsed.r.object_id ?? ""),
-        url: d.url,
-        expires_at: d.expires_at ?? null,
-        ...d.reason ? { reason: d.reason } : {}
-      });
-    }
-  }
-  return n;
-}
-function markObjectsComplete(b2) {
-  if (Array.isArray(b2.skipped)) {
-    b2.skipped = b2.skipped.filter((s) => !OBJECTS_TRUNCATED.test(s));
-    if (!b2.skipped.length) delete b2.skipped;
-  }
-  if (Array.isArray(b2.truncated)) {
-    b2.truncated = b2.truncated.filter((t) => t.table !== "objects");
-    if (!b2.truncated.length) delete b2.truncated;
-  }
-}
-function truncationNotes(b2) {
-  return Array.isArray(b2.skipped) ? b2.skipped.filter((s) => /: truncated at \d+ rows/.test(s)) : [];
-}
-
-// src/store.ts
-import { homedir as homedir2 } from "node:os";
-import { join as join2, resolve as resolve3 } from "node:path";
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2, chmodSync } from "node:fs";
-function dashboardOrigin(base2) {
-  try {
-    return new URL(base2).origin.toLowerCase();
-  } catch {
-    return base2.trim().replace(/\/+$/, "").toLowerCase();
-  }
-}
-function storedSessionFor(creds, dashBase) {
-  if (!creds.session) return { session: null, reason: "no-session" };
-  if (!creds.session_host) return { session: null, reason: "unbound" };
-  const host = dashboardOrigin(creds.session_host);
-  if (host !== dashboardOrigin(dashBase)) return { session: null, reason: "other-host", host };
-  return { session: creds.session, host };
-}
-function sessionNotForTarget(s, target) {
-  if (s.reason === "other-host") return `the stored dashboard session belongs to ${s.host}, not this target (${dashboardOrigin(target)}) \u2014 run \`vxil login\` against this target to use it here`;
-  if (s.reason === "unbound") return `the stored dashboard session has no recorded host (written by an older CLI) and is not sent anywhere \u2014 run \`vxil login\` again to bind it`;
-  return "no dashboard session \u2014 run `vxil login`";
-}
-function credDir() {
-  return join2(homedir2(), ".vxil");
-}
-function credFile() {
-  return join2(credDir(), "credentials.json");
-}
-function loadCredentials() {
-  try {
-    return JSON.parse(readFileSync3(credFile(), "utf8"));
-  } catch {
-    return {};
-  }
-}
-function saveCredentials(c) {
-  mkdirSync(credDir(), { recursive: true });
-  writeFileSync2(credFile(), JSON.stringify(c, null, 2));
-  try {
-    chmodSync(credFile(), 384);
-  } catch {
-  }
-}
-function projectFile(cwd = process.cwd()) {
-  return resolve3(cwd, ".vxil", "project.json");
+    functions: fns.map((f) => ({
+      name: f.name,
+      invoke: `POST /v1/fn/${f.name}`,
+      // keys sorted at every depth: online reads the signature back in the
+      // stored manifest's key order, offline in declaration order (F2)
+      signature: f.signature ? sortKeysDeep(f.signature) : null
+    }))
+  };
 }
-function loadProject(cwd = process.cwd()) {
+var MCP_CHECK_IGNORED_KEYS = ["generated_at", "tenant", "env"];
+function mcpCatalogUpToDate(existing, catalog) {
+  if (existing === null) return false;
+  const strip = (o) => {
+    for (const k of MCP_CHECK_IGNORED_KEYS) delete o[k];
+    return canonicalJson(o);
+  };
   try {
-    return JSON.parse(readFileSync3(projectFile(cwd), "utf8"));
+    const cur = JSON.parse(existing);
+    if (!cur || typeof cur !== "object" || Array.isArray(cur)) return false;
+    return strip(cur) === strip(JSON.parse(JSON.stringify(catalog)));
   } catch {
-    return null;
+    return false;
   }
 }
-function saveProject(binding, cwd = process.cwd()) {
-  const dir = resolve3(cwd, ".vxil");
-  mkdirSync(dir, { recursive: true });
-  writeFileSync2(projectFile(cwd), JSON.stringify(binding, null, 2));
+
+// src/exportUrls.ts
+var EXPORT_429_RETRIES = 6;
+var EXPORT_429_MAX_WAIT_MS = 12e4;
+var EXPORT_URL_PACE_DEFAULT_S = 30;
+var EXPORT_URL_PACE_MAX_S = 600;
+var EXPORT_EXIT_URLS_EXPIRED = 3;
+var EXPORT_NET_RETRIES = 3;
+function retryAfterMs(retryAfter, attempt) {
+  const ra = Number(retryAfter);
+  if (Number.isFinite(ra) && ra > 0) return Math.min(ra * 1e3, EXPORT_429_MAX_WAIT_MS);
+  return Math.min(2 ** attempt, 30) * 1e3;
 }
-function envLabelFor(base2) {
-  try {
-    return /(^|\.)api\.vxil\.com$/.test(new URL(base2).hostname) ? "production" : "staging";
-  } catch {
-    return "staging";
-  }
+function describeFetchError(e) {
+  if (!(e instanceof Error)) return String(e);
+  const cause = e.cause;
+  if (!(cause instanceof Error)) return e.message;
+  const code = cause.code;
+  const detail = typeof code === "string" && code && !cause.message.includes(code) ? `${cause.message}, ${code}` : cause.message;
+  return detail ? `${e.message} (${detail})` : e.message;
 }
-function mergePrimaryBinding(existing, primary) {
-  const { ephemeral: _e, expires_at: _x, ...keep } = existing ?? {};
-  void _e;
-  void _x;
-  return {
-    ...keep,
-    tenant_id: primary.tenant_id,
-    slug: primary.slug,
-    edge_url: primary.edge_url,
-    ...primary.env !== void 0 ? { env: primary.env } : {}
-  };
+function incompleteExportMessage(a) {
+  const lines = `${a.written} line${a.written === 1 ? "" : "s"}`;
+  const where = a.out ? `${a.out.path} was ${a.out.existed ? "left untouched (it still holds what it held before this run)" : "not created"}; the ${lines} written before the failure are in ${a.out.partial}` : `the ${lines} already on stdout stop there, and nothing in the stream marks the cut \u2014 a reader must treat it as partial`;
+  const resume = a.resume.length ? ` Resume by hand from ${a.resume.map((r) => `GET /v1/export/${a.feature}?format=ndjson&table=${encodeURIComponent(r.table)}&after=${encodeURIComponent(r.after)}${a.urls && r.table === "objects" ? "&include=urls" : ""}`).join(", then ")} (follow x-vxil-next-after and drop each page's header line), or re-run the export.` : " Re-run the export.";
+  return `${a.reason} \u2014 the export is INCOMPLETE: ${where}.${resume}`;
 }
-function bindNamedSlot(existing, name, slot) {
-  if (!existing) {
-    throw new Error(
-      `no project bound in this directory yet \u2014 run \`vxil link <slug>\` (or \`vxil quickstart\`) first, then \`vxil link <other-slug> --as ${name}\``
-    );
-  }
-  if (name === "dev") {
-    return {
-      ...existing,
-      dev: {
-        tenant_id: slot.tenant_id,
-        slug: slot.slug,
-        edge_url: slot.edge_url,
-        ...slot.expires_at ? { expires_at: slot.expires_at } : {}
-      }
-    };
+function parsePace(raw) {
+  if (raw === void 0) return { ms: EXPORT_URL_PACE_DEFAULT_S * 1e3 };
+  const s = Number(raw);
+  if (raw.trim() === "" || !Number.isFinite(s) || s < 0 || s > EXPORT_URL_PACE_MAX_S) {
+    return { err: `--pace takes seconds between two download-URL pages, 0..${EXPORT_URL_PACE_MAX_S} (default ${EXPORT_URL_PACE_DEFAULT_S}; 0 = as fast as the rate limiter allows) \u2014 got '${raw}'` };
   }
-  const { expires_at: _x, ...permanent } = slot;
-  void _x;
-  return { ...existing, targets: { ...existing.targets, [name]: permanent } };
-}
-var TARGET_NAME_RE = /^[a-z][a-z0-9-]{0,39}$/;
-function selectorFrom(flags) {
-  if (flags.target !== void 0) return { kind: "named", name: flags.target };
-  if (flags.dev) return { kind: "dev" };
-  return { kind: "primary" };
-}
-function describeSelector(sel) {
-  return sel.kind === "primary" ? "primary" : sel.kind === "dev" ? "--dev" : `--target ${sel.name}`;
+  return { ms: Math.round(s * 1e3) };
 }
-var TargetUnboundError = class extends Error {
-  constructor(selector2, fix) {
-    super(
-      sel_msg(selector2) + ` \u2014 ${fix}`
-    );
-    this.selector = selector2;
-    this.fix = fix;
-    this.name = "TargetUnboundError";
-  }
-  selector;
-  fix;
-};
-function sel_msg(sel) {
-  if (sel.kind === "dev") return "no dev tenant is bound in .vxil/project.json";
-  if (sel.kind === "named") return `no target '${sel.name}' is bound in .vxil/project.json`;
-  return "no project is bound";
+function paceWaitMs(lastStartMs, nowMs, paceMs) {
+  if (lastStartMs === null || paceMs <= 0) return 0;
+  return Math.max(0, lastStartMs + paceMs - nowMs);
 }
-function resolve_target(opts) {
-  const cwd = opts.cwd ?? process.cwd();
-  const proj = opts.project !== void 0 ? opts.project : loadProject(cwd);
-  const creds = opts.credentials ?? loadCredentials();
-  const env = opts.env ?? process.env;
-  const envKey = env.VXIL_API_KEY || void 0;
-  const envBase = env.VXIL_BASE_URL || void 0;
-  const selector2 = selectorFrom({ dev: opts.which === "dev", target: opts.target });
-  if (selector2.kind === "dev") {
-    const slot = proj?.dev;
-    if (!slot) {
-      throw new TargetUnboundError(
-        selector2,
-        "run `vxil dev up`, `vxil dev branch <name>`, or `vxil link <slug> --as dev` to bind one (the primary/production key is never used for --dev)"
-      );
+function ndjsonDownloads(lines) {
+  const out = [];
+  for (const l of lines) {
+    if (!l.includes('"download"')) continue;
+    try {
+      const d = JSON.parse(l).download;
+      if (d && typeof d === "object" && "url" in d) out.push(d);
+    } catch {
     }
-    const devKey = env.VXIL_DEV_KEY || void 0;
-    const stored = creds.keys?.[slot.slug];
-    const baseUrl2 = envBase ?? slot.edge_url ?? opts.defaultBase;
-    return {
-      apiKey: devKey ?? stored,
-      baseUrl: baseUrl2,
-      tenantSlug: slot.slug,
-      tenantId: slot.tenant_id,
-      slot: "dev",
-      envLabel: envLabelFor(baseUrl2),
-      keySource: devKey ? "VXIL_DEV_KEY" : stored ? "credentials" : "none",
-      selector: selector2
-    };
   }
-  if (selector2.kind === "named") {
-    const name = selector2.name;
-    const slot = proj?.targets?.[name] ?? proj?.branches?.[name] ?? (name === "dev" ? proj?.dev : void 0);
-    if (!slot) {
-      throw new TargetUnboundError(
-        selector2,
-        `run \`vxil link <slug> --as ${name}\` to bind it (or \`vxil dev branch ${name}\` for an ephemeral one); the primary key is never substituted for a missing target`
-      );
+  return out;
+}
+function newDownloadTally() {
+  return { total: 0, missing: /* @__PURE__ */ new Map(), expiries: [] };
+}
+function tallyDownloads(t, entries) {
+  for (const e of entries) {
+    t.total += 1;
+    if (e.url === null) {
+      const r = e.reason ?? "unknown";
+      t.missing.set(r, (t.missing.get(r) ?? 0) + 1);
+      continue;
     }
-    const stored = creds.keys?.[slot.slug];
-    const baseUrl2 = envBase ?? slot.edge_url ?? opts.defaultBase;
-    return {
-      apiKey: stored,
-      baseUrl: baseUrl2,
-      tenantSlug: slot.slug,
-      tenantId: slot.tenant_id,
-      slot: "named",
-      slotName: name,
-      envLabel: slot.env ?? envLabelFor(baseUrl2),
-      keySource: stored ? "credentials" : "none",
-      selector: selector2
-    };
+    const at = typeof e.expires_at === "string" ? Date.parse(e.expires_at) : NaN;
+    if (Number.isFinite(at)) t.expiries.push(at);
   }
-  if (envKey) {
-    const baseUrl2 = envBase ?? proj?.edge_url ?? opts.defaultBase;
-    return {
-      apiKey: envKey,
-      baseUrl: baseUrl2,
-      tenantSlug: proj?.slug,
-      tenantId: proj?.tenant_id,
-      slot: proj ? "primary" : "env",
-      envLabel: proj?.env ?? envLabelFor(baseUrl2),
-      keySource: "VXIL_API_KEY",
-      selector: selector2
-    };
+  return t;
+}
+function missingSummary(t) {
+  const missing = [...t.missing.values()].reduce((a, b2) => a + b2, 0);
+  if (!missing) return null;
+  const parts = [...t.missing.entries()].sort((a, b2) => b2[1] - a[1]).map(([r, n]) => `${r} \xD7${n}`);
+  return `vxil: ${missing} of ${t.total} object${t.total === 1 ? "" : "s"} carry NO download URL (${parts.join(", ")}) \u2014 status:* rows have no confirmed bytes yet (or are deleted); insufficient_scope needs files:read on the key; re-run for network_error`;
+}
+function expiredReport(t, nowMs, startedMs, readLive) {
+  let deadCount = 0;
+  let oldestAt = Infinity;
+  for (const at of t.expiries) {
+    if (at > nowMs) continue;
+    deadCount += 1;
+    if (at < oldestAt) oldestAt = at;
   }
-  if (proj) {
-    const key = creds.keys?.[proj.slug];
-    const baseUrl2 = envBase ?? proj.edge_url ?? opts.defaultBase;
+  if (!deadCount) return null;
+  const minted = t.expiries.length;
+  const ranMin = Math.max(1, Math.round((nowMs - startedMs) / 6e4));
+  const oldest = new Date(oldestAt).toISOString();
+  const remedy = "raise `features.files.downloadUrlTtl` (seconds, max 86400) above the export's run time (~0.3 s per object at the default --pace), read the NDJSON as it streams (pipe it to your fetcher), or mint per object at fetch time with GET /v1/files/{id}/download-url";
+  if (readLive) {
     return {
-      apiKey: key,
-      baseUrl: baseUrl2,
-      tenantSlug: proj.slug,
-      tenantId: proj.tenant_id,
-      slot: "primary",
-      envLabel: proj.env ?? envLabelFor(baseUrl2),
-      keySource: key ? "credentials" : "none",
-      selector: selector2
+      exitCode: 0,
+      message: `vxil: ${deadCount} of ${minted} download URL${minted === 1 ? "" : "s"} had expired by the time the export finished (it ran ~${ranMin} min; the oldest died at ${oldest}) \u2014 fine if your reader fetched each page as it streamed; a reader that waits for the end gets 403 on them. To keep them alive: ${remedy}.`
     };
   }
-  const baseUrl = envBase ?? opts.defaultBase;
   return {
-    apiKey: void 0,
-    baseUrl,
-    tenantSlug: void 0,
-    tenantId: void 0,
-    slot: "none",
-    envLabel: envLabelFor(baseUrl),
-    keySource: "none",
-    selector: selector2
+    exitCode: EXPORT_EXIT_URLS_EXPIRED,
+    message: `vxil: ${deadCount} of ${minted} download URL${minted === 1 ? "" : "s"} had ALREADY EXPIRED when the export finished (it ran ~${ranMin} min; the oldest died at ${oldest}) \u2014 a GET on them answers 403, so those objects' bytes are NOT one fetch away. The metadata is complete (exit ${EXPORT_EXIT_URLS_EXPIRED}, not 1). Fix: ${remedy}.`
   };
 }
-function targetBanner(t, verb) {
-  const host = (() => {
+var OBJECTS_TRUNCATED = /^objects: truncated at /;
+function objectsCut(b2) {
+  const tr = Array.isArray(b2.truncated) ? b2.truncated.find((t) => t.table === "objects") : void 0;
+  if (tr) return typeof tr.after === "string" && tr.after ? { after: tr.after } : { unresumable: true };
+  if (Array.isArray(b2.skipped) && b2.skipped.some((s) => OBJECTS_TRUNCATED.test(s))) return { unresumable: true };
+  return null;
+}
+function mergeObjectsPage(b2, lines) {
+  b2.tables ??= [];
+  let objects = b2.tables.find((t) => t.name === "objects");
+  if (!objects) {
+    objects = { name: "objects", rows: [] };
+    b2.tables.push(objects);
+  }
+  b2.downloads ??= [];
+  let n = 0;
+  for (const l of lines) {
+    let parsed;
     try {
-      return new URL(t.baseUrl).host;
+      parsed = JSON.parse(l);
     } catch {
-      return t.baseUrl;
+      continue;
     }
-  })();
-  const slot = t.slot === "named" ? `target '${t.slotName}'` : t.slot === "dev" ? "dev slot" : t.slot === "env" ? "VXIL_API_KEY (no project binding)" : t.slot === "primary" ? "primary" : "unbound";
-  const tenant = t.tenantSlug ? `tenant '${t.tenantSlug}'` : "tenant (unknown slug)";
-  return `vxil ${verb} \u2192 ${tenant} \xB7 ${t.envLabel.toUpperCase()} \xB7 ${host} [${slot}]`;
+    if (parsed.t !== "objects" || !parsed.r || typeof parsed.r !== "object") continue;
+    objects.rows.push(parsed.r);
+    n += 1;
+    const d = parsed.download;
+    if (d && typeof d === "object" && "url" in d) {
+      b2.downloads.push({
+        object_id: String(parsed.r.object_id ?? ""),
+        url: d.url,
+        expires_at: d.expires_at ?? null,
+        ...d.reason ? { reason: d.reason } : {}
+      });
+    }
+  }
+  return n;
 }
-function bindingSlots(proj) {
-  if (!proj) return [];
-  const out = [
-    { label: "primary", slug: proj.slug, tenant_id: proj.tenant_id, edge_url: proj.edge_url }
-  ];
-  const seen = /* @__PURE__ */ new Set([proj.slug]);
-  const push = (label, s) => {
-    if (seen.has(s.slug)) return;
-    seen.add(s.slug);
-    out.push({ label, slug: s.slug, tenant_id: s.tenant_id, edge_url: s.edge_url });
-  };
-  if (proj.dev) push("dev", proj.dev);
-  for (const [n, s] of Object.entries(proj.targets ?? {})) push(`target:${n}`, s);
-  for (const [n, s] of Object.entries(proj.branches ?? {})) push(`branch:${n}`, s);
-  return out;
+function markObjectsComplete(b2) {
+  if (Array.isArray(b2.skipped)) {
+    b2.skipped = b2.skipped.filter((s) => !OBJECTS_TRUNCATED.test(s));
+    if (!b2.skipped.length) delete b2.skipped;
+  }
+  if (Array.isArray(b2.truncated)) {
+    b2.truncated = b2.truncated.filter((t) => t.table !== "objects");
+    if (!b2.truncated.length) delete b2.truncated;
+  }
+}
+function truncationNotes(b2) {
+  return Array.isArray(b2.skipped) ? b2.skipped.filter((s) => /: truncated at \d+ rows/.test(s)) : [];
 }
 
 // src/drift.ts
-function isPlainObject(v) {
+function isPlainObject2(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v);
 }
 function flattenLeaves(obj, prefix = "") {
   const out = /* @__PURE__ */ new Map();
-  if (!isPlainObject(obj)) return out;
+  if (!isPlainObject2(obj)) return out;
   for (const k of Object.keys(obj).sort()) {
     const path = prefix ? `${prefix}.${k}` : k;
     const v = obj[k];
-    if (isPlainObject(v) && Object.keys(v).length) {
+    if (isPlainObject2(v) && Object.keys(v).length) {
       for (const [p, lv] of flattenLeaves(v, path)) out.set(p, lv);
     } else {
       out.set(path, v);
@@ -12493,159 +13112,6 @@ async function createBranchTenant(dash, opts) {
   };
 }
 
-// src/promotionGate.ts
-var NON_PRODUCTION_ENV_LABELS = /* @__PURE__ */ new Set([
-  "staging",
-  "stage",
-  "dev",
-  "development",
-  "test",
-  "qa",
-  "preview",
-  "sandbox",
-  "local"
-]);
-function normalizeLabel(label) {
-  return label.trim().toLowerCase();
-}
-function isNonProductionLabel(label) {
-  return NON_PRODUCTION_ENV_LABELS.has(normalizeLabel(label));
-}
-function isDevSlot(t) {
-  return t.slot === "dev" || t.slot === "named" && t.selector.kind === "named" && t.selector.name === "dev";
-}
-function isProductionTarget(t) {
-  if (isDevSlot(t)) return false;
-  if (normalizeLabel(t.envLabel) === "production") return true;
-  return envLabelFor(t.baseUrl) === "production" && !isNonProductionLabel(t.envLabel);
-}
-function hostOf(baseUrl) {
-  try {
-    return new URL(baseUrl).host;
-  } catch {
-    return baseUrl;
-  }
-}
-function unrecognizedLabelNotice(t) {
-  if (isDevSlot(t)) return null;
-  if (normalizeLabel(t.envLabel) === "production") return null;
-  if (envLabelFor(t.baseUrl) !== "production") return null;
-  if (isNonProductionLabel(t.envLabel)) return null;
-  return `env label '${t.envLabel}' is not a recognized environment and the host is ${hostOf(t.baseUrl)} \u2014 treating this target as PRODUCTION (use --env staging|dev|test|qa|preview|sandbox|local to say otherwise)`;
-}
-function envLabelWarning(label, baseUrl) {
-  const l = normalizeLabel(label);
-  const host = hostOf(baseUrl);
-  if (envLabelFor(baseUrl) === "production") {
-    if (l === "production") return null;
-    if (isNonProductionLabel(l)) {
-      return `slot labelled '${label}' on the PRODUCTION host ${host} \u2014 the push promotion gate will NOT fire for it (the documented staging-twin pattern; re-link with --env production if this IS a production tenant)`;
-    }
-    return `env label '${label}' is not a recognized environment \u2014 on the PRODUCTION host ${host} it is treated as PRODUCTION (the push promotion gate WILL fire). Use production|staging|dev|test|qa|preview|sandbox|local.`;
-  }
-  if (l === "production") {
-    return `slot labelled 'production' on the non-production host ${host} \u2014 the push promotion gate WILL fire for it`;
-  }
-  return null;
-}
-function isPlainObject2(v) {
-  return v !== null && typeof v === "object" && !Array.isArray(v);
-}
-function leafAt(manifest, dotted) {
-  let cur = manifest;
-  for (const seg of dotted.split(".")) {
-    if (!isPlainObject2(cur)) return void 0;
-    cur = cur[seg];
-  }
-  return cur;
-}
-function mockFeatures(cfg) {
-  return Object.entries(cfg.features ?? {}).filter(([, conf]) => {
-    if (!isPlainObject2(conf)) return false;
-    const c = conf;
-    return c.provider === "mock" || c.defaultProvider === "mock" || (isPlainObject2(c.embed) ? c.embed.provider === "mock" : false);
-  }).map(([f]) => f);
-}
-var SANDBOX_LEAVES = [
-  { feature: "payments", path: "paddle.sandbox" },
-  { feature: "payments", path: "paypal.sandbox" },
-  { feature: "payments", path: "revenuecat.acceptSandbox" }
-];
-function sandboxFeatures(cfg) {
-  const out = [];
-  for (const leaf of SANDBOX_LEAVES) {
-    const manifest = (cfg.features ?? {})[leaf.feature];
-    if (leafAt(manifest, leaf.path) === true) out.push(`${leaf.feature}.${leaf.path}`);
-  }
-  return out;
-}
-function isDevHost(host) {
-  const h = host.toLowerCase().replace(/:\d+$/, "").replace(/^\[|\]$/g, "");
-  if (h === "localhost" || h.endsWith(".localhost")) return true;
-  if (h === "127.0.0.1" || h.startsWith("127.")) return true;
-  if (h === "::1") return true;
-  if (h === "local" || h.endsWith(".local")) return true;
-  if (/^10\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h)) return true;
-  if (/^192\.168\.\d{1,3}\.\d{1,3}$/.test(h)) return true;
-  if (/^172\.(1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}$/.test(h)) return true;
-  return false;
-}
-function devRedirectOrigins(origins = []) {
-  const out = [];
-  for (const raw of origins) {
-    if (typeof raw !== "string" || !raw) continue;
-    if (/^http:\/\//i.test(raw)) {
-      out.push(raw);
-      continue;
-    }
-    const host = raw.replace(/^[a-z][a-z0-9+.-]*:\/\//i, "").replace(/[/?#].*$/, "");
-    if (host && isDevHost(host)) out.push(raw);
-  }
-  return out;
-}
-function redirectOrigins(cfg) {
-  const v = leafAt((cfg.features ?? {}).auth, "security.allowedRedirectOrigins");
-  return Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
-}
-var PROMOTION_OVERRIDE_FLAGS = {
-  mock: "allow-mock-in-prod",
-  sandbox: "allow-sandbox-in-prod",
-  origins: "allow-dev-origins-in-prod"
-};
-function promotionRefusals(cfg, allowed) {
-  const out = [];
-  const mocks = mockFeatures(cfg);
-  if (mocks.length && !allowed(PROMOTION_OVERRIDE_FLAGS.mock)) {
-    out.push({
-      kind: "mock",
-      flag: PROMOTION_OVERRIDE_FLAGS.mock,
-      message: `mock providers on [${mocks.join(", ")}] would ship to production (mock email/payments silently no-op). Set a real provider, or override with --${PROMOTION_OVERRIDE_FLAGS.mock}.`
-    });
-  }
-  const sandboxes = sandboxFeatures(cfg);
-  if (sandboxes.length && !allowed(PROMOTION_OVERRIDE_FLAGS.sandbox)) {
-    out.push({
-      kind: "sandbox",
-      flag: PROMOTION_OVERRIDE_FLAGS.sandbox,
-      message: `sandbox provider flags [${sandboxes.join(", ")}] would ship to a live money path (a sandbox key signs with the wrong secret; RevenueCat folds test purchases as outcome rejected_environment). Set them false, or override with --${PROMOTION_OVERRIDE_FLAGS.sandbox}.`
-    });
-  }
-  const devOrigins = devRedirectOrigins(redirectOrigins(cfg));
-  if (devOrigins.length && !allowed(PROMOTION_OVERRIDE_FLAGS.origins)) {
-    out.push({
-      kind: "origins",
-      flag: PROMOTION_OVERRIDE_FLAGS.origins,
-      message: `auth.security.allowedRedirectOrigins contains non-production origin(s) [${devOrigins.join(", ")}] \u2014 a loopback / .local / http:// redirect target on a production auth tenant is a token-exfiltration footgun. Remove them, or override with --${PROMOTION_OVERRIDE_FLAGS.origins}.`
-    });
-  }
-  return out;
-}
-function redirectOriginNotice(cfg) {
-  const origins = redirectOrigins(cfg);
-  if (!origins.length) return null;
-  return `auth.security.allowedRedirectOrigins (${origins.length}): ${origins.join(", ")}`;
-}
-
 // src/try.ts
 async function mintTry(fetchImpl, base2, opts = {}) {
   const url = `${base2.replace(/\/$/, "")}/v1/try`;
@@ -16692,7 +17158,7 @@ export default defineConfig({
     "hasFunctions": true,
     "byoKeys": [],
     "configSrc": "import { defineConfig } from '@vxil/config';\n\n// \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// \"Funnel SaaS\" \u2014 the STUDIO STARTER. A web-first funnel product, declared\n// end-to-end in ONE typed file:\n//\n//   guest session \u2192 guided steps \u2192 e-mail claim \u2192 account \u2192 pass \u2192 AI brief\n//\n// What it composes (every block is a shipped feature; nothing here is a\n// platform primitive you would have to build):\n//   \u2022 auth          \u2192 anonymous sign-in for the visitor, an OTP e-mail claim that\n//                     PROMOTES the guest in place (same id, same rows), a session\n//                     pair the server refreshes behind a long-lived cookie\n//   \u2022 cms           \u2192 two owner-scoped collections behind `strictEndUserScope`:\n//                     a signed-in visitor sees ONLY their own rows, and a\n//                     collection without an owner field is server-only\n//   \u2022 rate-limits   \u2192 two policies DECLARED here, converged by `vxil push`\n//   \u2022 webhooks      \u2192 failure alerts to the owners + ONE declared outbound\n//                     subscription for your ops endpoint\n//   \u2022 ai            \u2192 a stored prompt template DECLARED here; the brief runs on\n//                     the job lane with a `correlation_id` = the session row id\n//   \u2022 payments      \u2192 a payments INTEGRATION: your own provider account (mock\n//                     here), vxil never in the flow of funds\n//   \u2022 functions     \u2192 three event-driven functions (below)\n// Everything here is DATA the tenant owns and edits after `vxil init`.\n// \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nexport default defineConfig({\n  env: 'staging',\n\n  features: {\n    auth: {\n      // Visitors never see a password form: a guest session first, an e-mail\n      // code to claim it later (magic link stays on as the alternative).\n      methods: { emailPassword: false, magicLink: true },\n      anonymous: { enabled: true },\n      // The claim rides the OTP machinery (POST /v1/auth/anonymous/link/request\n      // + /verify). `testRecipients` is where your CI address goes \u2014 a listed\n      // address gets no mail and the 202 carries `test_code`.\n      otp: { enabled: true, codeTtlMinutes: 10, maxAttempts: 5, resendCooldownSec: 60 },\n      // The pair your server middleware rotates (README: \"keep the token fresh\").\n      session: { ttlMinutes: 60, refreshTtlDays: 30 },\n    },\n\n    cms: {\n      // A funnel row is live the moment it is written \u2014 no editorial draft step.\n      draftPublish: false,\n      // THE FAIL-SAFE. In end-user mode a collection with no `ownerField` is\n      // server-only (403 server_only on read AND write) instead of\n      // tenant-wide-shared. Every collection below declares an owner, so a\n      // visitor can only ever reach their own rows; a collection you add later\n      // without one is closed to them until you say otherwise.\n      strictEndUserScope: true,\n      hooks: {\n        // Steps only move forward \u2014 a client cannot rewind a completed intake.\n        // (`coalesce` so a row created without a step can still be stepped.)\n        steps_forward_only: {\n          collection: 'funnel_sessions',\n          event: 'beforeUpdate',\n          kind: 'validate',\n          expr: 'coalesce(item.step, 0) >= coalesce(before.step, 0)',\n          message: 'steps only move forward',\n        },\n        // The session state machine: in_progress \u2192 completed, and completed is\n        // terminal (the brief function flips it; nothing flips it back).\n        session_transition: {\n          collection: 'funnel_sessions',\n          event: 'beforeUpdate',\n          kind: 'validate',\n          expr: \"item.status == before.status || (before.status == 'in_progress' && item.status == 'completed')\",\n          message: 'illegal session status transition',\n        },\n        // A pass is bound to the charge that paid for it, forever.\n        pass_charge_immutable: {\n          collection: 'passes',\n          event: 'beforeUpdate',\n          kind: 'validate',\n          expr: 'item.charge_id == before.charge_id',\n          message: 'a pass keeps the charge that paid for it',\n        },\n      },\n    },\n\n    // Auth mail (the claim code) and the \"your brief is ready\" message ride\n    // this. `mock` needs no account; point it at your own provider to go live.\n    notifications: { provider: 'mock', fromEmail: 'hello@studio.example' },\n\n    // DECLARED API STATE #1 \u2014 rate-limit policies. These used to be rows you\n    // created by hand with POST /v1/rate-limits/policies and re-created in every\n    // environment; now `vxil push` converges the live set onto this list by\n    // name (creates what is missing, patches what differs, REPORTS what you did\n    // not declare). Your server checks them with POST /v1/rate-limits/check.\n    'rate-limits': {\n      enabled: true,\n      policies: [\n        // one visitor, thirty step writes a minute \u2014 enough for a human, not a loop\n        { name: 'funnel-step', key_template: '{tenant_id}:{user_id}', limit: 30, window_seconds: 60 },\n        // three claim codes per address per ten minutes; pass a HASH of the\n        // address as `email_hash`, never the address itself (it becomes a key)\n        { name: 'claim-request', key_template: '{tenant_id}:{email_hash}', limit: 3, window_seconds: 600, behavior: 'block' },\n      ],\n    },\n\n    webhooks: {\n      enabled: true,\n      // FAILURE ALERTS. Every error-level failure event in this backend (a dead\n      // delivery, a failed generation, a missed schedule) is digested into a\n      // mail to the project's owner accounts every 15 minutes. Recipients are\n      // deliberately not configurable; `digestMinutes: 0` makes it immediate.\n      alerts: { enabled: true, minLevel: 'error', digestMinutes: 15 },\n      // DECLARED API STATE #2 \u2014 an outbound subscription. Converged by\n      // target_url on push; a live row you did not declare is left and\n      // reported. The three function triggers below are NOT declared here \u2014\n      // their subscriptions derive from the functions manifest.\n      subscriptions: [\n        { target_url: 'https://ops.studio.example/vxil/events', event_prefixes: ['payments.', 'auth.user.'] },\n      ],\n    },\n\n    ai: {\n      enabled: true,\n      defaultProvider: 'mock', // BYO key later: providers.openaiKeyRef / anthropicKeyRef / geminiKeyRef\n      defaults: { maxTokens: 800, temperature: 0.4 },\n      // DECLARED API STATE #3 \u2014 the stored prompt template. Converged by\n      // CONTENT: a push stores a new version only when the text changed, so\n      // pushes are idempotent and versions stay monotonic. vxil stores and\n      // renders it; the wording is yours.\n      templates: [\n        {\n          template: 'studio-brief',\n          system:\n            'You are a senior brand strategist. Write in plain, confident English. ' +\n            'Never invent facts about the client; when something is unknown, say what you would need.',\n          user:\n            'Write a one-page creative brief for a studio client.\\n\\n' +\n            'Goal: {{goal}}\\nAudience: {{audience}}\\nTone: {{tone}}\\nConstraints: {{constraints}}\\n\\n' +\n            'Sections: Objective, Audience insight, Key message, Deliverables, Next steps.',\n        },\n      ],\n    },\n\n    // The job lane the brief runs on. `retry` is the ladder for JOB RUNS \u2014 the\n    // generation itself, and deliveries to your own endpoints. It is NOT a\n    // retry of what a platform-delivered function ANSWERS: the dispatcher ACKs\n    // every trigger delivery with a 200 whatever the function returned (guide\n    // 08, \"What is retried, and what is not\"), so the three functions below\n    // make their failures recoverable through the rows they own \u2014 a 5xx from\n    // one of them is observed (`functions.run.failed` \u2192 `webhooks.alerts`),\n    // never re-delivered.\n    jobs: { enabled: true, retry: { defaultMaxAttempts: 3 } },\n\n    // A payments INTEGRATION: the tenant's own Stripe/Paddle/PayPal/RevenueCat\n    // account; vxil is never in the flow of funds. `mock` needs no account and\n    // runs everything UP TO the paywall \u2014 push, deploy, the intake, the claim\n    // and every refusal (402 pass_required, 409 intake_incomplete). It cannot\n    // put a PAID charge on the ledger: its checkout URL is a placeholder, its\n    // webhooks are signed with the platform's secret, and\n    // `vx.payments.simulate` scripts subscriptions, not one-off charges \u2014 so on\n    // `mock` grant-pass never wakes and start-brief answers 402 to everyone.\n    // The paid path needs your provider's sandbox (README, \"Running the paid\n    // path\"), e.g. a Stripe test-mode account:\n    //   payments: { enabled: true, provider: 'stripe', defaults: { currency: 'usd' },\n    //     stripe: { secretKeyRef: 'stripe_secret', webhookSecretRef: 'stripe_webhook' } },\n    payments: { enabled: true, provider: 'mock', defaults: { currency: 'usd' } },\n\n    functions: { enabled: true },\n  },\n\n  // \u2500\u2500 Schema-as-code (\u22648 index slots per collection: s1\u2013s4/n1\u2013n2/t1\u2013t2) \u2500\u2500\u2500\u2500\u2500\u2500\n  cms: {\n    collections: {\n      // One row per visitor intake. Created and stepped by the browser as the\n      // (guest, then claimed) end-user; completed and settled by functions.\n      funnel_sessions: {\n        singular: 'funnel_session',\n        // The owner. In end-user mode the platform STAMPS this with the verified\n        // user id on create and scopes every read/patch/delete to it \u2014 a body\n        // naming someone else is a 400, and a foreign row is an honest 404.\n        ownerField: 'user',\n        fields: {\n          user: { type: 'string', required: true, indexSlot: 's1' },\n          status: { type: 'string', indexSlot: 's2', validation: { enum: ['in_progress', 'completed'] } },\n          generation_id: { type: 'string', indexSlot: 's3' }, // the job-lane generation that owns the result\n          result_status: { type: 'string', indexSlot: 's4', validation: { enum: ['queued', 'completed', 'failed'] } },\n          step: { type: 'int', indexSlot: 'n1', validation: { min: 1, max: 4 } }, // 1..4, forward only\n          started_at: { type: 'datetime', indexSlot: 't1' },\n          completed_at: { type: 'datetime', indexSlot: 't2' },\n          answers: { type: 'json' }, // { goal, audience, tone, constraints } \u2014 the template's inputs\n          result: { type: 'text' }, // the settled brief\n          error_hint: { type: 'string' }, // the provider's own words when the brief failed\n        },\n      },\n\n      // One row per PAID pass, written by the grant function on the provider's\n      // charge event. `charge_id` is the dedupe anchor: an at-least-once\n      // redelivery of the same charge is a clean 409 the function treats as\n      // \"already granted\". It is the DISPLAY RECORD, never the entitlement: the\n      // collection is owned, so the visitor's own thin-client key (cms:write)\n      // can create a pass or stretch its expires_at \u2014 start-brief decides from\n      // the owner-bound payments ledger instead.\n      passes: {\n        singular: 'pass',\n        ownerField: 'user',\n        fields: {\n          user: { type: 'string', required: true, indexSlot: 's1' },\n          charge_id: { type: 'string', required: true, unique: true, indexSlot: 's2' },\n          product: { type: 'string', indexSlot: 's3' },\n          amount_cents: { type: 'int', indexSlot: 'n1' },\n          granted_at: { type: 'datetime', indexSlot: 't1' },\n          expires_at: { type: 'datetime', indexSlot: 't2' }, // the brief function's range filter\n        },\n      },\n    },\n  },\n\n  // \u2500\u2500 The domain logic that ISN'T config: three event-driven functions \u2500\u2500\u2500\u2500\u2500\u2500\n  functions: {\n    // THE BRIEF. Invoked by the browser AS THE SIGNED-IN VISITOR\n    // (vx.asEndUser(token).fn['start-brief']({ session_id })): the end-user\n    // principal rides into the function, so its cms reads are owner-scoped and\n    // the generation is billed to that user. Requires a PAID pass, read from\n    // the owner-bound ledger (`payments:read`) on every call \u2014 never from the\n    // visitor-writable `passes` row, which it re-writes as the record when a\n    // grant delivery was lost; CLAIMS the row with If-Match before spending\n    // anything (a double click is one generation);\n    // starts the brief on the ai JOB lane with correlation_id = the session row id.\n    'start-brief': {\n      entry: './functions/start-brief.ts',\n      trigger: { kind: 'http' },\n      scopes: ['cms:read', 'cms:write', 'ai:write', 'payments:read'],\n      egressAllow: [],\n      signature: {\n        input: { session_id: 'string' },\n        // Two 202 answers, so the output is a whole TS type (a union): a new\n        // brief's handle, or `already_queued` when one is running \u2014 whose\n        // generation_id is null while that claim has not recorded its handle.\n        output:\n          '{ generation_id: string; run_id: string; correlation_id: string }' +\n          \" | { generation_id: string | null; status: 'already_queued' }\",\n      },\n    },\n\n    // THE GRANT. Woken by ONE platform event \u2014 `payments.charge.succeeded`, the\n    // full event name as the `source` (the prefix `payments.charge.` would wake\n    // it twice per Paddle charge, on `succeeded` and on `completed`) \u2014 a few\n    // seconds after your provider's webhook folds. If your pass were a TIER for\n    // a number of days rather than a count of briefs, you would not write this\n    // function at all: `payments.ledger.productMap['studio-pass'] = { tier: 'pass',\n    // durationDays: 30 }` and the platform writes the pass on the charge event\n    // (stacking, refund-aware). Re-reads the charge from the ledger (the event name is a\n    // routing claim, not an attestation), then writes the pass. A 5xx from it\n    // is ACKed and observed, not re-delivered \u2014 start-brief decides from the\n    // same ledger, so a lost grant never blocks a payer.\n    'grant-pass': {\n      entry: './functions/grant-pass.ts',\n      trigger: { kind: 'webhook', source: 'payments.charge.succeeded' },\n      scopes: ['payments:read', 'cms:write'],\n      egressAllow: [],\n    },\n\n    // THE SETTLE. Woken by the `job.generation.` prefix \u2014 completed AND failed \u2014\n    // and finds its own row through the event's `correlation_id` (no run\u2192record\n    // table of your own). On completed: the brief text from the replay buffer\n    // + a \"ready\" message. On failed: `error_hint` \u2014 the provider's own words \u2014\n    // onto the row, so the visitor sees why, not just that. A settle that\n    // cannot complete marks the row `failed` (the retry is one click) \u2014 the\n    // delivery is ACKed whatever it answers, so recovery lives in the row.\n    'settle-brief': {\n      entry: './functions/settle-brief.ts',\n      trigger: { kind: 'webhook', source: 'job.generation.' },\n      scopes: ['cms:read', 'cms:write', 'ai:read', 'notifications:send'],\n      egressAllow: [],\n    },\n  },\n});\n",
-    "readme": "# Funnel SaaS \u2014 the studio starter (saas)\n\nThe **web-first funnel** blueprint: a visitor lands, starts as a **guest**, walks a guided intake,\n**claims** the session with an e-mail code, buys a **pass** through your own payments provider,\nand gets an AI-written brief **settled back onto their record** \u2014 all of it declared in one typed\n`vxil.config.ts`, with three small functions for the parts that are code.\n\nIt is the shape most \"studio\" products have \u2014 a lead magnet, a paid deliverable, an account that\nonly exists once someone cares \u2014 and it is also the blueprint that shows **declared API state**:\nrate-limit policies, an outbound subscription and a stored prompt template live in the config and\nconverge on `vxil push`, so a second environment is a push, not a runbook.\n\n```bash\nvxil init --template funnel-saas\nvxil quickstart                       # or `vxil link <slug>` for an existing backend\nvxil push                             # collections + hooks + the three functions + the declared API state\nvxil gen                              # typed SDK: vx.from('funnel_sessions'), vx.fn['start-brief']\n```\n\n**What it provisions:**\n- `funnel_sessions` \u2014 `user` (the **owner field**), `status` (`in_progress \u2192 completed`, hook-guarded),\n  `step` (1\u20134, forward only), `answers` (json), then the brief's `generation_id`, `result_status`\n  (`queued | completed | failed`), `result` and `error_hint`.\n- `passes` \u2014 `user` (owner), `charge_id` (**unique** \u2014 the dedupe anchor), `product`, `amount_cents`,\n  `granted_at`, `expires_at`. The record the page shows \u2014 the payments ledger is the entitlement.\n- Features: `auth` (guest + OTP claim + a refreshable session pair) \xB7 `cms` (**`strictEndUserScope: true`**) \xB7\n  `rate-limits` (two **declared policies**) \xB7 `webhooks` (**`alerts` on** + one **declared subscription**) \xB7\n  `ai` (one **declared template**) \xB7 `jobs` \xB7 `payments` (a payments **integration** \u2014 your provider; `mock`\n  here, which runs everything *up to* the paywall \u2014 [Running the paid path](#running-the-paid-path)) \xB7\n  `notifications` (`mock`) \xB7 `functions`.\n- Functions: `start-brief` (http, invoked as the visitor), `grant-pass` (webhook on\n  `payments.charge.succeeded`), `settle-brief` (webhook on the `job.generation.` prefix).\n\n> **A simpler pass, if your pass is a tier for a number of days.** Since 2026-09-25 a\n> `ledger.productMap` entry may be `{ tier: 'pass', durationDays: 30 }`: the platform then writes\n> the pass itself on the charge event (stacking behind a live one, ended by a full refund or\n> chargeback), and `GET /v1/payments/entitlements` answers \"is this visitor on a pass, until when\".\n> This blueprint keeps its own `passes` record and `grant-pass` function on purpose \u2014 its pass is a\n> *count of briefs*, decided from the owner-bound charge ledger, not a tier for a duration.\n\n## The funnel, step by step\n\nEvery call below is the browser talking to your backend \u2014 with **two keys**, the way\nvxil.com/docs/guide/09-security-and-multitenancy prescribes: a **sign-in key** (the ordinary class,\ncarrying only `auth:signin`) for the moment *before* there is a session, and a **thin-client key**\n(`key_class: 'public'` \u2014 `cms:read`, `cms:write`, `functions:invoke`) for everything after, which the\nedge refuses unless it rides with a valid end-user token. A public key *cannot* carry `payments:write`\n(a `422` at mint), so the checkout is the one call your server makes \u2014 the last section.\n\n```ts\nimport { Vxil } from '@vxil/sdk';\nconst signin = Vxil.connect({ apiKey: SIGNIN_KEY });        // auth:signin only \u2014 works with no session\nconst thin = Vxil.connect({ apiKey: THIN_CLIENT_KEY });     // public class \u2014 needs a session on every call\n\n// 1. A guest. Real user id, real session, no e-mail yet (the token carries `anon: true`).\nconst guest = await signin.auth.anonymous.signIn();\nconst me = thin.asEndUser(guest.session.token);\n\n// 2. The intake. Owner-scoped: the platform stamps `user` with the guest's id on create,\n//    and this session (and only this session) can read and step the row.\nconst { item_id: session_id } = await me.from('funnel_sessions').create({\n  status: 'in_progress', step: 1, started_at: new Date().toISOString(),\n  answers: { goal: 'Launch a coffee subscription' },\n});\nawait me.from('funnel_sessions').patch(session_id, { step: 2, answers: { goal: '\u2026', audience: '\u2026' } });\n// \u2026steps 3 and 4. A PATCH that moves `step` backwards is a 422 from the `steps_forward_only` hook.\n\n// 3. The claim. A 6-digit code proves the address; the guest is PROMOTED IN PLACE \u2014\n//    same user id, so the intake rows are already theirs. (Sign-in class: the sign-in key.)\nawait signin.auth.anonymous.link.request({ token: guest.session.token, email: 'ada@example.com' });\nconst claimed = await signin.auth.anonymous.link.verify({ token: guest.session.token, email: 'ada@example.com', code: '123456' });\n// claimed.user_id === guest.user_id \u2014 unless the address already had an account: then\n// `merged: true`, a fresh session, and `rekeyed` says whether the guest's rows moved already.\n\n// 4. The pass \u2014 only after the claim. Your SERVER refuses a guest, creates the hosted checkout\n//    (below) and hands the URL back; the provider's webhook folds the charge \u2192\n//    `payments.charge.succeeded` \u2192 grant-pass writes the pass record.\n\n// 5. The brief. Invoked AS THE VISITOR: the function's reads are owner-scoped and the\n//    generation is metered to them. Until the visitor's ledger holds a paid charge the call\n//    throws a VxilError whose `.code` is 'pass_required' (402); an unfinished intake is\n//    'intake_incomplete' (409).\nconst handle = await me.fn['start-brief']({ session_id });\n// \u2192 { generation_id, run_id, correlation_id } for a new brief, or \u2014 a second click while one\n//    is running \u2014 { generation_id, status: 'already_queued' }: one generation, metered once,\n//    and `generation_id` is null while that attempt has not recorded its handle yet (the\n//    declared signature is that union). Either way, watch the ROW, not the handle:\n// \u2026seconds to minutes later, settle-brief writes `result` (or `error_hint`) onto the row and\n//    notifications delivers \"Your brief is ready\". A failed brief can be started again: the\n//    same call on a row whose result_status is 'failed' queues a new generation.\n```\n\n## What to learn from this\n\n- **`strictEndUserScope: true` is the fail-safe version of owner scoping.** Both collections declare an\n  `ownerField`, so a signed-in visitor reaches exactly their own rows; a collection you add later *without*\n  one is `403 server_only` for end-users on read and write instead of tenant-wide-shared. Nothing about a\n  server call changes \u2014 a server key still sees everything\n  (vxil.com/docs/guide/09-security-and-multitenancy).\n- **A guest is a real end-user.** `vx.auth.anonymous.signIn()` mints a real id; owner-scoped rows written\n  before the claim stay attached because the OTP claim (`POST /v1/auth/anonymous/link/request` + `/verify`)\n  promotes the guest in place. Passing the guest's token as `anonymous_token` on a magic-link request does\n  the same through mail (vxil.com/docs/guide/06-feature-catalog).\n- **Declared API state.** Three things that used to be rows you created by hand \u2014 and re-created in every\n  environment \u2014 are config now, and `vxil push` converges the live rows onto them, reporting (never\n  deleting) what you did not declare:\n\n  | Block | Converged by | The live rows it replaces |\n  |---|---|---|\n  | `features['rate-limits'].policies[]` | `name` | `POST /v1/rate-limits/policies` |\n  | `features.webhooks.subscriptions[]` | `target_url` | `POST /v1/webhooks/subscriptions` |\n  | `features.ai.templates[]` | content hash | `POST /v1/ai/templates` (a new version only when the text changed) |\n\n  The three function triggers are *not* declared here \u2014 a `webhook`-trigger binding on a function is its\n  own declaration, and the platform reconciles that subscription from the functions manifest.\n- **An event-driven grant, done honestly.** `grant-pass` wakes on the full event name\n  `payments.charge.succeeded` a few seconds after your provider's webhook folds. The event name is a\n  *routing claim*, so the function re-reads the ledger (`GET /v1/payments/charges`) before writing; the\n  `passes.charge_id` unique field (the ledger's charge id) turns an at-least-once redelivery into a `409`\n  it reads as \"already granted\". And it is honest about **what is not retried**: the dispatcher ACKs a\n  platform-delivered function with a `200` *whatever it answered*, so a `5xx` from the API is never\n  re-delivered \u2014 it is *observed* (`functions.run.failed`, once per failure streak, in the\n  `webhooks.alerts` digest), and recovery is data, not delivery: `start-brief` decides from the same\n  owner-bound ledger on every request, so a lost grant never blocks a payer, and it writes the missing\n  pass record for that charge (a `409` there just means it is recorded already)\n  (vxil.com/docs/guide/08-running-your-code-functions).\n- **An owned row the visitor can write is never an entitlement.** `passes` declares an `ownerField`, so\n  the thin-client key (`cms:write`) lets a visitor *create* a pass of their own or PATCH its\n  `expires_at` to 2099 \u2014 the platform stamps them as the owner, which proves who wrote the row, not that\n  anyone paid, and a write hook's `caller` is always `null`, so no hook can tell that write from\n  `grant-pass`'s (vxil.com/docs/guide/07-validation-and-hooks). So `start-brief` never reads `passes` to\n  decide: on every call it reads `GET /v1/payments/charges?status=succeeded` as the visitor (bound to\n  the verified principal; no key a browser holds can write the ledger) and needs a succeeded, unrefunded\n  charge from the last 365 days. The pass row is what the page *shows*; the ledger is what it *checks*.\n- **`correlation_id` closes the loop.** `start-brief` sends the session row id as `correlation_id` on\n  `POST /v1/ai/generate` (`mode: 'job'`); the platform echoes it on `job.generation.completed` /\n  `job.generation.failed` next to `generation_id`, so `settle-brief` finds its own row from the event alone.\n  On `failed` it writes **`error_hint`** \u2014 the provider's own status and message \u2014 onto the row, so the\n  visitor sees *why* (and `start-brief` accepts that row again, so a retry is one more click); on\n  `completed` the text comes from the generation's replay buffer\n  (`GET /v1/ai/generations/{generation_id}/stream?since=0`). Every settle write carries\n  `if: { generation_id }`, so a late delivery for an earlier attempt can never overwrite a newer one; and a\n  settle that cannot complete marks the row `failed` with `settle failed: <reason>` instead of answering a\n  status nothing will act on \u2014 the row, not the delivery, is where recovery lives.\n- **The claim comes before the spend.** `start-brief` reads the row's `version`, PATCHes\n  `result_status: 'queued'` with `If-Match: <version>`, and only then calls generate. A double click that\n  lands inside the generate round-trip loses the compare-and-set with `409 version_conflict` and gets a\n  `202 already_queued` \u2014 one generation, one credit reserve. A claim whose generate never recorded, or a\n  queued handle older than the job lane's ceiling, is treated as failed on the next click, so a row can\n  never stick in `queued`. Every write after the claim (recording the handle, marking a failure) carries\n  `If-Match: <the claim's version>`, so an attempt the next click already swept can never overwrite the\n  newer claim \u2014 its `409` means \"the row moved on\", and it steps aside without a write.\n- **Function errors are coded.** Every refusal a function answers is `{ error: { code, message } }` \u2014\n  `POST /v1/fn/:name` hands that body back verbatim, and the SDK raises it as a `VxilError` whose `.code`\n  is the function's own (`pass_required`, `intake_incomplete`, `already_settled`), so a page branches on a\n  code, never on a message. The platform-delivered functions answer `200 { skipped }` for a decision, and a\n  `500` with a code (`unsettled`, `grant_unsettled`) only when not even the row could record the failure \u2014\n  not to be retried (nothing re-delivers it) but to be *seen* through `functions.run.failed`.\n- **Failure alerts are on.** `webhooks.alerts` mails the project's owner accounts every 15 minutes with the\n  error-level failure events \u2014 a dead delivery, a failed generation, a missed schedule. Recipients are\n  deliberately not configurable; `digestMinutes: 0` makes it immediate.\n- **The payments feature is an integration.** Your Stripe, Paddle, PayPal or RevenueCat account, the\n  provider's hosted checkout, the provider's webhook; vxil folds the events and keeps the ledger. The\n  scaffold's `mock` provider stops at the paywall, so the paid path runs on your provider's sandbox \u2014 the\n  next section. To rehearse the grant chain without a card, Paddle's simulator signs with your real endpoint\n  secret and your `payments.` functions run for real (vxil.com/docs/guide/06-feature-catalog).\n\n## Server side: keep the visitor's token fresh\n\nA session token lives `session.ttlMinutes` (60 here); the cookie your app sets lives days. Every sign-in\nreturns a pair \u2014 the token and a `refresh_token` good for `session.refreshTtlDays` (30) \u2014 and\n`POST /v1/auth/sessions/refresh` rotates it. So a server-rendered app needs one root middleware, not a\nredesign (vxil.com/docs/guide/09-security-and-multitenancy):\n\n```ts\n// once per request, before any loader runs\nconst { token, refresh_token, expires_at } = readSessionCookie(request);\nlet session = { token, refresh_token, expires_at };\nif (Date.parse(expires_at) - Date.now() < 5 * 60_000) {          // within 5 min of expiry (or past it)\n  try {\n    session = (await vx.auth.sessions.refresh(refresh_token)).session;   // rotated pair\n    setSessionCookie(response, session);                          // store BOTH halves again\n  } catch {\n    clearSessionCookie(response);                                 // refresh revoked or expired: sign in again\n  }\n}\nconst asUser = vx.asEndUser(session.token);                       // every per-visitor read below is scoped by the platform\n```\n\nStore the refresh token only in the `HttpOnly` cookie; refresh *early* rather than on `401`, so parallel\nloaders do not race to rotate the same token; keep the server key for the tenant-wide rows only.\n\nThe same server owns the **checkout** \u2014 `POST /v1/payments/checkout-sessions` needs `payments:write`, which\na public key cannot carry, and it is server-only (a `403 server_only` in end-user mode). Three rules shape it:\n\n- **The buyer is the session, never a form field.** Ask the platform whose token it is:\n  `vx.auth.sessions.verify` answers with the account *as it is now* (`auth:read` on the server key).\n- **A guest cannot buy \u2014 claim first.** A charge stays with the user id that paid it. When a guest claims an\n  address that already has an account, the merge re-keys the guest's subscriptions, customer links and\n  credit balances onto that account (vxil.com/docs/guide/06-feature-catalog, \"What a merge moves\") \u2014 not its\n  one-off charges \u2014 and `start-brief` decides from the charges ledger. A guest who paid and *then* merged\n  would have paid for a brief the merged account can never start. So refuse the checkout until the claim:\n  `verified` is `false` while the visitor has no proven address \u2014 a guest has none, and the claim *is* the\n  proof (every other way into this blueprint, a magic link or a code, proves one too). Not the token's\n  `anon` claim: that is a snapshot from when the token was minted, not the account as it is now.\n- **One Idempotency-Key per purchase *attempt*, never per visitor.** A key the payments feature has seen\n  replays its first session verbatim, and the key never expires \u2014 so `pass:${user_id}` would hand a visitor\n  whose checkout expired, who was refunded, or who comes back after the 365-day pass the same dead URL\n  forever. Key the attempt: the buy page renders a fresh attempt id into its form, so a double click posts\n  the same id (one session), while a reload, a return from the checkout or next year's renewal renders a\n  new one. The id is not a credential \u2014 the `user_id` next to it is the verified one, so an invented id\n  only ever opens another checkout for the visitor's own account.\n\n```ts\n// the visitor is signed in (the middleware above keeps `session` fresh); the form posts `attempt`\nconst who = await vx.auth.sessions.verify(session.token);         // { user_id, verified, \u2026 } \u2014 the account NOW\nif (!who.verified) {                                              // still a guest: charges never follow a merge\n  return Response.json({ error: { code: 'claim_required', message: 'claim your e-mail before you buy' } }, { status: 409 });\n}\nconst attempt = String(form.get('attempt') ?? '');                // crypto.randomUUID(), rendered with the buy page\nif (!/^[\\w-]{16,64}$/.test(attempt)) {\n  return Response.json({ error: { code: 'bad_attempt', message: 'reload the page and try again' } }, { status: 400 });\n}\nconst { url } = await vx.payments.createCheckoutSession(\n  { user_id: who.user_id, mode: 'payment',\n    line_items: [{ price_ref: 'studio-pass', amount_cents: 4900 }],   // a real provider takes ITS price id \u2014 below\n    success_url: 'https://studio.example/thanks', cancel_url: 'https://studio.example/pass' },\n  { idempotencyKey: `pass:${who.user_id}:${attempt}` },\n);\n// redirect the visitor to `url` \u2014 a hosted checkout on YOUR provider; vxil is never in the flow of funds.\n```\n\nThe same server is where the declared rate-limit policies are checked. `POST /v1/rate-limits/check` takes a\n`policy_id`, never a name \u2014 list the policies once after the first push and keep the two ids:\n\n```ts\nconst policies = await vx.rateLimits.listPolicies();                  // RateLimitPolicy[] \u2014 \u2264100, no cursor\nconst stepPolicy = policies.find((p) => p.name === 'funnel-step')!.policy_id;\n// before forwarding a step write\nawait vx.rateLimits.check({ policy_id: stepPolicy, key_values: { user_id }, cost: 1 });   // 429 + Retry-After when blocked\n// before forwarding a claim request \u2014 a HASH of the address, never the address (it becomes a key)\nawait vx.rateLimits.check({ policy_id: claimPolicy, key_values: { email_hash: sha256(email) } });\n```\n\n## Running the paid path\n\nThe scaffold ships `payments.provider: 'mock'`, so `vxil push` works with no provider account, and\neverything but the payment runs on it: the intake, the claim, the deploy, and every refusal\n(`402 pass_required`, `409 intake_incomplete`, a guest's `claim_required`). What `mock` cannot do is put a\n**paid** charge on the ledger: its checkout URL is a placeholder host nothing serves, its webhooks are\nsigned with the platform's own secret rather than one you hold, and `vx.payments.simulate` scripts\n*subscription* lifecycles, not a one-off charge. So on `mock`, `grant-pass` never wakes and `start-brief`\nanswers `402 pass_required` to every visitor \u2014 the paywall doing its job. To run the brief end to end,\npoint the block at your provider's sandbox, in a project of its own (the signing-secret ref is one per\nprovider \u2014 vxil.com/docs/guide/06-feature-catalog):\n\n```ts\n// vxil.config.ts \u2014 a Stripe TEST-mode account (a Paddle sandbox is `provider: 'paddle'` + `paddle: { \u2026 }`)\npayments: {\n  enabled: true, provider: 'stripe', defaults: { currency: 'usd' },\n  stripe: { secretKeyRef: 'stripe_secret', webhookSecretRef: 'stripe_webhook' },\n},\n```\n\n```bash\nvxil secrets set payments/stripe_secret       # the test-mode secret key, at the hidden prompt\nvxil secrets set payments/stripe_webhook      # the signing secret of the endpoint below\nvxil push\n```\n\nRegister `https://api.vxil.com/v1/internal/payments/webhook/stripe/<tenantId>` as the endpoint in the\nprovider's dashboard. On a real provider `line_items[].price_ref` is the provider's own price id (Stripe\n`price_\u2026`), not `studio-pass`. Pay with the provider's test card: the charge folds \u2192\n`payments.charge.succeeded` \u2192 `grant-pass` records the pass, and the next `start-brief` queues the brief.\n\n**Go deeper:** vxil.com/docs/guide/09-security-and-multitenancy (end-user mode \xB7 `strictEndUserScope` \xB7 the\nrefresh middleware) \xB7 vxil.com/docs/guide/06-feature-catalog (auth guests and claims \xB7 rate-limits \xB7\nwebhooks alerts and declared subscriptions \xB7 ai `mode: 'job'` \xB7 payments) \xB7\nvxil.com/docs/guide/08-running-your-code-functions (the `webhook` trigger \xB7 at-least-once) \xB7\nvxil.com/docs/guide/04-data-with-cms (owner scoping \xB7 the query DSL).\n\n**Own the shape.** The config is yours after `init` \u2014 nothing is locked.\n",
+    "readme": "# Funnel SaaS \u2014 the studio starter (saas)\n\nThe **web-first funnel** blueprint: a visitor lands, starts as a **guest**, walks a guided intake,\n**claims** the session with an e-mail code, buys a **pass** through your own payments provider,\nand gets an AI-written brief **settled back onto their record** \u2014 all of it declared in one typed\n`vxil.config.ts`, with three small functions for the parts that are code.\n\nIt is the shape most \"studio\" products have \u2014 a lead magnet, a paid deliverable, an account that\nonly exists once someone cares \u2014 and it is also the blueprint that shows **declared API state**:\nrate-limit policies, an outbound subscription and a stored prompt template live in the config and\nconverge on `vxil push`, so a second environment is a push, not a runbook.\n\n```bash\nvxil init --template funnel-saas\nvxil quickstart                       # or `vxil link <slug>` for an existing backend\nvxil push                             # collections + hooks + the three functions + the declared API state\nvxil gen                              # typed SDK: vx.from('funnel_sessions'), vx.fn['start-brief']\n```\n\n**What it provisions:**\n- `funnel_sessions` \u2014 `user` (the **owner field**), `status` (`in_progress \u2192 completed`, hook-guarded),\n  `step` (1\u20134, forward only), `answers` (json), then the brief's `generation_id`, `result_status`\n  (`queued | completed | failed`), `result` and `error_hint`.\n- `passes` \u2014 `user` (owner), `charge_id` (**unique** \u2014 the dedupe anchor), `product`, `amount_cents`,\n  `granted_at`, `expires_at`. The record the page shows \u2014 the payments ledger is the entitlement.\n- Features: `auth` (guest + OTP claim + a refreshable session pair) \xB7 `cms` (**`strictEndUserScope: true`**) \xB7\n  `rate-limits` (two **declared policies**) \xB7 `webhooks` (**`alerts` on** + one **declared subscription**) \xB7\n  `ai` (one **declared template**) \xB7 `jobs` \xB7 `payments` (a payments **integration** \u2014 your provider; `mock`\n  here, which runs everything *up to* the paywall \u2014 [Running the paid path](#running-the-paid-path)) \xB7\n  `notifications` (`mock`) \xB7 `functions`.\n- Functions: `start-brief` (http, invoked as the visitor), `grant-pass` (webhook on\n  `payments.charge.succeeded`), `settle-brief` (webhook on the `job.generation.` prefix).\n\n> **A simpler pass, if your pass is a tier for a number of days.** Since 2026-09-25 a\n> `ledger.productMap` entry may be `{ tier: 'pass', durationDays: 30 }`: the platform then writes\n> the pass itself on the charge event (stacking behind a live one, ended by a full refund or\n> chargeback), and `GET /v1/payments/entitlements` answers \"is this visitor on a pass, until when\".\n> This blueprint keeps its own `passes` record and `grant-pass` function on purpose \u2014 its pass is a\n> *count of briefs*, decided from the owner-bound charge ledger, not a tier for a duration.\n\n## The funnel, step by step\n\nEvery call below is the browser talking to your backend \u2014 with **two keys**, the way\nvxil.com/docs/guide/09-security-and-multitenancy prescribes: a **sign-in key** (the ordinary class,\ncarrying only `auth:signin`) for the moment *before* there is a session, and a **thin-client key**\n(`key_class: 'public'` \u2014 `cms:read`, `cms:write`, `functions:invoke`) for everything after, which the\nedge refuses unless it rides with a valid end-user token. A public key *cannot* carry `payments:write`\n(a `422` at mint), so the checkout is the one call your server makes \u2014 the last section.\n\n```ts\nimport { Vxil } from '@vxil/sdk';\nconst signin = Vxil.connect({ apiKey: SIGNIN_KEY });        // auth:signin only \u2014 works with no session\nconst thin = Vxil.connect({ apiKey: THIN_CLIENT_KEY });     // public class \u2014 needs a session on every call\n\n// 1. A guest. Real user id, real session, no e-mail yet (the token carries `anon: true`).\nconst guest = await signin.auth.anonymous.signIn();\nconst me = thin.asEndUser(guest.session.token);\n\n// 2. The intake. Owner-scoped: the platform stamps `user` with the guest's id on create,\n//    and this session (and only this session) can read and step the row.\nconst { item_id: session_id } = await me.from('funnel_sessions').create({\n  status: 'in_progress', step: 1, started_at: new Date().toISOString(),\n  answers: { goal: 'Launch a coffee subscription' },\n});\nawait me.from('funnel_sessions').patch(session_id, { step: 2, answers: { goal: '\u2026', audience: '\u2026' } });\n// \u2026steps 3 and 4. A PATCH that moves `step` backwards is a 422 from the `steps_forward_only` hook.\n\n// 3. The claim. A 6-digit code proves the address; the guest is PROMOTED IN PLACE \u2014\n//    same user id, so the intake rows are already theirs. (Sign-in class: the sign-in key.)\nawait signin.auth.anonymous.link.request({ token: guest.session.token, email: 'ada@example.com' });\nconst claimed = await signin.auth.anonymous.link.verify({ token: guest.session.token, email: 'ada@example.com', code: '123456' });\n// claimed.user_id === guest.user_id \u2014 unless the address already had an account: then\n// `merged: true`, a fresh session, and `rekeyed` says whether the guest's rows moved already.\n\n// 4. The pass \u2014 only after the claim. Your SERVER refuses a guest, creates the hosted checkout\n//    (below) and hands the URL back; the provider's webhook folds the charge \u2192\n//    `payments.charge.succeeded` \u2192 grant-pass writes the pass record.\n\n// 5. The brief. Invoked AS THE VISITOR: the function's reads are owner-scoped and the\n//    generation is metered to them. Until the visitor's ledger holds a paid charge the call\n//    throws a VxilError whose `.code` is 'pass_required' (402); an unfinished intake is\n//    'intake_incomplete' (409).\nconst handle = await me.fn['start-brief']({ session_id });\n// \u2192 { generation_id, run_id, correlation_id } for a new brief, or \u2014 a second click while one\n//    is running \u2014 { generation_id, status: 'already_queued' }: one generation, metered once,\n//    and `generation_id` is null while that attempt has not recorded its handle yet (the\n//    declared signature is that union). Either way, watch the ROW, not the handle:\n// \u2026seconds to minutes later, settle-brief writes `result` (or `error_hint`) onto the row and\n//    notifications delivers \"Your brief is ready\". A failed brief can be started again: the\n//    same call on a row whose result_status is 'failed' queues a new generation.\n```\n\n## What to learn from this\n\n- **`strictEndUserScope: true` is the fail-safe version of owner scoping.** Both collections declare an\n  `ownerField`, so a signed-in visitor reaches exactly their own rows; a collection you add later *without*\n  one is `403 server_only` for end-users on read and write instead of tenant-wide-shared. Nothing about a\n  server call changes \u2014 a server key still sees everything\n  (vxil.com/docs/guide/09-security-and-multitenancy).\n- **A guest is a real end-user.** `vx.auth.anonymous.signIn()` mints a real id; owner-scoped rows written\n  before the claim stay attached because the OTP claim (`POST /v1/auth/anonymous/link/request` + `/verify`)\n  promotes the guest in place. Passing the guest's token as `anonymous_token` on a magic-link request does\n  the same through mail (vxil.com/docs/guide/06-feature-catalog).\n- **Declared API state.** Three things that used to be rows you created by hand \u2014 and re-created in every\n  environment \u2014 are config now, and `vxil push` converges the live rows onto them, reporting (never\n  deleting) what you did not declare:\n\n  | Block | Converged by | The live rows it replaces |\n  |---|---|---|\n  | `features['rate-limits'].policies[]` | `name` | `POST /v1/rate-limits/policies` |\n  | `features.webhooks.subscriptions[]` | `target_url` | `POST /v1/webhooks/subscriptions` |\n  | `features.ai.templates[]` | content hash | `POST /v1/ai/templates` (a new version only when the text changed) |\n\n  The three function triggers are *not* declared here \u2014 a `webhook`-trigger binding on a function is its\n  own declaration, and the platform reconciles that subscription from the functions manifest.\n- **An event-driven grant, done honestly.** `grant-pass` wakes on the full event name\n  `payments.charge.succeeded` a few seconds after your provider's webhook folds. The event name is a\n  *routing claim*, so the function re-reads the ledger (`GET /v1/payments/charges`) before writing; the\n  `passes.charge_id` unique field (the ledger's charge id) turns an at-least-once redelivery into a `409`\n  it reads as \"already granted\". And it is honest about **what is not retried**: the dispatcher ACKs a\n  platform-delivered function with a `200` *whatever it answered*, so a `5xx` from the API is never\n  re-delivered \u2014 it is *observed* (`functions.run.failed`, once per failure streak, in the\n  `webhooks.alerts` digest), and recovery is data, not delivery: `start-brief` decides from the same\n  owner-bound ledger on every request, so a lost grant never blocks a payer, and it writes the missing\n  pass record for that charge (a `409` there just means it is recorded already)\n  (vxil.com/docs/guide/08-running-your-code-functions).\n- **An owned row the visitor can write is never an entitlement.** `passes` declares an `ownerField`, so\n  the thin-client key (`cms:write`) lets a visitor *create* a pass of their own or PATCH its\n  `expires_at` to 2099 \u2014 the platform stamps them as the owner, which proves who wrote the row, not that\n  anyone paid, and a write hook's `caller` is always `null`, so no hook can tell that write from\n  `grant-pass`'s (vxil.com/docs/guide/07-validation-and-hooks). So `start-brief` never reads `passes` to\n  decide: on every call it reads `GET /v1/payments/charges?status=succeeded` as the visitor (bound to\n  the verified principal; no key a browser holds can write the ledger) and needs a succeeded, unrefunded\n  charge from the last 365 days. The pass row is what the page *shows*; the ledger is what it *checks*.\n- **`correlation_id` closes the loop.** `start-brief` sends the session row id as `correlation_id` on\n  `POST /v1/ai/generate` (`mode: 'job'`); the platform echoes it on `job.generation.completed` /\n  `job.generation.failed` next to `generation_id`, so `settle-brief` finds its own row from the event alone.\n  On `failed` it writes **`error_hint`** \u2014 the provider's own status and message \u2014 onto the row, so the\n  visitor sees *why* (and `start-brief` accepts that row again, so a retry is one more click); on\n  `completed` the text comes from the generation's replay buffer\n  (`GET /v1/ai/generations/{generation_id}/stream?since=0`). Every settle write carries\n  `if: { generation_id }`, so a late delivery for an earlier attempt can never overwrite a newer one; and a\n  settle that cannot complete marks the row `failed` with `settle failed: <reason>` instead of answering a\n  status nothing will act on \u2014 the row, not the delivery, is where recovery lives.\n- **The claim comes before the spend.** `start-brief` reads the row's `version`, PATCHes\n  `result_status: 'queued'` with `If-Match: <version>`, and only then calls generate. A double click that\n  lands inside the generate round-trip loses the compare-and-set with `409 version_conflict` and gets a\n  `202 already_queued` \u2014 one generation, one credit reserve. A claim whose generate never recorded, or a\n  queued handle older than the job lane's ceiling, is treated as failed on the next click, so a row can\n  never stick in `queued`. Every write after the claim (recording the handle, marking a failure) carries\n  `If-Match: <the claim's version>`, so an attempt the next click already swept can never overwrite the\n  newer claim \u2014 its `409` means \"the row moved on\", and it steps aside without a write.\n- **Function errors are coded.** Every refusal a function answers is `{ error: { code, message } }` \u2014\n  `POST /v1/fn/:name` hands that body back verbatim, and the SDK raises it as a `VxilError` whose `.code`\n  is the function's own (`pass_required`, `intake_incomplete`, `already_settled`), so a page branches on a\n  code, never on a message. The platform-delivered functions answer `200 { skipped }` for a decision, and a\n  `500` with a code (`unsettled`, `grant_unsettled`) only when not even the row could record the failure \u2014\n  not to be retried (nothing re-delivers it) but to be *seen* through `functions.run.failed`.\n- **Failure alerts are on.** `webhooks.alerts` mails the project's owner accounts every 15 minutes with the\n  error-level failure events \u2014 a dead delivery, a failed generation, a missed schedule. Recipients are\n  deliberately not configurable; `digestMinutes: 0` makes it immediate.\n- **The payments feature is an integration.** Your Stripe, Paddle, PayPal or RevenueCat account, the\n  provider's hosted checkout, the provider's webhook; vxil folds the events and keeps the ledger. The\n  scaffold's `mock` provider stops at the paywall, so the paid path runs on your provider's sandbox \u2014 the\n  next section. To rehearse the grant chain without a card, Paddle's simulator signs with your real endpoint\n  secret and your `payments.` functions run for real (vxil.com/docs/guide/06-feature-catalog).\n\n## Server side: keep the visitor's token fresh\n\nA session token lives `session.ttlMinutes` (60 here); the cookie your app sets lives days. Every sign-in\nreturns a pair \u2014 the token and a `refresh_token` good for `session.refreshTtlDays` (30) \u2014 and\n`vx.auth.sessions.ensureFresh(pair)` rotates it a few minutes before it expires (`POST /v1/auth/sessions/refresh`\nunderneath). So a server-rendered app needs one root middleware, not a redesign. The full recipe, with its\n`refreshFailure()` classifier and the `markRefreshFailed()` marker, is in\nvxil.com/docs/guide/09-security-and-multitenancy (\"Keeping the end-user token fresh behind a long-lived cookie\"):\n\n```ts\n// once per request, before any loader runs\nlet asUser = null;\nconst pair = readSessionCookie(request);                          // { token, refresh_token, expires_at }\nif (pair) {\n  try {\n    const { session, refreshed } = await vx.auth.sessions.ensureFresh(pair);\n    if (refreshed) setSessionCookie(response, session);           // rotated: store BOTH halves again\n    asUser = vx.asEndUser(session.token);                         // every per-visitor read below is scoped by the platform\n  } catch (e) {\n    // NOT \"sign in again\" on any failure \u2014 see below. refreshFailure() is guide 09's classifier.\n    const failure = refreshFailure(e, pair, readCookie(request, 'vx_refresh_failed'));\n    if (failure === 'dead') clearSessionCookie(response);         // revoked or expired: sign in again\n    if (failure === 'race') markRefreshFailed(response, pair);    // keep the cookie: the winner's is on its way\n    // 'transient': keep the cookie; this one request runs signed out\n  }\n}\n```\n\n**A failed refresh is not always a dead session.** Two requests carrying the same pair can reach two server\ninstances: one rotates, the other re-sends the refresh token that was revoked a moment ago and gets\n`401 invalid_refresh` \u2014 the same answer a truly revoked or expired token gets. Clearing the cookie on *any*\nfailure lets that loser's response overwrite the winner's new cookie, and a signed-in visitor is signed out for\nnothing. So the classifier keeps the cookie for anything that is not `invalid_refresh` (a network failure, a\ntimeout, a `429` or `5xx`), treats the first `invalid_refresh` of a pair as a lost race (a short-lived marker names\nthe pair), and clears the cookie only when the *same* pair fails again after a 15-second grace, or the cookie holds\nno refresh token at all.\n\nStore the refresh token only in the `HttpOnly` cookie; refresh *early* rather than on `401`, so parallel\nloaders in one process share one rotation; keep the server key for the tenant-wide rows only.\n\nThe same server owns the **checkout** \u2014 `POST /v1/payments/checkout-sessions` needs `payments:write`, which\na public key cannot carry, and it is server-only (a `403 server_only` in end-user mode). Three rules shape it:\n\n- **The buyer is the session, never a form field.** Ask the platform whose token it is:\n  `vx.auth.sessions.verify` answers with the account *as it is now* (`auth:read` on the server key).\n- **A guest cannot buy \u2014 claim first.** A charge stays with the user id that paid it. When a guest claims an\n  address that already has an account, the merge re-keys the guest's subscriptions, customer links and\n  credit balances onto that account (vxil.com/docs/guide/06-feature-catalog, \"What a merge moves\") \u2014 not its\n  one-off charges \u2014 and `start-brief` decides from the charges ledger. A guest who paid and *then* merged\n  would have paid for a brief the merged account can never start. So refuse the checkout until the claim:\n  `verified` is `false` while the visitor has no proven address \u2014 a guest has none, and the claim *is* the\n  proof (every other way into this blueprint, a magic link or a code, proves one too). Not the token's\n  `anon` claim: that is a snapshot from when the token was minted, not the account as it is now.\n- **One Idempotency-Key per purchase *attempt*, never per visitor.** A key the payments feature has seen\n  replays its first session verbatim, and the key never expires \u2014 so `pass:${user_id}` would hand a visitor\n  whose checkout expired, who was refunded, or who comes back after the 365-day pass the same dead URL\n  forever. Key the attempt: the buy page renders a fresh attempt id into its form, so a double click posts\n  the same id (one session), while a reload, a return from the checkout or next year's renewal renders a\n  new one. The id is not a credential \u2014 the `user_id` next to it is the verified one, so an invented id\n  only ever opens another checkout for the visitor's own account.\n\n```ts\n// the visitor is signed in (the middleware above keeps `session` fresh); the form posts `attempt`\nconst who = await vx.auth.sessions.verify(session.token);         // { user_id, verified, \u2026 } \u2014 the account NOW\nif (!who.verified) {                                              // still a guest: charges never follow a merge\n  return Response.json({ error: { code: 'claim_required', message: 'claim your e-mail before you buy' } }, { status: 409 });\n}\nconst attempt = String(form.get('attempt') ?? '');                // crypto.randomUUID(), rendered with the buy page\nif (!/^[\\w-]{16,64}$/.test(attempt)) {\n  return Response.json({ error: { code: 'bad_attempt', message: 'reload the page and try again' } }, { status: 400 });\n}\nconst { url } = await vx.payments.createCheckoutSession(\n  { user_id: who.user_id, mode: 'payment',\n    line_items: [{ price_ref: 'studio-pass', amount_cents: 4900 }],   // a real provider takes ITS price id \u2014 below\n    success_url: 'https://studio.example/thanks', cancel_url: 'https://studio.example/pass' },\n  { idempotencyKey: `pass:${who.user_id}:${attempt}` },\n);\n// redirect the visitor to `url` \u2014 a hosted checkout on YOUR provider; vxil is never in the flow of funds.\n```\n\nThe same server is where the declared rate-limit policies are checked. `POST /v1/rate-limits/check` takes a\n`policy_id`, never a name \u2014 list the policies once after the first push and keep the two ids:\n\n```ts\nconst policies = await vx.rateLimits.listPolicies();                  // RateLimitPolicy[] \u2014 \u2264100, no cursor\nconst stepPolicy = policies.find((p) => p.name === 'funnel-step')!.policy_id;\n// before forwarding a step write\nawait vx.rateLimits.check({ policy_id: stepPolicy, key_values: { user_id }, cost: 1 });   // 429 + Retry-After when blocked\n// before forwarding a claim request \u2014 a HASH of the address, never the address (it becomes a key)\nawait vx.rateLimits.check({ policy_id: claimPolicy, key_values: { email_hash: sha256(email) } });\n```\n\n## Running the paid path\n\nThe scaffold ships `payments.provider: 'mock'`, so `vxil push` works with no provider account, and\neverything but the payment runs on it: the intake, the claim, the deploy, and every refusal\n(`402 pass_required`, `409 intake_incomplete`, a guest's `claim_required`). What `mock` cannot do is put a\n**paid** charge on the ledger: its checkout URL is a placeholder host nothing serves, its webhooks are\nsigned with the platform's own secret rather than one you hold, and `vx.payments.simulate` scripts\n*subscription* lifecycles, not a one-off charge. So on `mock`, `grant-pass` never wakes and `start-brief`\nanswers `402 pass_required` to every visitor \u2014 the paywall doing its job. To run the brief end to end,\npoint the block at your provider's sandbox, in a project of its own (the signing-secret ref is one per\nprovider \u2014 vxil.com/docs/guide/06-feature-catalog):\n\n```ts\n// vxil.config.ts \u2014 a Stripe TEST-mode account (a Paddle sandbox is `provider: 'paddle'` + `paddle: { \u2026 }`)\npayments: {\n  enabled: true, provider: 'stripe', defaults: { currency: 'usd' },\n  stripe: { secretKeyRef: 'stripe_secret', webhookSecretRef: 'stripe_webhook' },\n},\n```\n\n```bash\nvxil secrets set payments/stripe_secret       # the test-mode secret key, at the hidden prompt\nvxil secrets set payments/stripe_webhook      # the signing secret of the endpoint below\nvxil push\n```\n\nRegister `https://api.vxil.com/v1/internal/payments/webhook/stripe/<tenantId>` as the endpoint in the\nprovider's dashboard. On a real provider `line_items[].price_ref` is the provider's own price id (Stripe\n`price_\u2026`), not `studio-pass`. Pay with the provider's test card: the charge folds \u2192\n`payments.charge.succeeded` \u2192 `grant-pass` records the pass, and the next `start-brief` queues the brief.\n\n**Go deeper:** vxil.com/docs/guide/09-security-and-multitenancy (end-user mode \xB7 `strictEndUserScope` \xB7 the\nrefresh middleware) \xB7 vxil.com/docs/guide/06-feature-catalog (auth guests and claims \xB7 rate-limits \xB7\nwebhooks alerts and declared subscriptions \xB7 ai `mode: 'job'` \xB7 payments) \xB7\nvxil.com/docs/guide/08-running-your-code-functions (the `webhook` trigger \xB7 at-least-once) \xB7\nvxil.com/docs/guide/04-data-with-cms (owner scoping \xB7 the query DSL).\n\n**Own the shape.** The config is yours after `init` \u2014 nothing is locked.\n",
     "functions": {
       "grant-pass.ts": "// grant-pass.ts \u2014 GRANT A PASS ON A SUCCESSFUL CHARGE (a vxil function, \xA77.3).\n//\n// Trigger: webhook, source 'payments.charge.succeeded' \u2014 the FULL event name, so\n// this function wakes for exactly one event: the moment your provider's webhook\n// (Stripe, Paddle, PayPal, RevenueCat, or the mock) folds a succeeded charge.\n// The platform wires the subscription for you on deploy; the first attempt is\n// delivered directly, a few seconds after the event.\n//\n// The envelope's `payload` is the event, flattened:\n//   { event, audit_id, occurred_at, actor, surface, data }\n// and `data` is the payments.charge.succeeded payload:\n//   { end_user_id, provider, provider_charge_id, amount_cents, currency, product_id, environment }\n//\n// THREE RULES this function lives by:\n//   \u2022 The event NAME is a routing claim, not an attestation \u2014 anyone who can\n//     enqueue a job in your own project can produce a delivery with a chosen\n//     name. So the ledger is re-read (GET /v1/payments/charges) before a pass\n//     is written; a charge the ledger does not know is skipped.\n//   \u2022 Delivery is at-least-once. `passes.charge_id` is UNIQUE (the LEDGER's\n//     charge id \u2014 the same key start-brief's record write uses), so a redelivery\n//     is a clean 409 unique_violation treated as \"already granted\".\n//   \u2022 Nothing this function ANSWERS is re-delivered. The dispatcher ACKs every\n//     platform-delivered trigger with a 200 whatever the handler returned\n//     (guide 08, \"What is retried, and what is not\") \u2014 so a 5xx here is not a\n//     retry request, it is the OBSERVATION channel: `functions.run.failed`\n//     (once per failure streak) \u2192 the `webhooks.alerts` digest. Recovery is\n//     data, not delivery: the pass row is a DISPLAY RECORD (an owned row the\n//     visitor's own key could write, so it is never the entitlement) \u2014\n//     start-brief decides from the same owner-bound ledger on every request,\n//     so a grant lost here never blocks a payer, and it re-writes the missing\n//     record. A decision (skip) answers 200 and is a decision.\n\nimport type { WebhookFunctionEnvelope } from '@vxil/sdk';\n\n/** the `payments.charge.succeeded` event payload (the fields read here) */\ninterface ChargeSucceeded {\n  end_user_id?: string | null;\n  provider_charge_id?: string | null;\n  amount_cents?: number | null;\n  currency?: string | null;\n  product_id?: string | null;\n}\ntype Env = WebhookFunctionEnvelope<ChargeSucceeded>;\ninterface Charge { charge_id: string; amount_cents: number; currency: string; status: string }\ninterface ChargeList { data?: { charges?: Charge[] } }\ninterface Created { data?: { item_id?: string } }\ninterface ErrBody { error?: { code?: string } }\n\nconst PASS_DAYS = 365; // mirrored in start-brief.ts (the ledger gate)\n\nexport default {\n  async fetch(req: Request): Promise<Response> {\n    const env = (await req.json().catch(() => ({}))) as Env;\n    const base = env.vxil_base ?? 'https://api.vxil.com';\n    const pay = env.scoped_jwts?.payments;\n    const cms = env.scoped_jwts?.cms;\n    if (!pay || !cms) return fail(403, 'missing_scopes', 'the function needs payments:read and cms:write');\n    // The binding's `source` already filters deliveries; this stays as belt-and-braces.\n    if (env.payload?.event !== 'payments.charge.succeeded') {\n      return Response.json({ skipped: true, event: env.payload?.event });\n    }\n    const raw = env.payload.data;\n    // Past 64 KiB the whole `data` value is replaced by { truncated: true } \u2014\n    // never a half object. A charge payload is tiny, but the check is free.\n    if (raw && 'truncated' in raw) return Response.json({ skipped: true, reason: 'payload truncated' });\n    const data: ChargeSucceeded = raw ?? {};\n    const userId = data.end_user_id ?? null;\n    const providerChargeId = data.provider_charge_id ?? null;\n    if (!userId || !providerChargeId || data.amount_cents == null) {\n      return Response.json({ skipped: true, reason: 'charge carries no user, id or amount' });\n    }\n\n    // 1. Re-read the LEDGER (the authoritative record) \u2014 a succeeded charge of\n    //    this amount must exist for this user. This is what turns the event\n    //    name from a claim into a fact. (One product, one pass per purchase:\n    //    the match is by amount; the list is newest-first.)\n    const led = await fetch(\n      `${base}/v1/payments/charges?user_id=${encodeURIComponent(userId)}&status=succeeded&limit=50`,\n      { headers: H(pay) },\n    ).catch(() => new Response(null, { status: 599 }));\n    if (led.status >= 500) return unsettled(`ledger read ${led.status}`);\n    if (!led.ok) return Response.json({ skipped: true, reason: `ledger read ${led.status}` });\n    const charges = ((await led.json()) as ChargeList).data?.charges ?? [];\n    const match = charges.find((c) => c.status === 'succeeded' && c.amount_cents === data.amount_cents\n      && (!data.currency || c.currency === data.currency));\n    if (!match) return Response.json({ skipped: true, reason: 'no succeeded charge of that amount on the ledger' });\n\n    // 2. Write the pass RECORD. Server mode, so `user` is set explicitly (in\n    //    end-user mode the platform would stamp it). The ledger's `charge_id` is\n    //    the unique anchor \u2014 start-brief's record write keys on the same id.\n    const now = Date.now();\n    const created = await fetch(`${base}/v1/cms/items/passes`, {\n      method: 'POST',\n      headers: H(cms),\n      body: JSON.stringify({\n        data: {\n          user: userId,\n          charge_id: match.charge_id,\n          product: data.product_id ?? 'studio-pass',\n          amount_cents: data.amount_cents,\n          granted_at: new Date(now).toISOString(),\n          expires_at: new Date(now + PASS_DAYS * 86_400_000).toISOString(),\n        },\n      }),\n    }).catch(() => new Response(null, { status: 599 }));\n    if (created.status === 409) {\n      const code = ((await created.json().catch(() => ({}))) as ErrBody).error?.code;\n      // the redelivery case \u2014 the pass is already there\n      return Response.json({ granted: false, reason: code ?? 'already granted', charge_id: match.charge_id });\n    }\n    if (created.status >= 500) return unsettled(`pass write ${created.status}`);\n    if (!created.ok) return Response.json({ skipped: true, reason: `pass write ${created.status}` });\n    const itemId = ((await created.json()) as Created).data?.item_id;\n    return Response.json({\n      granted: true, pass: itemId, user: userId, charge_id: match.charge_id, provider_charge_id: providerChargeId,\n    });\n  },\n};\n\n// \u2500\u2500 tiny helpers \u2500\u2500\nconst H = (jwt: string) => ({ authorization: `Bearer ${jwt}`, 'content-type': 'application/json' });\nconst fail = (status: number, code: string, message: string) =>\n  Response.json({ error: { code, message } }, { status });\n/** The charge succeeded and no pass was written. Answer 500 so the run is SEEN\n *  (`functions.run.failed` \u2192 the alert digest); it is ACKed, never re-delivered\n *  \u2014 start-brief decides from the ledger (the payer is never blocked) and\n *  re-writes the missing record on the next request. */\nconst unsettled = (reason: string) =>\n  fail(500, 'grant_unsettled', `${reason} \u2014 no pass written; surfaced via functions.run.failed (not re-delivered), repaired by start-brief from the ledger`);\n",
       "settle-brief.ts": "// settle-brief.ts \u2014 SETTLE THE BRIEF ONTO ITS ROW (a vxil function, \xA77.3).\n//\n// Trigger: webhook, source 'job.generation.' \u2014 the PREFIX, so this function\n// wakes for both `job.generation.completed` and `job.generation.failed`. The\n// envelope's `payload.data` is the event payload:\n//   { run_id, generation_id, correlation_id, status, error_class, error_hint, state, level }\n//\n// `correlation_id` is the funnel_sessions row id that start-brief sent with\n// the generate call \u2014 the platform echoes it on the event next to\n// generation_id, so this function needs no run\u2192record table of its own.\n//\n// On COMPLETED: the settled text lives in the generation's replay buffer\n// (GET /v1/ai/generations/{id}/stream?since=0 \u2014 every recorded frame, plus\n// `done`); the token frames are joined and PATCHed onto the row, then the\n// visitor gets a \"ready\" message. On FAILED: `error_hint` carries the\n// provider's own status and message (`Upstream said: \u2026`) and `error_class`\n// the class \u2014 the row gets the hint, so the visitor (and your support inbox)\n// sees WHY, not just that it failed. On completed both are null by contract.\n//\n// THE DELIVERY CONTRACT (guide 08, \"What is retried, and what is not\"): on\n// every platform-delivered trigger the dispatcher ACKs the delivery with a 200\n// WHATEVER this handler returns. A 5xx from here is never re-delivered \u2014 it is\n// OBSERVED (`functions.run.failed`, once per failure streak, digested by\n// `webhooks.alerts`). Only a crash of the dispatch itself is retried. So this\n// function never answers a 5xx hoping for a redelivery; it makes every failure\n// RECOVERABLE THROUGH THE ROW instead:\n//   \u2022 a settle that cannot complete marks the row `result_status: 'failed'`\n//     with `error_hint: 'settle failed: <reason>'` \u2014 start-brief accepts that\n//     row again, so the visitor's retry is one click;\n//   \u2022 only when not even that mark could be written does it answer 500 \u2014 not\n//     for a retry (there is none) but so the failure is SEEN in the alert\n//     digest instead of vanishing behind a 200.\n// The one transient it waits out ITSELF is the replay buffer: `done: false`\n// means the terminal frame is a moment behind the event, so the read is\n// repeated a few times before giving up (the guide's \"retry internally\").\n//\n// Every write carries `if: { generation_id }` \u2014 the row is touched only while\n// it is still waiting on THIS generation, so a late delivery for an earlier\n// attempt can never overwrite a newer one (409 precondition_failed = stale).\n// At-least-once: the same PATCH twice is the same row, and the \"ready\" send\n// carries the delivery's idempotency key, so a redelivery never double-mails.\n\nimport type { JobGenerationSettledEventPayload, WebhookFunctionEnvelope } from '@vxil/sdk';\n\ntype Env = WebhookFunctionEnvelope<JobGenerationSettledEventPayload>;\ninterface SessionData { user?: string; generation_id?: string | null; result_status?: string }\ninterface Item { data?: { data?: SessionData } }\ninterface Replay { data?: { frames?: Array<{ type?: string; delta?: string; done?: boolean }>; done?: boolean } }\n\nconst REPLAY_TRIES = 4;      // reads of the replay buffer before giving up \u2026\nconst REPLAY_WAIT_MS = 500;  // \u2026 and the pause between them (wall time, not CPU)\nconst ROW_TRIES = 3;         // re-reads of a row still inside start-brief's claim\u2192generate\u2192record window\nconst ROW_WAIT_MS = 700;\n\nexport default {\n  async fetch(req: Request): Promise<Response> {\n    const env = (await req.json().catch(() => ({}))) as Env;\n    const base = env.vxil_base ?? 'https://api.vxil.com';\n    const cms = env.scoped_jwts?.cms;\n    const ai = env.scoped_jwts?.ai;\n    const notif = env.scoped_jwts?.notifications;\n    if (!cms || !ai) return fail(403, 'missing_scopes', 'the function needs cms:read, cms:write and ai:read');\n\n    const event = env.payload?.event ?? '';\n    if (event !== 'job.generation.completed' && event !== 'job.generation.failed') {\n      return Response.json({ skipped: true, event }); // e.g. job.generation.processing\n    }\n    // a truncated payload ({ truncated: true }) carries nothing to settle from\n    const raw = env.payload?.data;\n    const data: Partial<JobGenerationSettledEventPayload> = raw && !('truncated' in raw) ? raw : {};\n    const sessionId = data.correlation_id ?? null;\n    const generationId = data.generation_id ?? null;\n    if (!sessionId || !generationId) {\n      return Response.json({ skipped: true, reason: 'not a funnel generation (no correlation_id)' });\n    }\n    const row = { base, cms, sessionId, generationId };\n\n    // Find our row through the correlation id (server mode: any row). It must\n    // be waiting on THIS generation: another id is a stale delivery (an earlier\n    // attempt settling late) \u2014 unless the row is `queued` with no handle yet,\n    // which is start-brief's claim\u2192generate\u2192record window: the handle is one\n    // PATCH away, so the read is repeated before the delivery is called stale.\n    let session: SessionData | null = null;\n    let readStatus = 0;\n    for (let i = 0; i < ROW_TRIES; i++) {\n      if (i > 0) await sleep(ROW_WAIT_MS);\n      const res = await fetch(`${base}/v1/cms/items/funnel_sessions/${encodeURIComponent(sessionId)}`, { headers: H(cms) });\n      readStatus = res.status;\n      if (res.status === 404) return Response.json({ skipped: true, reason: 'no such session' });\n      if (!res.ok) continue; // a 5xx read: try again, then fall through to the blind mark below\n      const s = ((await res.json()) as Item).data?.data ?? {};\n      if (s.generation_id === generationId) { session = s; break; }\n      if (s.result_status === 'queued' && !s.generation_id) continue; // claimed, handle not recorded yet\n      return Response.json({ skipped: true, reason: 'stale generation', expected: s.generation_id ?? null });\n    }\n    if (!session) {\n      if (readStatus >= 500) {\n        // The row could not be read. Mark it failed anyway \u2014 the `if`\n        // precondition lands the mark only if the row is still waiting on this\n        // generation \u2014 and let the visitor retry.\n        return await settleFailed(row, `session read ${readStatus}`);\n      }\n      return Response.json({ skipped: true, reason: 'stale generation (no handle recorded for it)' });\n    }\n\n    if (event === 'job.generation.failed') {\n      // The provider's own words, bounded (the event caps the hint at 200 chars).\n      const hint = data.error_hint ?? data.error_class ?? 'generation failed';\n      const patch = await patchSession(row, { result_status: 'failed', error_hint: hint });\n      if (patch.status === 409) return Response.json({ skipped: true, reason: 'stale generation' });\n      if (!patch.ok) return unsettled(`session patch ${patch.status}`);\n      return Response.json({ settled: 'failed', session: sessionId, error_class: data.error_class ?? null, error_hint: hint });\n    }\n\n    // COMPLETED \u2014 the text is in the replay buffer. `done: false` means the\n    // buffer has not received its terminal frame yet \u2014 a moment behind the\n    // event \u2014 so the read is repeated a few times before the brief is given\n    // up (never settled empty; never a 5xx-and-hope: nothing re-delivers).\n    let replay: NonNullable<Replay['data']> | null = null;\n    let replayStatus = 0;\n    for (let i = 0; i < REPLAY_TRIES; i++) {\n      if (i > 0) await sleep(REPLAY_WAIT_MS);\n      const rep = await fetch(`${base}/v1/ai/generations/${encodeURIComponent(generationId)}/stream?since=0`, { headers: H(ai) });\n      replayStatus = rep.status;\n      if (rep.status >= 400 && rep.status < 500) break; // not transient \u2014 a 404 generation will not appear\n      if (!rep.ok) continue;\n      const d = ((await rep.json()) as Replay).data ?? {};\n      if (d.done) { replay = d; break; }\n    }\n    if (!replay) {\n      return await settleFailed(row, replayStatus >= 400 ? `replay read ${replayStatus}` : 'replay buffer never reported done');\n    }\n    const text = (replay.frames ?? []).filter((f) => f.type === 'token').map((f) => f.delta ?? '').join('');\n\n    const patch = await patchSession(row, { result_status: 'completed', result: text, error_hint: null });\n    if (patch.status === 409) return Response.json({ skipped: true, reason: 'stale generation' });\n    if (!patch.ok) return await settleFailed(row, `session patch ${patch.status}`);\n\n    // Tell the visitor. Best-effort AFTER the result is on the row: a mail that\n    // fails must not un-settle a brief that is ready. The delivery's\n    // idempotency key rides the send, so a redelivered event never sends twice\n    // (notifications honors Idempotency-Key).\n    let delivery: number | null = null;\n    if (notif && session.user) {\n      const send = await fetch(`${base}/v1/notifications/send`, {\n        method: 'POST',\n        headers: { ...H(notif), ...(env.idempotency_key ? { 'idempotency-key': env.idempotency_key } : {}) },\n        body: JSON.stringify({\n          user_id: session.user,\n          template: 'transactional',\n          data: { subject: 'Your brief is ready', paragraph: 'Open the studio to read your creative brief.' },\n        }),\n      }).catch(() => null);\n      delivery = send?.status ?? null;\n    }\n    return Response.json({ settled: 'completed', session: sessionId, chars: text.length, delivery });\n  },\n};\n\n// \u2500\u2500 tiny helpers \u2500\u2500\ninterface Row { base: string; cms: string; sessionId: string; generationId: string }\nconst H = (jwt: string) => ({ authorization: `Bearer ${jwt}`, 'content-type': 'application/json' });\nconst sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));\nconst fail = (status: number, code: string, message: string) =>\n  Response.json({ error: { code, message } }, { status });\n/** Not even the row could record the failure: answer 500 so the run is SEEN\n *  (`functions.run.failed` \u2192 the alert digest). ACKed, never re-delivered. */\nconst unsettled = (reason: string) =>\n  fail(500, 'unsettled', `${reason} \u2014 the row could not be marked failed; surfaced via functions.run.failed, not re-delivered`);\n/** Every write is guarded by `if: { generation_id }`: the row is touched only\n *  while it still waits on THIS generation (409 precondition_failed = stale). */\nfunction patchSession(row: Row, data: Record<string, unknown>): Promise<Response> {\n  return fetch(`${row.base}/v1/cms/items/funnel_sessions/${encodeURIComponent(row.sessionId)}`, {\n    method: 'PATCH', headers: H(row.cms), body: JSON.stringify({ data, if: { generation_id: row.generationId } }),\n  }).catch(() => new Response(null, { status: 599 }));\n}\n/** The recoverable outcome: mark the row failed with the reason, so start-brief\n *  accepts it again and the visitor's retry is one click. */\nasync function settleFailed(row: Row, reason: string): Promise<Response> {\n  const patch = await patchSession(row, { result_status: 'failed', error_hint: `settle failed: ${reason}`.slice(0, 200) });\n  if (patch.ok) return Response.json({ settled: 'failed', session: row.sessionId, reason });\n  if (patch.status === 409) return Response.json({ skipped: true, reason: 'stale generation' });\n  return unsettled(`${reason}; mark failed \u2192 ${patch.status}`);\n}\n",
@@ -18328,14 +18794,6 @@ function positional(skip = 0) {
   }
   return out.slice(skip);
 }
-function printEnvelope({ status, body }) {
-  if (body.error) {
-    console.error(`error ${status}: ${body.error.code} \u2014 ${body.error.message}`);
-    if (body.error.hint) console.error(`hint: ${body.error.hint}`);
-    process.exit(1);
-  }
-  console.log(JSON.stringify(body.data, null, 2));
-}
 async function prompt(q, opts = {}) {
   const stdin = process.stdin;
   if (opts.hidden && stdin.isTTY && stdin.setRawMode) {
@@ -18397,25 +18855,21 @@ async function dashFetch(base2, method, path, body, cookie) {
 function makeDash(base2) {
   return (method, path, body, cookie) => dashFetch(base2, method, path, body, cookie);
 }
+function linkRequest(slug, tenantId, base2) {
+  const as = flag("as");
+  return { slug, tenantId, edgeUrl: base2, env: flag("env") ?? envLabelFor(base2), ...as !== void 0 ? { as } : {} };
+}
 function persistLink(slug, tenantId, apiKey, base2) {
+  const req = linkRequest(slug, tenantId, base2);
+  const plan = planLinkBinding(loadProject(), req);
+  if ("error" in plan) fail(plan.error);
+  const envWarn = envLabelWarning(req.env, base2);
+  if (envWarn) console.error(`vxil: ${envWarn}`);
   const creds = loadCredentials();
   creds.keys = { ...creds.keys, [slug]: apiKey };
   saveCredentials(creds);
-  const as = flag("as");
-  const env = flag("env") ?? envLabelFor(base2);
-  const envWarn = envLabelWarning(env, base2);
-  if (envWarn) console.error(`vxil: ${envWarn}`);
-  const existing = loadProject();
-  if (as !== void 0) {
-    if (!TARGET_NAME_RE.test(as)) fail(`--as '${as}': a target name is 1\u201340 chars of [a-z0-9-], starting with a letter`);
-    if (existing?.slug === slug) fail(`'${slug}' is already this repo's PRIMARY binding \u2014 a named slot must be a different tenant`);
-    saveProject(bindNamedSlot(existing, as, { tenant_id: tenantId, slug, edge_url: base2, env }));
-    return as === "dev" ? "as the dev slot (--dev)" : `as target '${as}' (--target ${as})`;
-  }
-  const merged = mergePrimaryBinding(existing, { tenant_id: tenantId, slug, edge_url: base2, env });
-  saveProject(merged);
-  const kept = bindingSlots(merged).slice(1).map((s) => s.label);
-  return kept.length ? `as the primary binding (kept: ${kept.join(", ")})` : "as the primary binding";
+  saveProject(plan.binding);
+  return plan.label;
 }
 function selector() {
   return selectorFrom({ dev: hasFlag("dev"), target: flag("target") });
@@ -19468,6 +19922,12 @@ function listTemplates() {
 }
 try {
   switch (cmd) {
+    case "--version":
+    case "-v":
+    case "version": {
+      console.log(VXIL_CLI_PKG_VERSION);
+      break;
+    }
     case "init": {
       initProject();
       break;
@@ -19516,6 +19976,8 @@ try {
       const slot = { tenant_id: d.tenant_id, slug: d.app_slug, edge_url: d.edge_url ?? base2, env: flag("env") ?? envLabelFor(base2) };
       const merged = mergePrimaryBinding(loadProject(), slot);
       saveProject(hasFlag("dev") ? { ...merged, dev: { tenant_id: slot.tenant_id, slug: slot.slug, edge_url: slot.edge_url } } : merged);
+      const envNotice = quickstartEnvNotice(flag("env"), base2, d.app_slug, { dev: hasFlag("dev") });
+      if (envNotice) console.error(`vxil: ${envNotice}`);
       if (!existsSync8(resolve7(process.cwd(), "vxil.config.ts"))) initProject();
       console.log(`
 \u2713 tenant '${d.app_slug}' created \xB7 enabled: ${(d.enabled ?? []).join(", ")}`);
@@ -19620,9 +20082,12 @@ try {
       const base2 = process.env.VXIL_BASE_URL ?? DEFAULT_BASE;
       const directKey = flag("key");
       if (directKey) {
-        const tenantId = flag("tenant") ?? "(unknown)";
-        const bound = persistLink(slug, tenantId, directKey, base2);
-        console.log(`\u2713 linked '${slug}' ${bound} (using provided --key)`);
+        const r = await linkViaStoredKey(makeApi({ apiKey: directKey, baseUrl: base2 }), slug, directKey);
+        if ("invalid" in r) fail(`the --key was refused (${r.invalid}) \u2014 nothing was linked`);
+        const rec = reconcileLinkTenant(flag("tenant"), r.result.tenant_id);
+        if ("error" in rec) fail(rec.error);
+        const bound = persistLink(slug, rec.tenantId, directKey, base2);
+        console.log(`\u2713 linked '${slug}' ${bound} (using provided --key \xB7 tenant ${rec.tenantId})`);
         break;
       }
       const creds = loadCredentials();
@@ -19630,13 +20095,19 @@ try {
       if (stored && !hasFlag("mint")) {
         const r = await linkViaStoredKey(makeApi({ apiKey: stored, baseUrl: base2 }), slug, stored);
         if ("result" in r) {
-          const tenantId = flag("tenant") ?? r.result.tenant_id;
+          const rec = reconcileLinkTenant(flag("tenant"), r.result.tenant_id);
+          if ("error" in rec) fail(rec.error);
+          const tenantId = rec.tenantId;
           const bound = persistLink(slug, tenantId, stored, base2);
           console.log(`\u2713 linked '${slug}' ${bound} (using the key already stored for this slug in ~/.vxil/credentials.json \u2014 pass --mint for a new one)`);
           break;
         }
         console.error(`stored key for '${slug}' was refused (${r.invalid}) \u2014 minting a new one\u2026`);
       }
+      {
+        const pre = planLinkBinding(loadProject(), linkRequest(slug, "(unknown)", base2));
+        if ("error" in pre) fail(pre.error);
+      }
       const linkDashBase = dashboardBase(base2);
       const dash = makeDash(linkDashBase);
       const keyName = `cli-${hostname()}`.slice(0, 100);
@@ -20558,30 +21029,25 @@ export default defineConfig(${JSON.stringify({ features: featBlocks, cms: { coll
           }
         }
       } else if (sub === "invoke") {
-        if (!name) fail("usage: vxil functions invoke <name> [--data '<json>'] [--async]");
-        const { api, baseUrl, target } = requireApi(selector(), { write: `functions invoke ${name}` });
-        let payload = {};
-        const raw = flag("data");
-        if (raw !== void 0) {
-          try {
-            payload = JSON.parse(raw);
-          } catch {
-            fail("--data must be valid JSON");
-          }
+        let parsed;
+        try {
+          parsed = parseInvokeArgs(rest);
+        } catch (e) {
+          fail(e.message);
         }
-        if (hasFlag("async")) {
+        const { name: fnName, body: payload } = parsed;
+        const { api, baseUrl, target } = requireApi(selector(), { write: `functions invoke ${fnName}` });
+        if (parsed.async) {
           const tenantId = target.tenantId && target.tenantId !== "(unknown)" ? target.tenantId : void 0;
           if (!tenantId) fail("`--async` needs a linked tenant (run `vxil link <slug>` or `vxil quickstart`)");
           printEnvelope(await api("POST", "/v1/jobs/enqueue", {
-            job_name: `fn-queue:${name}`,
-            target_url: `${baseUrl.replace(/\/$/, "")}/v1/internal/fn/trigger/${encodeURIComponent(name)}?tenant=${tenantId}`,
+            job_name: `fn-queue:${fnName}`,
+            target_url: `${baseUrl.replace(/\/$/, "")}/v1/internal/fn/trigger/${encodeURIComponent(fnName)}?tenant=${tenantId}`,
             payload: { trigger: "queue", payload },
-            idempotency_key: `fnq:${name}:${Date.now()}`
+            idempotency_key: `fnq:${fnName}:${Date.now()}`
           }));
         } else {
-          const res = await api("POST", `/v1/fn/${encodeURIComponent(name)}`, payload);
-          if (res.body.error) printEnvelope(res);
-          else console.log(JSON.stringify(res.body.data ?? res.body, null, 2));
+          emitOutput(formatFnAnswer(fnName, await api("POST", `/v1/fn/${encodeURIComponent(fnName)}`, payload)));
         }
       } else if (sub === "enable") {
         if (!name) fail("usage: vxil functions enable <name>");
@@ -20622,7 +21088,7 @@ export default defineConfig(${JSON.stringify({ features: featBlocks, cms: { coll
         else console.log(`\u2713 disabled '${name}' (functions config v${r.version ?? "?"})`);
         for (const l of disableNotices(name, declared, r.version)) console.error(l);
       } else if (sub === "dev") {
-        if (!name) fail("usage: vxil functions dev <name> [--port <n>]");
+        if (!name) fail("usage: vxil functions dev <name> [--port <n>] [--trigger <http|webhook|cms-hook|auth-hook|queue|cron>] \xB7 vxil functions dev <name> --event <file.json> [--trigger <lane>] [--run-id <id>]  (no dev slot + a production primary: a non-http lane or --event asks for the slug, or --yes)");
         await runFunctionsDev(name);
       } else {
         fail("usage: vxil functions new|deploy|list|delete|enable|disable|invoke|logs|dev <name>");
@@ -20816,18 +21282,18 @@ export default defineConfig(${JSON.stringify({ features: featBlocks, cms: { coll
       }
       let parsed;
       try {
-        parsed = parseApiArgs(positional(0), flag("data"));
+        parsed = parseApiArgv(rest);
       } catch (e) {
         fail(e.message);
       }
       const { method, path, body } = parsed;
       const { api } = requireApi(selector(), method === "GET" ? {} : { write: `api ${method} ${path}` });
-      printEnvelope(await api(method, path, body));
+      emitOutput(formatEnvelope(await api(method, path, body), { rawText: true }));
       break;
     }
     default:
       console.log(`vxil \u2014 a Supabase-grade code-first CLI for the whole platform
-  init [--template <id>] \xB7 templates \xB7 try (keyless sandbox) \xB7 quickstart [--features a,b] [--invite <code>] [--env <label>] [--dev [--ttl <h>]] [--no-push] \xB7 login \xB7 link <slug> [--key <k>] [--as dev|<name>] [--env <label>] [--mint]
+  --version \xB7 init [--template <id>] \xB7 templates \xB7 try (keyless sandbox) \xB7 quickstart [--features a,b] [--invite <code>] [--env <label>] [--dev [--ttl <h>]] [--no-push] \xB7 login \xB7 link <slug> [--key <k> [--tenant <id>]] [--as dev|<name>] [--env <label>] [--mint]
   keys mint --name <n> --scopes <a,b,c> [--env live|test] [--store] \xB7 keys list \xB7 keys revoke <key_id> [--yes]  \u2014 a NARROW scoped key for a server (shown once; needs a vxil login session)
   keys perms <key_id> [--allow <a,b> | --clear-allow] [--deny <c> | --clear-deny]  \u2014 a key's MCP tool permissions (admin+)
   account [show] \xB7 account set [--locale <code>] [--display-name <n>] \xB7 account password \xB7 logout \xB7 invites [list] \xB7 invites generate [--count <n>] \xB7 invites accept <token|url>
@@ -20847,7 +21313,7 @@ export default defineConfig(${JSON.stringify({ features: featBlocks, cms: { coll
   migrate payments --from-provider stripe|paddle|paypal|revenuecat (--customers <f.csv> | --all) [--dry-run]  \u2014 backfill subscriptions via the server sync leg (resumable)
   payments simulate --scenario refund-pair|cross-platform-unlock|renewal|expiry|past-due-grace|transfer --user <id> [--tier <t>]  \u2014 mock/dev projects only
   env pull [--dev] [--file <f>] [--print] [--no-gitignore]
-  functions new|deploy|list|delete|enable|disable [--yes]|invoke [--async]|logs [--tail]|dev <name> [--port <n>] \xB7 cms status|pull|reindex <collection>|drop <collection> [--yes]|bulk-rm <collection> --filter '<json>' [--dry-run] [--yes] \xB7 dev up [--ttl <h>] [--new]|down [--yes]|seed|reset
+  functions new|deploy|list|delete|enable|disable [--yes]|invoke ['<json>' | --data '<json>'] [--async]|logs [--tail]|dev <name> [--port <n>] [--trigger <lane>] [--event <file.json>] [--yes] \xB7 cms status|pull|reindex <collection>|drop <collection> [--yes]|bulk-rm <collection> --filter '<json>' [--dry-run] [--yes] \xB7 dev up [--ttl <h>] [--new]|down [--yes]|seed|reset
   files put <path> --user <id> [--content-type <t>] \xB7 files rm <object_id> [--yes] \xB7 webhooks sources add|list|rm|test \xB7 webhooks events replay|runs <event_id> \xB7 search sync run|reset <sourceKey> [--sweep|--purge] \xB7 users import <file.json|.csv>
   api --help  \u2014 the operator cheat-sheet: every dashboard action as one 'vxil api' line, grouped by feature
   listen --forward-to <url> [--dev] [--source <id>] [--events <prefix,\u2026>] [--replay-last <n>] [--interval <s>] [--show-runs] [--raw]  \u2014 forward inbound webhook events to a local server
@@ -21386,6 +21852,37 @@ async function runFunctionsDev(name) {
   const cfg = await loadVxilConfig();
   const def = cfg.functions?.[name];
   if (!def) fail(`function '${name}' not declared in vxil.config`);
+  let bindings;
+  try {
+    bindings = lowerAllTriggerBindings(def, name);
+  } catch (e) {
+    fail(e.message);
+  }
+  const eventFile = flag("event");
+  const laneFlag = flag("trigger");
+  let lane = "http";
+  let oneShotInput;
+  if (eventFile !== void 0) {
+    let json2;
+    try {
+      json2 = JSON.parse(readFileSync8(resolve7(process.cwd(), eventFile), "utf8"));
+    } catch (e) {
+      fail(`--event ${eventFile}: ${e.message.split("\n")[0]}`);
+    }
+    const parsedEvent = parseEventFile(json2, laneFlag);
+    if ("error" in parsedEvent) fail(parsedEvent.error);
+    lane = parsedEvent.lane;
+    oneShotInput = { input: parsedEvent.input };
+  } else if (laneFlag !== void 0) {
+    const l = parseLane(laneFlag);
+    if (!l) fail(`--trigger '${laneFlag}' is not a lane \u2014 use one of ${LOCAL_LANES.join(" | ")}`);
+    lane = l;
+  }
+  const laneRefused = laneRefusal(lane, bindings, name);
+  if (laneRefused) fail(laneRefused);
+  const oneShot = oneShotInput ? planLocalDelivery({ lane, input: oneShotInput.input, bindings, fnName: name }) : void 0;
+  if (oneShot && !oneShot.ok) fail(oneShot.refusal);
+  const timeoutMs = normalizeFnLimits(def.limits)?.timeoutMs;
   const explicit = hasFlag("dev") || flag("target") !== void 0;
   const sel = explicit ? selector() : loadProject()?.dev ? { kind: "dev" } : { kind: "primary" };
   const t = resolveTargetOrFail(sel);
@@ -21394,6 +21891,22 @@ async function runFunctionsDev(name) {
     console.error(`vxil: no dev tenant bound \u2014 the local function's feature calls will hit the PRIMARY binding '${t.tenantSlug ?? "(env key)"}' (${t.envLabel}); bind one with \`vxil dev up\` or pass --target <name>`);
   }
   announceTarget(t, `functions dev ${name}`);
+  const prodGuard = productionLaneGuard({
+    lane,
+    oneShot: oneShot !== void 0,
+    explicitSelector: explicit,
+    production: isProductionTarget(t),
+    tenant: t.tenantSlug ?? "(env key)",
+    fnName: name
+  });
+  if (prodGuard) {
+    await confirmTyped(
+      prodGuard,
+      `vxil: ${prodGuard}.
+Type ${t.tenantSlug ? `the tenant slug '${t.tenantSlug}'` : "'yes'"} to run it anyway: `,
+      t.tenantSlug ?? "yes"
+    );
+  }
   const tenantId = t.tenantId && t.tenantId !== "(unknown)" ? t.tenantId : "dev-tenant";
   let Miniflare;
   try {
@@ -21406,27 +21919,79 @@ async function runFunctionsDev(name) {
   const entry = resolve7(cwd, def.entry);
   const scopes = def.scopes ?? [];
   const egressAllow = def.egressAllow ?? [];
+  const note = (line) => {
+    if (oneShot) console.error(line);
+    else console.log(line);
+  };
   const outbound = makeDevOutbound({
     fnName: name,
     scopes,
     egressAllow,
     edgeUrl: t.baseUrl,
     apiKey: t.apiKey,
-    log: (line) => console.log(`  ${line}`)
+    log: (line) => note(`  ${line}`)
   });
   const mfOptions = (source) => ({
     modules: [{ type: "ESModule", path: "fn.mjs", contents: source }],
-    compatibilityDate: "2025-09-01",
-    // parity with the deploy pipeline's metadata
+    // the deploy pipeline's runtime settings (@vxil/types FUNCTIONS_RUNTIME)
+    compatibilityDate: FUNCTIONS_RUNTIME.compatibilityDate,
+    compatibilityFlags: [...FUNCTIONS_RUNTIME.compatibilityFlags],
     outboundService: (req) => outbound(req)
   });
   const first = await bundleFunction(entry, { projectRoot: cwd, minify: false });
   const mf = new Miniflare(mfOptions(first.source));
   const { secrets, missing } = resolveDevSecrets(def.secrets, process.env);
   for (const m of missing) {
-    console.log(`  ! secret '${m}' not resolved locally \u2014 export VXIL_FN_SECRET_${m.toUpperCase()}=\u2026 (deployed invokes read tenant_secrets)`);
+    note(`  ! secret '${m}' not resolved locally \u2014 export VXIL_FN_SECRET_${m.toUpperCase()}=\u2026 (deployed invokes read tenant_secrets)`);
+  }
+  const realTenantLine = `  writes:  every feature call lands on '${t.tenantSlug ?? "(env key)"}' for REAL (its data, its provider accounts) \u2014 a money-lane function grants, refunds or mails for real; run it against a dev tenant (\`vxil dev up\`)`;
+  const dispatch = async (envelope) => {
+    const out = await mf.dispatchFetch("https://fn.vxil.internal/invoke", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(envelope)
+    });
+    return { status: out.status, text: await out.text(), contentType: out.headers.get("content-type") };
+  };
+  if (oneShot?.ok) {
+    const runId = flag("run-id") ?? `dev-${Date.now().toString(36)}`;
+    const envelope = buildEnvelope({
+      fnName: name,
+      scopes,
+      payload: oneShot.payload,
+      tenantId,
+      requestId: runId,
+      trigger: lane,
+      runId,
+      secrets
+    });
+    console.error(`vxil functions dev '${name}' \u2014 one ${lane} delivery \xB7 local isolate, remote edge`);
+    console.error(`  tenant:  ${t.tenantSlug ?? "(env key)"} \xB7 edge ${t.baseUrl}`);
+    console.error(realTenantLine);
+    console.error(`  idempotency_key: ${envelope.idempotency_key}${lane === "http" ? "" : " (the same --run-id replays it as a redelivery)"}`);
+    const t0 = Date.now();
+    let answer;
+    try {
+      answer = await dispatch(envelope);
+    } catch (e) {
+      await mf.dispose();
+      fail(`isolate error: ${String(e.message).split("\n")[0]}`);
+    }
+    await mf.dispose();
+    console.error(`  \u2192 ${answer.status} (${Date.now() - t0} ms)`);
+    for (const l of deployedVerdict(lane, oneShot.binding, timeoutMs)) console.error(`  ${l}`);
+    let body = {};
+    let raw;
+    try {
+      body = JSON.parse(answer.text);
+    } catch {
+      raw = answer.text;
+    }
+    emitOutput(formatFnAnswer(name, { status: answer.status, body, ...raw !== void 0 ? { raw } : {} }));
+    process.exit(0);
   }
   const port = Number(flag("port") ?? 8788);
+  const serverStamp = Date.now().toString(36);
   let seq = 0;
   const server = createServer((req, res) => {
     const chunks = [];
@@ -21434,37 +21999,47 @@ async function runFunctionsDev(name) {
     req.on("end", () => {
       void (async () => {
         seq += 1;
-        const requestId = `dev-${seq}`;
         const reqUrl = new URL(req.url ?? "/", `http://localhost:${port}`);
-        let payload = Object.fromEntries(reqUrl.searchParams);
+        let input = Object.fromEntries(reqUrl.searchParams);
         if ((req.method ?? "GET") !== "GET") {
           try {
-            payload = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+            input = JSON.parse(Buffer.concat(chunks).toString("utf8"));
           } catch {
-            payload = {};
+            input = {};
           }
         }
+        const runHeader = req.headers["x-vxil-run-id"];
+        const requestId = lane !== "http" && typeof runHeader === "string" && runHeader ? runHeader : `dev-${serverStamp}-${seq}`;
+        const label = lane === "http" ? `${req.method} ${reqUrl.pathname}` : lane;
+        const d = planLocalDelivery({ lane, input, bindings, fnName: name });
+        if (!d.ok) {
+          console.error(`  [${requestId}] ${label} refused \u2014 ${d.refusal}`);
+          res.writeHead(422, { "content-type": "application/json" });
+          res.end(JSON.stringify({ error: { code: "lane_refused", message: d.refusal } }));
+          return;
+        }
         const idem = req.headers["idempotency-key"];
         const envelope = buildEnvelope({
           fnName: name,
           scopes,
-          payload,
+          payload: d.payload,
           tenantId,
           requestId,
+          trigger: lane,
+          runId: requestId,
           ...typeof idem === "string" ? { idempotencyKey: idem } : {},
           secrets
         });
         const t0 = Date.now();
         try {
-          const out = await mf.dispatchFetch("https://fn.vxil.internal/invoke", {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify(envelope)
-          });
-          const text = await out.text();
-          console.log(`  [${requestId}] ${req.method} ${reqUrl.pathname} \u2192 ${out.status} (${Date.now() - t0} ms)`);
-          res.writeHead(out.status, { "content-type": out.headers.get("content-type") ?? "application/json" });
-          res.end(text);
+          const out = await dispatch(envelope);
+          const event = lane === "webhook" ? ` ${String(d.payload.event)}` : "";
+          console.log(`  [${requestId}] ${label}${event} \u2192 ${out.status} (${Date.now() - t0} ms)`);
+          if (out.status < 200 || out.status >= 300) {
+            for (const l of deployedVerdict(lane, d.binding, timeoutMs)) console.log(`      ${l}`);
+          }
+          res.writeHead(out.status, { "content-type": out.contentType ?? "application/json" });
+          res.end(out.text);
         } catch (e) {
           console.error(`  [${requestId}] isolate error: ${String(e.message).split("\n")[0]}`);
           res.writeHead(502, { "content-type": "application/json" });
@@ -21490,10 +22065,22 @@ async function runFunctionsDev(name) {
   });
   server.listen(port, () => {
     const auds = functionCallbackAudiences(scopes);
+    const sample = {
+      http: '{"name":"world"}',
+      webhook: '{"event":"payments.charge.succeeded","data":{}}',
+      "cms-hook": '{"event":"cms.item.created","collection":"<slug>","item_id":"<id>"}',
+      "auth-hook": '{"event":"auth.user.created","user_id":"<id>"}',
+      queue: '{"your":"payload"}',
+      cron: "{}"
+    };
     console.log(`vxil functions dev '${name}' \u2014 local isolate, remote edge (design \xA75.1-C)`);
     console.log(`  tenant:  ${t.tenantSlug ?? "(env key)"} \xB7 edge ${t.baseUrl}`);
+    console.log(realTenantLine);
     console.log(`  bundle:  ${def.entry} (${Math.round(first.bytes / 100) / 10} KB) \u2014 rebuilds on save`);
-    console.log(`  invoke:  curl -X POST http://localhost:${port}/ -d '{"name":"world"}'`);
+    if (lane !== "http") {
+      console.log(`  lane:    ${lane} \u2014 every request is wrapped as the deployed ${lane} envelope; one the dispatcher would skip answers 422 lane_refused`);
+    }
+    console.log(`  invoke:  curl -X POST http://localhost:${port}/ -d '${sample[lane]}'`);
     console.log(`  scopes:  [${scopes.join(", ") || "none"}] \u2192 features [${auds.join(", ") || "none"}] (clamp reproduced locally)`);
     console.log(`  egress:  deny-by-default, same egressDecision as deployed \xB7 allowed: ${egressAllow.join(", ") || "(none beyond api.vxil.*)"}`);
     console.log("  caveat:  local edge calls use YOUR API key, not per-invoke scoped JWTs \u2014 the aud-level");