@xano/sdk 1.0.0

package/dist/chunk-K5BBGTYZ.js

@@ -0,0 +1,217 @@
+import {
+  isTaggedValue
+} from "./chunk-OXA6PSZT.js";
+import {
+  describeEntry,
+  protoKeyed
+} from "./chunk-CIMQZRRE.js";
+
+// src/values/obj.ts
+var IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function serializeValue(v, path, followed) {
+  const record = objSetRecord(v, path, followed);
+  if (record) return record;
+  const nowExpr = serializeEpochMs(v);
+  if (nowExpr !== null) return grouped(nowExpr + serializeFilters(v, path), v.filters, followed);
+  return grouped(serializeAtom(v, path) + serializeFilters(v, path), v.filters, followed);
+}
+function grouped(rendered, chain, followed) {
+  const tail = chain[chain.length - 1];
+  return followed && tail !== void 0 && tail.arg.length > 0 ? `(${rendered})` : rendered;
+}
+function serializeEpochMs(v) {
+  if (v.tag !== "const:epochms") return null;
+  if (v.value !== "now") return null;
+  return "now|to_epochms";
+}
+function objSetRecord(v, path, followed) {
+  if (v.tag !== "const:obj") return null;
+  if (v.value === "") {
+    throw new Error(
+      `obj(): \`${path}\` is \`c.obj(null)\`, the legacy BLANK object form \u2014 the engine evaluates it to null, not to {}. Write \`c.null()\` for the null, or \`c.obj()\` for an empty object.`
+    );
+  }
+  if (v.value !== "{}") {
+    const parsed = parseJson(v.value);
+    if (parsed === NOT_JSON) return null;
+    return grouped(serializeJson(parsed, path) + serializeFilters(v, path), v.filters, followed);
+  }
+  const members = [];
+  const keys = /* @__PURE__ */ new Set();
+  let i = 0;
+  for (; i < v.filters.length; i++) {
+    const f = v.filters[i];
+    if (f.name !== "set" || f.disabled || f.arg.length !== 2) break;
+    const [pathArg, member] = f.arg;
+    if (pathArg.tag !== "const" || pathArg.filters.length > 0) break;
+    const bracketed = pathArg.value.startsWith("[");
+    const key = parseSetPath(pathArg.value);
+    if (!IDENT.test(key)) {
+      if (!bracketed) break;
+      throw keyError(key, ` inside the \`c.obj\` at \`${path}\``);
+    }
+    if (keys.has(key)) break;
+    keys.add(key);
+    members.push([key, member]);
+  }
+  const parts = members.map(
+    ([key, member], idx) => `${key}: ${serializeValue(member, `${path}.${key}`, idx < members.length - 1)}`
+  );
+  const rendered = parts.length === 0 ? "{}" : `{ ${parts.join(", ")} }`;
+  const rest = { ...v, filters: v.filters.slice(i) };
+  return grouped(rendered + serializeFilters(rest, path), rest.filters, followed);
+}
+function parseSetPath(stored) {
+  const bracketed = /^\["(.*)"\]$/s.exec(stored);
+  return bracketed ? bracketed[1].replace(/\\(["\\])/g, "$1") : stored;
+}
+function keyError(key, where) {
+  return new Error(
+    `obj(): key "${key}"${where} must be a bare identifier ([A-Za-z_][A-Za-z0-9_]*) \u2014 XanoScript object keys aren't quoted.`
+  );
+}
+var NOT_JSON = /* @__PURE__ */ Symbol("not-json");
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return NOT_JSON;
+  }
+}
+function serializeJson(value, path) {
+  if (value === null) return "null";
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") return Number.isFinite(value) ? String(value) : "null";
+  if (Array.isArray(value)) {
+    return `[${value.map((el, i) => serializeJson(el, `${path}[${i}]`)).join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    const parts = Object.entries(value).map(([key, member]) => {
+      if (!IDENT.test(key)) {
+        throw keyError(key, ` at \`${path}\``);
+      }
+      return `${key}: ${serializeJson(member, `${path}.${key}`)}`;
+    });
+    return parts.length === 0 ? "{}" : `{ ${parts.join(", ")} }`;
+  }
+  return "null";
+}
+function serializeFilters(v, path) {
+  let out = "";
+  for (const f of v.filters) {
+    if (f.disabled) {
+      throw new Error(
+        `obj(): the value at \`${path}\` carries a DISABLED \`${f.name}\` filter. An object literal is stored as one expression string, which has no spelling for a disabled filter \u2014 drop it, or build the value in a prior step (e.g. \`s.set_var\`) and reference it with \`ref\`.`
+      );
+    }
+    const args = f.arg.map((a, i) => {
+      if (a.filters.length > 0) {
+        throw new Error(
+          `obj(): the \`${f.name}\` filter on member \`${path}\` has an argument (#${i}) that carries its own filter chain (\`ref(\u2026, { safe: true })\` is one). In an expression a trailing \`|\` binds to the whole value, not to one argument, so this cannot be written without changing what it means. Compute the argument in a prior step (\`s.set_var\`) and reference it with \`ref\`.`
+        );
+      }
+      return serializeAtom(a, `${path}|${f.name}[${i}]`);
+    });
+    out += `|${f.name}${args.length > 0 ? `:${args.join(":")}` : ""}`;
+  }
+  return out;
+}
+function serializeAtom(v, path) {
+  switch (v.tag) {
+    case "const":
+      return JSON.stringify(v.value);
+    // double-quoted + escaped, valid XanoScript string
+    case "const:int":
+    case "const:decimal":
+      return v.value;
+    // already the numeric literal (e.g. "123", "1.5")
+    case "const:bool":
+      return v.value === "true" ? "true" : "false";
+    case "const:null":
+      return "null";
+    case "input":
+      return `$input.${v.value}`;
+    case "var":
+      return `$var.${v.value}`;
+    case "auth":
+      return v.value ? `$auth.${v.value}` : "$auth";
+    case "col":
+      return `$db.${v.value}`;
+    // A workspace env var and a built-in request var are the SAME tag; the
+    // built-ins just carry a `$`-prefixed name. Both spell `$env.` + the name,
+    // so `sys.remoteIp()` renders `$env.$remote_ip` and `env("STRIPE_KEY")`
+    // renders `$env.STRIPE_KEY`.
+    case "setting":
+      return `$env.${v.value}`;
+    // The engine's native current-time constant reaches this function ONLY as a
+    // filter argument — a member position is answered by `serializeEpochMs`
+    // above. There it is unwritable: the value needs a leading `|to_epochms` to
+    // evaluate as a time at all (see `serializeEpochMs`), and inside an argument
+    // a trailing `|` binds to the whole value rather than to the argument, which
+    // is the same wall a pre-filtered argument hits.
+    case "const:epochms":
+      throw new Error(
+        `obj(): \`${path}\` is \`c.now()\` used as a FILTER ARGUMENT. In an expression the current-time constant has to carry a \`|to_epochms\` coercion, and a \`|\` inside an argument binds to the whole value instead \u2014 so this cannot be written without changing what it means. Compute it in a prior step (\`s.set_var("now", c.now())\`) and reference it with \`ref("now")\`.`
+      );
+    // `c.array([…])` stores plain JSON, and the literal grammar spells the same
+    // list — so it renders to the identical bytes a bare `[…]` member does. The
+    // bare form always worked and this one used to throw, which made the empty
+    // list (`c.array([])`) an export failure with no named way through.
+    // A nested `obj()` (or `c.expression`) is already expression source: a
+    // record literal inlines as the same bytes a bare `{…}` member renders; any
+    // other expression is grouped so a following `|` or `,` cannot split it.
+    case "const:expr2":
+      return v.value[0] == "{" ? v.value : `(${v.value})`;
+    case "const:array": {
+      const parsed = parseJson(v.value);
+      if (parsed !== NOT_JSON) return serializeJson(parsed, path);
+      break;
+    }
+  }
+  throw new Error(
+    `obj(): \`${path}\` is a value tagged "${v.tag}", which an object literal cannot carry. Bind it in a prior step (\`s.set_var("x", \u2026)\`) and use \`ref("x")\`.`
+  );
+}
+function serializeMember(m, path, followed = false) {
+  if (typeof m === "string") return JSON.stringify(m);
+  if (typeof m === "number") return String(m);
+  if (typeof m === "boolean") return m ? "true" : "false";
+  if (m === null) return "null";
+  if (isTaggedValue(m)) return serializeValue(m, path, followed);
+  if (Array.isArray(m)) {
+    return `[${m.map((el, i) => serializeMember(el, `${path}[${i}]`, i < m.length - 1)).join(", ")}]`;
+  }
+  const proto = typeof m === "object" ? Object.getPrototypeOf(m) : 0;
+  if (proto === Object.prototype || proto === null) return serializeRecord(m, path);
+  throw new Error(
+    `obj(): \`${path}\` must be a Value (inp/ref/auth/col/c.*), a scalar literal (string/number/boolean), a nested object, or an array (got ${describeEntry(m)}).`
+  );
+}
+function serializeRecord(rec, path) {
+  const entries = Object.entries(rec);
+  const parts = entries.map(([key, member], idx) => {
+    if (!IDENT.test(key)) {
+      throw keyError(key, path ? ` at \`${path}\`` : "");
+    }
+    return `${key}: ${serializeMember(member, path ? `${path}.${key}` : key, idx < entries.length - 1)}`;
+  });
+  return parts.length === 0 ? "{}" : `{ ${parts.join(", ")} }`;
+}
+function obj(fields) {
+  if (typeof fields !== "object" || fields === null || Array.isArray(fields) || isTaggedValue(fields) || protoKeyed(fields)) {
+    throw new Error(
+      `obj() takes a { key: value } record \u2014 got ${isTaggedValue(fields) ? "a value (`c.*`/`ref()`), which needs no obj()" : describeEntry(fields)}.`
+    );
+  }
+  return {
+    value: serializeRecord(fields, ""),
+    tag: "const:expr2",
+    filters: []
+  };
+}
+
+export {
+  obj
+};
+//# sourceMappingURL=chunk-K5BBGTYZ.js.map

package/dist/chunk-K6RXBGUB.js

@@ -0,0 +1,427 @@
+import {
+  confirm
+} from "./chunk-65HWOMGV.js";
+import {
+  discloseCanonicalMoves,
+  movesClause,
+  releaseCanonicalMoves
+} from "./chunk-BWPNT55T.js";
+import {
+  exportWorkspaceBundle
+} from "./chunk-CJHQKJU4.js";
+import {
+  DEFAULT_BRANCH_LABEL,
+  deleteBranch,
+  findBranch,
+  listBranchListing,
+  liveBranchLabel,
+  requireBranch,
+  setLiveBranch
+} from "./chunk-TRJCALW3.js";
+import {
+  sectionKind
+} from "./chunk-45UIT5T2.js";
+import {
+  assertOneName
+} from "./chunk-ZIY7RNUT.js";
+import {
+  getAccessToken
+} from "./chunk-ET4Y4XCB.js";
+import {
+  pipedYes
+} from "./chunk-T5KELPAR.js";
+import {
+  contextFlags
+} from "./chunk-NAQDMEHV.js";
+import {
+  shellWord
+} from "./chunk-FWD7AL6N.js";
+import {
+  describeWrite
+} from "./chunk-4KHEMC32.js";
+import {
+  CliError,
+  UsageError,
+  blank,
+  credentialWriteTarget,
+  describeWriteTarget,
+  detail,
+  discloseWriteTarget,
+  info,
+  isMachineOutput,
+  safeText,
+  step,
+  success,
+  suggestVerb,
+  warn,
+  writeJson,
+  writeTargetPayload
+} from "./chunk-PTHVMXZI.js";
+import {
+  suggestAll
+} from "./chunk-UTI5G6OJ.js";
+
+// src/emit/branch-commands.ts
+var VERBS = ["list", "set-live", "delete"];
+function assertVerb(verb) {
+  if (verb !== void 0 && VERBS.includes(verb)) return verb;
+  throw new UsageError(
+    verb === void 0 ? `\`xanosdk workspace branch\` needs a verb: ${VERBS.join(", ")}.` : `\`xanosdk workspace branch ${verb}\` is not a verb. Expected one of: ${VERBS.join(", ")}.`,
+    {
+      helpFor: { command: "workspace", subcommand: "branch" },
+      ...verb === void 0 ? {} : { suggestion: suggestVerb(verb, VERBS) }
+    }
+  );
+}
+function requireLabel(label, verb) {
+  if (label !== void 0 && label.trim() !== "") return label;
+  throw new UsageError(`\`xanosdk workspace branch ${verb}\` needs a branch label.`, {
+    helpFor: { command: "workspace", subcommand: "branch" }
+  });
+}
+function shownLabel(label) {
+  return safeText(/\s/.test(label) ? JSON.stringify(label) : label);
+}
+function renderUnaddressable(rows) {
+  if (rows.length === 0) return;
+  blank();
+  warn(
+    `${rows.length} branch${rows.length === 1 ? "" : "es"} here carr${rows.length === 1 ? "ies" : "y"} no label:`,
+    "branch.unlabeled",
+    [
+      ...rows.map((r) => {
+        const tags = [r.live ? "LIVE" : "", r.backup ? "backup" : ""].filter(Boolean).join(", ");
+        return `(unnamed, created ${r.createdAt ?? "at an unknown time"})${tags === "" ? "" : `  (${tags})`}`;
+      }),
+      "Every branch route addresses a branch by label, so these cannot be",
+      "selected, made live, or deleted from here \u2014 remove one in the Xano dashboard."
+    ]
+  );
+}
+function renderList(branches, unaddressable, workspaceId) {
+  blank();
+  step(`Branches in workspace #${workspaceId}`);
+  if (branches.length === 0 && unaddressable.length === 0) {
+    detail("none reported");
+    return;
+  }
+  for (const b of branches) {
+    const tags = [b.live ? "live" : "", b.backup ? "backup" : ""].filter(Boolean).join(", ");
+    detail(`${shownLabel(b.label)}${tags === "" ? "" : `  (${tags})`}`);
+  }
+  renderUnaddressable(unaddressable);
+  blank();
+  detail("Branches scope logic. Tables and microservices are shared by every branch.");
+}
+async function runBranchCommand(args) {
+  const verb = assertVerb(args.positionals[0]);
+  if (verb === "list" && args.positionals.length > 1) {
+    throw new UsageError(
+      `\`xanosdk workspace branch list\` takes no argument, and was also given \`${args.positionals[1]}\`.`,
+      { hintFor: { command: "workspace", subcommand: "branch" } }
+    );
+  }
+  if (args.expectLive !== void 0 && verb !== "set-live") {
+    throw new UsageError(
+      `\`--expect-live\` guards a switch of the live branch, and \`xanosdk workspace branch ${verb}\` makes none. It belongs to \`xanosdk workspace branch set-live <branch> --expect-live <label>\`; drop it here.`,
+      { hintFor: { command: "workspace", subcommand: "branch" } }
+    );
+  }
+  const typedLabel = args.positionals[1];
+  if (typedLabel !== void 0) assertOneName(typedLabel, "the branch label", { args, helpFor: { command: "workspace", subcommand: "branch" } });
+  if (verb === "delete" && typedLabel?.trim() === DEFAULT_BRANCH_LABEL) {
+    throw new UsageError(
+      `Branch "${DEFAULT_BRANCH_LABEL}" is the workspace's default branch, which cannot be deleted. Nothing was sent.`,
+      { hintFor: { command: "workspace", subcommand: "branch" } }
+    );
+  }
+  const auth = await getAccessToken(args);
+  const workspaceId = auth.workspaceId;
+  const target = { baseUrl: auth.instance, workspaceId };
+  const { branches, unaddressable } = await listBranchListing(auth, target).catch(async (err) => {
+    const { unansweredRead } = await import("./source-resolve-S2XA3XZF.js");
+    throw unansweredRead(err, `list the branches of workspace ${workspaceId}`, "workspace");
+  });
+  if (verb === "list") {
+    if (isMachineOutput(args)) {
+      writeJson({ workspaceId, instance: auth.instance, branches, unaddressable });
+      return;
+    }
+    renderList(branches, unaddressable, workspaceId);
+    return;
+  }
+  const typed = requireLabel(args.positionals[1], verb);
+  if (verb === "delete" && findBranch(branches, typed) === void 0) {
+    const label2 = typed;
+    const destination2 = credentialWriteTarget({ instance: auth.instance, workspaceId });
+    const known = branches.map((b) => shownLabel(b.label)).join(", ");
+    const near = suggestAll(label2.trim(), branches.filter((b) => !b.live && b.label.trim() !== DEFAULT_BRANCH_LABEL).map((b) => b.label));
+    const again = `${args.json === true ? " --json" : ""}${contextFlags(args)}`;
+    const missed = `No branch named "${label2}" on ${describeWriteTarget(destination2)} \u2014 nothing was deleted.`;
+    const meant = near.map((n) => `Did you mean "${safeText(n)}"? \`xanosdk workspace branch delete ${shellWord(n)}${again}\` deletes it, after asking to confirm.`);
+    const branchesLine = known !== "" ? [`Its branches: ${known}.`] : [];
+    if (near.length > 0) {
+      const { SourceError } = await import("./source-resolve-S2XA3XZF.js");
+      throw new SourceError([missed, ...meant, ...branchesLine].join("\n"), "gone", "workspace", near[0], near.length > 1 ? near : void 0);
+    }
+    warn(missed, "branch.not-found", branchesLine);
+    if (isMachineOutput(args)) {
+      writeJson({
+        verb: "delete",
+        destination: writeTargetPayload(destination2),
+        workspaceId,
+        branch: label2,
+        deleted: false,
+        alreadyGone: true,
+        declined: false
+      });
+    }
+    return;
+  }
+  const branch = requireBranch(branches, typed);
+  const label = branch.label;
+  if (verb === "delete" && branch.live) {
+    throw new CliError(
+      "SDK_BRANCH_LIVE",
+      `Branch "${label}" is the LIVE branch of workspace #${workspaceId} and cannot be deleted.
+Promote another branch first (\`xanosdk workspace branch set-live <other>${pipedYes(args)}${contextFlags()}\`), then delete this one.`,
+      { exitCode: 2, details: { conflictsWith: { live: label } } }
+    );
+  }
+  const destination = credentialWriteTarget({ instance: auth.instance, workspaceId });
+  const refusing = verb === "delete" && args.yes !== true && process.stdin.isTTY !== true;
+  step(
+    verb === "set-live" ? `Making branch ${shownLabel(label)} live` : `${refusing ? "Would delete" : "Deleting"} branch ${shownLabel(label)}`
+  );
+  discloseWriteTarget(destination);
+  if (verb === "set-live") {
+    if (args.expectLive !== void 0) {
+      const mismatch = liveMismatch({ branches, unaddressable }, args.expectLive);
+      if (mismatch !== void 0) {
+        throw liveBranchMismatch(
+          `\`--expect-live ${args.expectLive}\` does not hold: ${mismatch.why}. Nothing was switched.
+Check what is serving with \`xanosdk workspace branch list${contextFlags()}\`, then run set-live again.`,
+          mismatch.live
+        );
+      }
+    }
+    if (branch.live) {
+      success(`Branch "${label}" is already live in workspace #${workspaceId} \u2014 nothing to do.`);
+      if (isMachineOutput(args)) {
+        writeJson({
+          verb: "set-live",
+          destination: writeTargetPayload(destination),
+          workspaceId,
+          branch: label,
+          setLive: false,
+          alreadyLive: true,
+          declined: false
+        });
+      }
+      return;
+    }
+    const outgoing = branches.find((b) => b.live)?.label;
+    blank();
+    if (outgoing !== void 0) {
+      warn(
+        `This is a production cutover for workspace #${workspaceId}.`,
+        "branch.production-cutover",
+        [`The runtime stops serving "${outgoing}" and starts serving "${label}".`]
+      );
+    } else {
+      warn(`No branch is live in workspace #${workspaceId} \u2014 "${label}" becomes the branch the runtime serves.`, "branch.none-live");
+    }
+    detail("Table data is unaffected \u2014 it is shared by every branch either way.");
+    const readBranch = (name) => exportWorkspaceBundle(auth, {
+      base: auth.instance,
+      workspaceId,
+      label: `reading branch ${shownLabel(name)}`,
+      branch: name,
+      safeErrors: true
+    }).catch(() => void 0);
+    const [incoming, served] = await Promise.all([
+      readBranch(label),
+      outgoing === void 0 ? Promise.resolve(void 0) : readBranch(outgoing)
+    ]);
+    const stale = incoming === void 0 ? [] : staleSchemaRefs(incoming);
+    if (stale.length > 0) {
+      warn(
+        `"${label}"'s logic writes ${stale.length === 1 ? "a column" : `${stale.length} columns`} the shared tables no longer have \u2014 once it is live, ${stale.length === 1 ? "that write stores" : "those writes store"} nothing there:`,
+        "branch.stale-schema-refs",
+        stale
+      );
+    }
+    const moves = incoming === void 0 || served === void 0 ? [] : releaseCanonicalMoves(incoming, served);
+    discloseCanonicalMoves(moves, { subject: "the set-live", when: "as it goes live" });
+    blank();
+    if (!args.yes) {
+      const ok = await confirm(`Make "${label}" the live branch?${movesClause(moves)}`, {
+        flag: "--yes",
+        refusal: {
+          details: { verb: "set-live", branch: label, setLive: false, alreadyLive: false, declined: false },
+          rerun: branchRerun(args, "set-live", label)
+        }
+      });
+      if (!ok) {
+        info("Set-live cancelled \u2014 nothing was switched; the live branch is unchanged.");
+        if (isMachineOutput(args)) {
+          writeJson({
+            verb: "set-live",
+            destination: writeTargetPayload(destination),
+            workspaceId,
+            branch: label,
+            setLive: false,
+            alreadyLive: false,
+            declined: true
+          });
+        }
+        return;
+      }
+    }
+    if (args.expectLive !== void 0) {
+      const now = await listBranchListing(auth, target).catch(async (err) => {
+        const { unansweredRead } = await import("./source-resolve-S2XA3XZF.js");
+        throw unansweredRead(err, `list the branches of workspace ${workspaceId}`, "workspace");
+      });
+      const drift = liveMismatch(now, args.expectLive);
+      if (drift !== void 0) {
+        throw liveBranchMismatch(
+          `\`--expect-live ${args.expectLive}\` no longer holds \u2014 ${drift.why}. Live changed while this ran; the check is not atomic, so it is re-read before switching and the switch refused. Nothing was switched.
+Check what is serving with \`xanosdk workspace branch list${contextFlags()}\`, then run set-live again.`,
+          drift.live
+        );
+      }
+    }
+    await describeWrite(
+      { what: `the switch of the live branch to "${label}"`, resolveWith: `xanosdk workspace branch list${contextFlags()}` },
+      () => setLiveBranch(auth, { ...target, label })
+    );
+    success(`Branch "${label}" is now live in workspace #${workspaceId}.`);
+    if (outgoing !== void 0) {
+      detail(`Roll back with \`xanosdk workspace branch set-live ${outgoing}${pipedYes(args)}${contextFlags()}\`.`);
+    }
+    if (isMachineOutput(args)) {
+      writeJson({
+        verb: "set-live",
+        destination: writeTargetPayload(destination),
+        workspaceId,
+        branch: label,
+        setLive: true,
+        alreadyLive: false,
+        previousBranch: outgoing,
+        canonicalMoves: moves,
+        declined: false
+      });
+    }
+    return;
+  }
+  if (!args.yes) {
+    const ok = await confirm(`Delete branch "${label}" from workspace #${workspaceId}?`, {
+      flag: "--yes",
+      refusal: {
+        details: { verb: "delete", branch: label, deleted: false, alreadyGone: false, declined: false },
+        rerun: branchRerun(args, "delete", label)
+      }
+    });
+    if (!ok) {
+      info("Deletion cancelled \u2014 nothing was deleted.");
+      if (isMachineOutput(args)) {
+        writeJson({
+          verb: "delete",
+          destination: writeTargetPayload(destination),
+          workspaceId,
+          branch: label,
+          deleted: false,
+          alreadyGone: false,
+          declined: true
+        });
+      }
+      return;
+    }
+  }
+  await describeWrite(
+    { what: `the delete of branch "${label}"`, resolveWith: `xanosdk workspace branch list${contextFlags()}` },
+    () => deleteBranch(auth, { ...target, label })
+  );
+  success(`Deleted branch "${label}" from workspace #${workspaceId}.`);
+  if (isMachineOutput(args)) {
+    writeJson({
+      verb: "delete",
+      destination: writeTargetPayload(destination),
+      workspaceId,
+      branch: label,
+      deleted: true,
+      alreadyGone: false,
+      declined: false
+    });
+  }
+}
+function liveMismatch(listing, expected) {
+  const live = liveBranchLabel(listing.branches);
+  if (live === expected) return void 0;
+  if (live !== void 0) return { why: `"${live}" is live, not "${expected}"`, live };
+  if (listing.unaddressable.some((b) => b.live)) {
+    return { why: `the live branch has no label, so it cannot be "${expected}"`, live: null };
+  }
+  return { why: `no branch reports as live, so "${expected}" is not`, live: null };
+}
+function liveBranchMismatch(message, live) {
+  return new CliError("SDK_LIVE_BRANCH_MISMATCH", message, { details: { conflictsWith: { live } }, exitCode: 2 });
+}
+function branchRerun(args, verb, label) {
+  const expect = verb === "set-live" && args.expectLive !== void 0 ? ` --expect-live ${shellWord(args.expectLive)}` : "";
+  return `xanosdk workspace branch ${verb} ${shellWord(label)}${expect} --yes${args.json === true ? " --json" : ""}${contextFlags(args)}`;
+}
+var ROW_WRITES = /^mvp:dbo_(?:add|edit|add_or_edit|patch)$/;
+function staleSchemaRefs(bundle) {
+  const payload = bundle?.payload;
+  if (payload === null || typeof payload !== "object") return [];
+  const sections = payload;
+  const tables = /* @__PURE__ */ new Map();
+  for (const t of Array.isArray(sections.dbo) ? sections.dbo : []) {
+    if (typeof t?.guid !== "string") continue;
+    const schema = Array.isArray(t.schema) ? t.schema : [];
+    tables.set(t.guid, {
+      name: typeof t.name === "string" ? t.name : t.guid,
+      columns: new Set(schema.map((c) => c?.name).filter((n) => typeof n === "string"))
+    });
+  }
+  const out = /* @__PURE__ */ new Set();
+  const walk = (node, where) => {
+    if (Array.isArray(node)) {
+      for (const n of node) walk(n, where);
+      return;
+    }
+    if (node === null || typeof node !== "object") return;
+    const stmt = node;
+    const ref = stmt.context?.dbo?.id;
+    if (typeof stmt.name === "string" && ROW_WRITES.test(stmt.name) && typeof ref === "string" && Array.isArray(stmt.input)) {
+      const table = tables.get(ref);
+      for (const field of stmt.input) {
+        if (typeof field?.name !== "string" || field.ignore === true) continue;
+        if (table === void 0) out.add(`a table no longer there (${ref}).${field.name}${where}`);
+        else if (!table.columns.has(field.name)) out.add(`${table.name}.${field.name}${where}`);
+      }
+    }
+    for (const value of Object.values(stmt)) walk(value, where);
+  };
+  for (const [section, rows] of Object.entries(sections)) {
+    if (section === "dbo" || !Array.isArray(rows)) continue;
+    for (const row of rows) {
+      if (row === null || typeof row !== "object") continue;
+      const name = typeof row.name === "string" ? row.name : "";
+      const verb = typeof row.verb === "string" ? `${row.verb} ` : "";
+      walk(row, ` (${sectionKind(section, row)} ${verb}${name})`);
+    }
+  }
+  return [...out];
+}
+
+export {
+  shownLabel,
+  runBranchCommand,
+  liveMismatch,
+  liveBranchMismatch,
+  staleSchemaRefs
+};
+//# sourceMappingURL=chunk-K6RXBGUB.js.map