@xano/sdk 1.0.0

package/dist/keep-data-merge-7MPLVAVI.js

@@ -0,0 +1,1119 @@
+import {
+  assertStorageModesKept,
+  discloseTableEffects,
+  droppedAndAdded,
+  tableEffectFields,
+  tableEffectsOf
+} from "./chunk-BWPNT55T.js";
+import "./chunk-TPHWJ7UG.js";
+import {
+  tableRowCounter
+} from "./chunk-C6RIMRU4.js";
+import {
+  XANOSDK_IMPORT_UNIQUENESS_CODE,
+  XanoSdkImportRefusal,
+  detectXanoSdkImportRoute,
+  xanosdkImport
+} from "./chunk-WQFNASK4.js";
+import {
+  exportWorkspaceBundle
+} from "./chunk-CJHQKJU4.js";
+import {
+  encodeWorkspaceArchive
+} from "./chunk-3DRXWLJ5.js";
+import "./chunk-X4DVXBFY.js";
+import {
+  diffAgainstLive,
+  payloadOf,
+  planTypeSection,
+  rowLabeler,
+  sectionKind,
+  storedColumnsAfter,
+  tableAdditions
+} from "./chunk-45UIT5T2.js";
+import "./chunk-HRVBLCVJ.js";
+import "./chunk-2ZUEE4EK.js";
+import "./chunk-AN6BL47T.js";
+import "./chunk-A3UDOZB6.js";
+import "./chunk-2MNLRIOX.js";
+import "./chunk-7G3CTU7I.js";
+import "./chunk-6PBR37LN.js";
+import "./chunk-NAQDMEHV.js";
+import {
+  shellWord
+} from "./chunk-FWD7AL6N.js";
+import "./chunk-4KHEMC32.js";
+import {
+  seedRowsByTableGuid
+} from "./chunk-U64O2MXY.js";
+import "./chunk-ROY4YAEQ.js";
+import "./chunk-XW6KISBB.js";
+import "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import {
+  UNTRUSTED_CERTIFICATE
+} from "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-3YW23UFH.js";
+import {
+  CliError,
+  detail,
+  displayPath,
+  warn,
+  withSpinner
+} from "./chunk-PTHVMXZI.js";
+import "./chunk-2CMJZDCL.js";
+import "./chunk-K5BBGTYZ.js";
+import "./chunk-LQCMKAJ7.js";
+import "./chunk-6HO3NCSJ.js";
+import "./chunk-5V5XU32D.js";
+import "./chunk-HVRUQXGD.js";
+import "./chunk-ERVIASGL.js";
+import "./chunk-4POWHT2K.js";
+import "./chunk-H2V3N23D.js";
+import "./chunk-3JDU4VRL.js";
+import "./chunk-WTPZRR4I.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import {
+  LOCK_PAYLOAD_KEYS
+} from "./chunk-6MR5TI5V.js";
+import {
+  shellQuote
+} from "./chunk-5ZSO4T2G.js";
+import "./chunk-XNCP4KYO.js";
+import "./chunk-YU4HSQW7.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-EHP3WPEG.js";
+import "./chunk-L5JYN3NM.js";
+import "./chunk-G554NZNI.js";
+import "./chunk-N5GKCWE5.js";
+import "./chunk-OXA6PSZT.js";
+import "./chunk-VAX3UZOY.js";
+import "./chunk-NZOWWHU5.js";
+import "./chunk-4BW2SG2N.js";
+import "./chunk-TTEIYD5P.js";
+import "./chunk-CIMQZRRE.js";
+import "./chunk-OHX6MIUZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/emit/canonical-steps.ts
+function slugMoveSteps(moves, held) {
+  const at = new Map(moves.map((m) => [m.guid, m.from]));
+  const owner = new Map(held);
+  const taken = /* @__PURE__ */ new Set([...held.keys(), ...moves.map((m) => m.to)]);
+  const steps = [];
+  for (let round = 0; round <= moves.length + 1; round++) {
+    const pending = moves.filter((m) => at.get(m.guid) !== m.to);
+    const blocked = pending.filter((m) => {
+      const holder = owner.get(m.to);
+      return holder !== void 0 && holder !== m.guid;
+    });
+    if (blocked.length === 0) {
+      steps.push([]);
+      return steps;
+    }
+    if (blocked.some((m) => !pending.some((p) => p.guid === owner.get(m.to)))) return void 0;
+    const wants = new Map(blocked.map((m) => [m.guid, m.to]));
+    const parked = /* @__PURE__ */ new Set();
+    for (const m of blocked) {
+      const seen = [];
+      let cur = m.guid;
+      while (cur !== void 0 && wants.has(cur) && !seen.includes(cur)) {
+        seen.push(cur);
+        cur = owner.get(wants.get(cur));
+      }
+      if (cur === void 0 || !seen.includes(cur)) continue;
+      const cycle = seen.slice(seen.indexOf(cur));
+      if (!cycle.some((g) => parked.has(g))) parked.add(cycle[0]);
+    }
+    const blockedGuids = new Set(wants.keys());
+    const step = [];
+    const next = /* @__PURE__ */ new Map();
+    for (const m of pending) {
+      if (!blockedGuids.has(m.guid)) {
+        next.set(m.guid, m.to);
+        continue;
+      }
+      const here = at.get(m.guid);
+      if (parked.has(m.guid) || here === void 0) {
+        const slug = freeSlug(here ?? m.to, taken);
+        taken.add(slug);
+        step.push({ kind: m.kind, name: m.name, slug, declared: m.to, why: "park" });
+        next.set(m.guid, slug);
+      } else {
+        step.push({ kind: m.kind, name: m.name, slug: here, declared: m.to, why: "stay" });
+      }
+    }
+    for (const [guid, slug] of next) {
+      const before = at.get(guid);
+      if (before !== void 0 && owner.get(before) === guid) owner.delete(before);
+      if (slug !== void 0) owner.set(slug, guid);
+      at.set(guid, slug);
+    }
+    steps.push(step);
+  }
+  return void 0;
+}
+function freeSlug(base, taken) {
+  for (let n = 1; ; n++) {
+    const slug = n === 1 ? `${base}-tmp` : `${base}-tmp${n}`;
+    if (!taken.has(slug)) return slug;
+  }
+}
+function renderSlugSteps(steps, rerun, indent = "  ") {
+  const id = (o) => `${o.kind}\0${o.name}`;
+  return steps.map((step, i) => {
+    const here = new Set(step.map(id));
+    const set = step.map(
+      (o) => `${o.kind} "${o.name}"'s canonical to "${o.slug}" (${o.why === "park" ? "a slug nobody holds" : "where it is now"})`
+    );
+    const back = (i === 0 ? [] : steps[i - 1]).filter((o) => !here.has(id(o))).map((o) => `${o.kind} "${o.name}"'s canonical back to "${o.declared}" (as declared)`);
+    const listed = [...set, ...back];
+    const what = listed.length === 0 ? "deploy the project as declared" : `set ${listed.join(", ")} \u2014 every other canonical as declared`;
+    return `${indent}${i + 1}. ${what}, then run \`${rerun}\``;
+  });
+}
+
+// src/emit/keep-data-merge.ts
+var TABLE_KINDS = /* @__PURE__ */ new Set(["table", "dbo"]);
+function cannotMergeError(label) {
+  return new Error(
+    `\`--keep-data\` cannot keep ${label}'s rows: this environment predates the SDK import route, which every deploy writes through. Nothing was sent, and its data is untouched.
+Update it: \`xanosdk local-engine update\` for a local engine, or update the Xano instance behind an ephemeral environment. Dropping \`--keep-data\` will not help \u2014 a replacing deploy uses the same route.`
+  );
+}
+async function unreachableProbeError(err, req) {
+  const reach = err instanceof Error ? /: could not reach it \((.*)\)\.\n/.exec(err.message) : null;
+  const status = err?.status;
+  const answered = err instanceof Error ? /: the probe answered (.*)\n/.exec(err.message) : null;
+  if (status === 501 && answered !== null) {
+    const label = `${req.label[0].toUpperCase()}${req.label.slice(1)}`;
+    const replace = req.rerun === void 0 ? "deploy without `--keep-data`" : `\`${req.rerun.command.split(" ").filter((w) => w !== "--keep-data").join(" ")}\``;
+    return new Error(
+      `${label} answered the check whether it can merge with ${answered[1].replace(/\.$/, "")}: it does not support a \`--keep-data\` merge. Nothing was sent, and its data is untouched. To deploy anyway, ${replace} \u2014 a replace, which also replaces its rows with the seed rows.${req.rerun?.note ?? ""}`
+    );
+  }
+  const serverError = typeof status === "number" && (status >= 500 || status === 429) && answered !== null;
+  if (reach === null && !serverError || req.rerun === void 0) return err;
+  const { LookupFailedError, rateLimitedCause } = await import("./source-resolve-S2XA3XZF.js");
+  const failed = new LookupFailedError(
+    reach !== null ? `Could not reach ${req.label} to ask whether it can merge (${reach[1]}). ${reach[1].includes(UNTRUSTED_CERTIFICATE) ? "A certificate problem" : "A network failure"} \u2014 nothing was sent and its data is untouched` : `${req.label[0].toUpperCase()}${req.label.slice(1)} answered the check whether it can merge with ${status === 429 ? "its rate limit" : "a server error"} (${answered[1].replace(/\.$/, "")}). ${status === 429 ? `${rateLimitedCause()}: nothing` : "Nothing"} was sent and its data is untouched`,
+    "unreachable",
+    req.kind ?? "ephemeral",
+    `run \`${req.rerun.command}\` again`,
+    status === 429 ? "Once the wait is over" : void 0
+  );
+  failed.message += req.rerun.note;
+  return failed;
+}
+async function unansweredReadError(err, req) {
+  if (req.rerun === void 0) return err;
+  const { LookupFailedError, isRateLimited, isServerError, isTransportFailure, unansweredCause } = await import("./source-resolve-S2XA3XZF.js");
+  const transport = isTransportFailure(err);
+  if (!transport && !isServerError(err)) return err;
+  const first = ((err instanceof Error ? err.message : String(err)).trim().split("\n")[0] ?? "").replace(/[.:]$/, "");
+  const failed = new LookupFailedError(
+    `${first[0]?.toUpperCase() ?? ""}${first.slice(1)}. ${unansweredCause(err)} \u2014 nothing was written and its data is untouched`,
+    "unreachable",
+    req.kind ?? "ephemeral",
+    `run \`${req.rerun.command}\` again`,
+    isRateLimited(err) ? "Once the wait is over" : void 0
+  );
+  failed.message += req.rerun.note;
+  return failed;
+}
+var EXIT_CONFLICT = 2;
+function refusalDetails(refused, lists) {
+  return {
+    refused,
+    ...lists.serverCode === void 0 ? {} : { serverCode: lists.serverCode },
+    conflicts: lists.conflicts ?? [],
+    renames: lists.renames ?? [],
+    outOfScope: lists.outOfScope ?? []
+  };
+}
+var EXIT_TRANSIENT = 8;
+function importInProgressError(label, rerun, refusal) {
+  const again = rerun === void 0 ? "run the same command again" : `run \`${rerun.command}\` again`;
+  return new CliError(
+    "SDK_IMPORT_REFUSED",
+    `${label.charAt(0).toUpperCase()}${label.slice(1)} was busy with another import, so this one did not start.
+Nothing was written \u2014 its data is intact, and nothing in the project has to change: ${again} in a moment.${rerun?.note ?? ""}`,
+    {
+      exitCode: EXIT_TRANSIENT,
+      details: { refused: "importInProgress", landed: false, serverCode: refusal.code, ...rerun === void 0 ? {} : { rerun: rerun.command } }
+    }
+  );
+}
+function refusedError(label, refusal, indexChanges = [], rerun) {
+  if (refusal.retryable) return importInProgressError(label, rerun, refusal);
+  const conflicts = refusal.conflicts.map(
+    (c) => `  ${c.kind} "${c.identity}"${c.owner.guid === void 0 ? "" : ` (held by guid ${c.owner.guid})`}`
+  );
+  const uniqueAdds = indexChanges.filter((c) => c.action === "add" && c.unique);
+  const unique = refusal.code === XANOSDK_IMPORT_UNIQUENESS_CODE && uniqueAdds.length > 0 ? `The merge adds ${uniqueAdds.length === 1 ? "a unique index" : "unique indexes"} the rows already there may hold duplicates for:
+${uniqueAdds.map((c) => `  table ${c.table}: ${c.index}`).join("\n")}
+Remove the duplicate rows or the index.
+` : "";
+  const message = `${label} refused the merge: ${refusal.reason}
+` + (conflicts.length > 0 ? `${conflicts.join("\n")}
+` : "") + unique + `Nothing was written \u2014 the environment's data is intact.
+Fix what it names and deploy again, or rebuild the environment from the project with \`${rerun === void 0 ? "xanosdk deploy --keep-data --reset" : withFlag(rerun.command, "--reset")}\` (that replaces its rows with the seed rows).${rerun?.note ?? ""}`;
+  if (refusal.code === XANOSDK_IMPORT_UNIQUENESS_CODE) {
+    const err2 = new CliError("SDK_IMPORT_REFUSED", message, {
+      exitCode: EXIT_CONFLICT,
+      details: {
+        ...refusalDetails("uniqueViolation", { serverCode: refusal.code }),
+        landed: false,
+        indexes: uniqueAdds.map((c) => ({ table: c.table, index: c.index }))
+      }
+    });
+    return Object.assign(err2, { cause: refusal });
+  }
+  if (refusal.conflicts.length === 0) return new Error(message, { cause: refusal });
+  const err = new CliError("SDK_IDENTITY_CONFLICT", message, {
+    exitCode: EXIT_CONFLICT,
+    details: refusalDetails("identityConflict", {
+      serverCode: refusal.code,
+      conflicts: refusal.conflicts.map((c) => ({
+        kind: sectionKind(planTypeSection(c.kind)),
+        name: c.identity,
+        liveGuid: c.owner.guid ?? null,
+        projectGuid: c.archiveGuid ?? null
+      }))
+    })
+  });
+  return Object.assign(err, { cause: refusal });
+}
+function liveTableTriggers(live) {
+  const tables = /* @__PURE__ */ new Map();
+  for (const row of payloadRows(live, "dbo")) {
+    if (typeof row.guid === "string" && typeof row.name === "string") tables.set(row.guid, row.name);
+  }
+  return payloadRows(live, "trigger").filter((row) => row.obj_type === "database").map((row) => {
+    const table = typeof row.obj_id === "string" ? row.obj_id : "";
+    return { name: typeof row.name === "string" ? row.name : "", table: tables.get(table) ?? table };
+  });
+}
+function tableTriggerMergeError(label, triggers, remedy) {
+  const one = triggers.length === 1;
+  const lines = triggers.map((t) => `  ${t.name} (table ${t.table})`);
+  return new CliError(
+    "SDK_IMPORT_REFUSED",
+    `${label.charAt(0).toUpperCase()}${label.slice(1)} was not merged: it holds ${one ? "a table trigger" : `${triggers.length} table triggers`}, and a merge into an ephemeral or a tenant fails while one is there (the instance answers 500, after part of the merge may have landed):
+${lines.join("\n")}
+Nothing was written \u2014 the environment's data is intact. Removing the trigger from the project does not help while the environment holds it. A replace works; it replaces the rows with the seed rows: \`${remedy.command}\`.${remedy.note}`,
+    {
+      exitCode: EXIT_CONFLICT,
+      details: { refused: "tableTrigger", landed: false, triggers: triggers.map((t) => ({ ...t })) }
+    }
+  );
+}
+function nameCollisions(operations, live, outgoing) {
+  const deleted = new Set(operations.filter((o) => o.action === "delete").map((o) => `${o.type}\0${o.name}`));
+  const pairs = operations.filter((o) => o.action === "create" && deleted.has(`${o.type}\0${o.name}`));
+  if (pairs.length === 0) return [];
+  const liveLabel = rowLabeler(payloadOf(live));
+  const outLabel = rowLabeler(payloadOf(outgoing));
+  const guids = (rows) => new Set(rows.map((r) => r.guid));
+  const out = [];
+  for (const op of pairs) {
+    const section = planTypeSection(op.type);
+    const liveRows = payloadRows(live, section);
+    const outRows = payloadRows(outgoing, section);
+    const liveGuids = guids(liveRows);
+    const outGuids = guids(outRows);
+    const gone = liveRows.filter((r) => r.name === op.name && !outGuids.has(r.guid));
+    for (const row of outRows.filter((r) => r.name === op.name && !liveGuids.has(r.guid))) {
+      const label = outLabel(section, row);
+      const held = gone.find((g) => liveLabel(section, g) === label);
+      if (held === void 0) continue;
+      out.push({
+        kind: sectionKind(section, row),
+        name: label.slice(label.indexOf(":") + 1),
+        liveGuid: typeof held.guid === "string" ? held.guid : null,
+        projectGuid: typeof row.guid === "string" ? row.guid : null
+      });
+    }
+  }
+  return out;
+}
+function collisionError(label, collisions, resetRerun) {
+  const one = collisions.length === 1;
+  const lines = collisions.map(
+    (c) => `  ${c.kind} "${c.name}" \u2014 live guid ${c.liveGuid ?? "unknown"}, the project's ${c.projectGuid ?? "unknown"}`
+  );
+  return new CliError(
+    "SDK_IDENTITY_CONFLICT",
+    `${label} cannot merge: it holds ${one ? "an object" : "objects"} under ${one ? "a name" : "names"} the project sends under another identity. A merge matches on guid, so it would delete the live one and create the project's beside it, which the environment refuses by name:
+${lines.join("\n")}
+Nothing was written \u2014 the environment's data is intact.
+Rebuild the environment from the project with \`${resetRerun}\` (that replaces its rows with the seed rows), or give one of ${one ? "the two" : "each pair"} another name.`,
+    { exitCode: EXIT_CONFLICT, details: refusalDetails("identityConflict", { conflicts: collisions }) }
+  );
+}
+var COMPOSING_PARENTS = {
+  message: ["channel", "realtime_server"],
+  channel: ["realtime_server"],
+  query: ["app"]
+};
+function parentRenames(collisions, live, outgoing, pins) {
+  const entries = pins?.entries;
+  if (entries === void 0 || pins?.keyFixUps === void 0) return [];
+  const keyOf = /* @__PURE__ */ new Map();
+  for (const [key, guid] of entries) keyOf.set(guid, key);
+  const guidsIn = (bundle, section) => new Set(payloadRows(bundle, section).map((r) => r.guid).filter((g) => typeof g === "string"));
+  const out = /* @__PURE__ */ new Map();
+  for (const collision of collisions) {
+    const key = collision.liveGuid === null ? void 0 : keyOf.get(collision.liveGuid);
+    if (key === void 0) continue;
+    const sep = key.indexOf(":");
+    const parts = key.slice(sep + 1).split("|");
+    let found;
+    for (let n = parts.length - 1; n >= 1 && found === void 0; n--) {
+      const name = parts.slice(0, n).join("|");
+      for (const section of COMPOSING_PARENTS[key.slice(0, sep)] ?? []) {
+        const guid = entries.get(`${section}:${name}`);
+        if (guid === void 0 || !guidsIn(live, section).has(guid) || guidsIn(outgoing, section).has(guid)) continue;
+        found = { section, name, guid };
+        break;
+      }
+    }
+    if (found === void 0) continue;
+    const parentKey = `${found.section}:${found.name}`;
+    const existing = out.get(parentKey);
+    if (existing !== void 0) {
+      existing.children.push(collision);
+      continue;
+    }
+    const scope = found.name.includes("|") ? found.name.slice(0, found.name.lastIndexOf("|") + 1) : "";
+    const liveGuids = guidsIn(live, found.section);
+    const sent = guidsIn(outgoing, found.section);
+    const candidates = [...entries].filter(([k, g]) => k.startsWith(`${found.section}:${scope}`) && sent.has(g) && !liveGuids.has(g)).map(([k]) => k.slice(found.section.length + 1)).filter((name) => scope === "" ? !name.includes("|") : !name.slice(scope.length).includes("|"));
+    const fix = pins.keyFixUps(parentKey, candidates.length === 1 ? candidates[0] : void 0);
+    if (fix === void 0) continue;
+    out.set(parentKey, {
+      kind: sectionKind(found.section),
+      name: found.name,
+      guid: found.guid,
+      candidates,
+      rename: fix.rename,
+      children: [collision]
+    });
+  }
+  const explained = new Set([...out.values()].flatMap((p) => p.children));
+  for (const collision of collisions) {
+    if (explained.has(collision) || collision.liveGuid === null || collision.projectGuid === null) continue;
+    const key = keyOf.get(collision.liveGuid);
+    const target = keyOf.get(collision.projectGuid);
+    if (key === void 0 || target === void 0 || key === target) continue;
+    const section = key.slice(0, key.indexOf(":"));
+    if (!target.startsWith(`${section}:`) || guidsIn(outgoing, section).has(collision.liveGuid)) continue;
+    const name = key.slice(section.length + 1);
+    const newName = target.slice(section.length + 1);
+    const fix = pins.keyFixUps(key, newName);
+    if (fix === void 0) continue;
+    out.set(key, {
+      kind: sectionKind(section),
+      name,
+      guid: collision.liveGuid,
+      candidates: [newName],
+      rename: fix.rename,
+      children: [collision],
+      self: true
+    });
+  }
+  return [...out.values()];
+}
+function parentRenameError(label, parents, collisions, resetRerun) {
+  const explained = new Set(parents.flatMap((p) => p.children));
+  const others = collisions.filter((c) => !explained.has(c));
+  const collisionLine = (c, indent) => `${indent}${c.kind} "${c.name}" \u2014 live guid ${c.liveGuid ?? "unknown"}, the project's ${c.projectGuid ?? "unknown"}`;
+  const lines = [];
+  for (const p of parents) {
+    lines.push(
+      `  ${p.kind} "${p.name}" (guid ${p.guid}) \u2014 xano.lock still pins it, ` + (p.candidates.length === 0 ? "and the project no longer declares it" : `and the project now adds ${p.candidates.map((c) => `"${c}"`).join(", ")}`) + (p.self === true ? "; the project sends it under a new identity:" : `; what it holds took new identities with its name:`),
+      ...p.children.map((c) => collisionLine(c, "    ")),
+      `    renamed? run: ${p.rename}`
+    );
+  }
+  if (others.length > 0) lines.push(...others.map((c) => collisionLine(c, "  ")));
+  const one = parents.length === 1;
+  return new CliError(
+    "SDK_IDENTITY_CONFLICT",
+    `${label} was not merged: ${one ? "an object" : "objects"} renamed in code that xano.lock still pins under the old name \u2014 a rename the lock was not told about. What ${one ? "it holds is" : "they hold is"} keyed by ${one ? "its" : "their"} name, so the merge would delete each live child and create the project's under the same name, which the environment refuses:
+${lines.join("\n")}
+Nothing was written \u2014 the environment's data is intact. Run the \`lock rename\`, then deploy again: the merge ` + (parents.every((p) => p.self === true) ? `then updates ${one ? "it" : "them"} in place, keeping ${one ? "its" : "their"} identity. If` : `then renames ${one ? "it" : "them"} in place and what ${one ? "it holds keeps its" : "they hold keeps their"} identity. If`) + ` it was not a rename, rebuild the environment with \`${resetRerun}\` (that replaces its rows with the seed rows), or give one of each pair another name.`,
+    {
+      exitCode: EXIT_CONFLICT,
+      details: refusalDetails("renamePending", {
+        conflicts: collisions,
+        renames: parents.map((p) => ({
+          kind: p.kind,
+          name: p.name,
+          guid: p.guid,
+          candidates: p.candidates,
+          rename: p.rename,
+          conflicts: p.children.map((c) => `${c.kind}:${c.name}`)
+        }))
+      })
+    }
+  );
+}
+function setGuidRemedy(guid, candidates, codePinned) {
+  if (codePinned === void 0 || candidates.length === 0) return void 0;
+  const pins = candidates.map((c) => codePinned.get(c)?.guid);
+  if (pins.some((g) => g === void 0 || g === guid)) return void 0;
+  return { ...candidates.length === 1 ? { table: candidates[0] } : {}, guid, pins };
+}
+function clearReplacedCommand(name, lockPath) {
+  return `xanosdk lock prune --identity-only ${shellWord(`table:${name}`)} --lock=${shellWord(displayPath(lockPath))} --yes`;
+}
+function pendingRenameLines(p, still = "the table would still be dropped", sameName = {}) {
+  const adds = p.candidates.map((c) => `"${c}"`).join(", ");
+  if (sameNameRepin(p)) {
+    const temp = `${p.table}_tmp`;
+    const { rebuild, addFlag } = sameName;
+    const deploy = addFlag === void 0 ? "deploy" : `deploy with \`${addFlag}\``;
+    return [
+      `  table "${p.table}" (guid ${p.guid}) \u2014 its def now pins another guid (${p.setGuid.pins[0]}) under the same name, and a merge cannot replace a table with another of its own name: the environment refuses it by name.`,
+      `    same table? set the def of "${p.table}" back to \`guid: "${p.guid}"\` \u2014 the merge keeps it and its rows`,
+      `    not wanted? run: ${p.prune} \u2014 then rename the def to "${temp}" and ${deploy} (the merge drops the old table with its rows and creates this one), rename it back to "${p.table}" and deploy again (the merge renames it)`,
+      ...rebuild === void 0 ? [] : [`    or rebuild the environment from the project: \`${rebuild}\` (replaces every table's rows with the seed rows)`]
+    ];
+  }
+  if (p.setGuid === void 0) {
+    return [
+      `  table "${p.table}" (guid ${p.guid}) \u2014 xano.lock still pins it, and the project now adds ${adds}:`,
+      `    renamed? run: ${p.rename ?? ""}`,
+      `    deleted? run: ${p.prune}`
+    ];
+  }
+  const one = p.setGuid.table !== void 0;
+  if (p.setGuid.pins.length === 0) {
+    return [
+      `  table "${p.table}" (guid ${p.guid}) \u2014 xano.lock keeps it as a guid a def's \`guid:\` replaced, and the project now adds ${adds}:`,
+      `    renamed? set ${one ? `the def of "${p.setGuid.table}"` : "the def of the table it became"} to \`guid: "${p.guid}"\``,
+      `    deleted? run: ${p.prune}`
+    ];
+  }
+  return [
+    `  table "${p.table}" (guid ${p.guid}) \u2014 xano.lock still pins it, and the project now adds ${adds}, ${one ? `whose def pins its own guid (${p.setGuid.pins[0]})` : "each pinning its own guid in its def"}:`,
+    `    renamed? set ${one ? `the def of "${p.setGuid.table}"` : "the def of the table it became"} to \`guid: "${p.guid}"\` \u2014 not a \`lock rename\`: the def's own guid replaces any lock entry, so ${still}`,
+    `    deleted? run: ${p.prune}`
+  ];
+}
+function sameNameRepin(p) {
+  return p.setGuid !== void 0 && p.setGuid.pins.length === 1 && p.candidates.length === 1 && p.candidates[0] === p.table;
+}
+function pendingRenameFollowUp(all, afterPrune) {
+  const pending = all.filter((p) => !sameNameRepin(p));
+  if (pending.length === 0) return "Do one, then deploy again.";
+  const inCode = pending.filter((p) => p.setGuid !== void 0).length;
+  const kept = inCode === 0 ? "after `lock rename` the merge renames the table" : inCode === pending.length ? "with the def's `guid:` set to the old guid the merge renames the table" : "after `lock rename` (or, where the def pins its own guid, the def's `guid:` set to the old one) the merge renames the table";
+  return `${inCode === 0 ? "Run" : "Do"} one, then deploy again: ${kept} and keeps its rows; after \`lock prune\` ${afterPrune}`;
+}
+function pendingRenames(operations, nameDelete, pins) {
+  if (pins === void 0) return [];
+  const created = operations.filter((o) => o.action === "create" && TABLE_KINDS.has(o.type)).map((o) => o.name);
+  if (created.length === 0) return [];
+  const replacedBy = new Map([...pins.codePinned ?? []].flatMap(([name, t]) => (t.replaces ?? []).map((g) => [g, name])));
+  const out = [];
+  for (const op of operations.filter((o) => o.action === "delete" && TABLE_KINDS.has(o.type))) {
+    const guid = nameDelete(op).guid;
+    if (guid === void 0) continue;
+    const orphan = pins.tables.get(guid);
+    const pinned = orphan ?? replacedBy.get(guid) ?? pins.replaced?.get(guid);
+    if (pinned === void 0) continue;
+    const fix = pins.fixUps(pinned, created.length === 1 ? created[0] : void 0);
+    const prune = orphan === void 0 && pins.clearReplaced !== void 0 ? pins.clearReplaced(pinned) : fix.prune;
+    const setGuid = setGuidRemedy(guid, created, pins.codePinned) ?? (orphan === void 0 ? { ...created.length === 1 ? { table: created[0] } : {}, guid, pins: [] } : void 0);
+    out.push({ table: op.name, guid, candidates: created, ...setGuid === void 0 ? { rename: fix.rename } : { setGuid }, prune });
+  }
+  return out;
+}
+function pendingRenameDetail(p) {
+  return {
+    table: p.table,
+    guid: p.guid,
+    candidates: [...p.candidates],
+    ...p.rename !== void 0 ? { rename: p.rename } : {},
+    ...p.setGuid !== void 0 ? { setGuid: { ...p.setGuid, pins: [...p.setGuid.pins] } } : {},
+    ...sameNameRepin(p) ? { sameName: true } : {},
+    prune: p.prune
+  };
+}
+function pendingRenameError(label, pending, resetRerun) {
+  const lines = pending.flatMap((p) => pendingRenameLines(p, void 0, { rebuild: resetRerun }));
+  const one = pending.length === 1;
+  const lead = pending.every(sameNameRepin) ? `${label} was not merged: ${one ? "a table's def pins" : "table defs pin"} a new guid under the name the table already has, and a merge matches on guid, so it would delete the old table with every row.` : `${label} was not merged: it would DROP ${one ? "a table" : "tables"} xano.lock still pins, with every row, while the project adds a new table \u2014 a rename the lock was not told about. A merge matches on guid, so it would delete the old table and create an empty one.`;
+  return new CliError(
+    "SDK_IDENTITY_CONFLICT",
+    `${lead}
+${lines.join("\n")}
+Nothing was written \u2014 the environment's data is intact. ` + pendingRenameFollowUp(pending, `it drops ${one ? "it" : "them"} as a deletion.`),
+    {
+      exitCode: EXIT_CONFLICT,
+      details: refusalDetails("renamePending", { renames: pending.map(pendingRenameDetail) })
+    }
+  );
+}
+function liveCanonicalRow(live, kind, guid, name) {
+  const rows = payloadRows(live, planTypeSection(kind));
+  if (guid !== void 0) {
+    const byGuid = rows.find((r) => r.guid === guid);
+    if (byGuid !== void 0) return byGuid;
+  }
+  return rows.find((r) => r.name === name && (typeof r.guid !== "string" || r.guid === ""));
+}
+function slugOf(row) {
+  return typeof row?.canonical === "string" && row.canonical !== "" ? row.canonical : void 0;
+}
+function canonicalChanges(canonicals, live) {
+  const out = [];
+  for (const c of canonicals) {
+    const row = liveCanonicalRow(live, c.kind, c.guid, c.name);
+    const from = slugOf(row);
+    if (row === void 0 || from === void 0 || c.served === void 0 || c.served === from) continue;
+    out.push({ kind: sectionKind(planTypeSection(c.kind), row), name: c.name, from, to: c.served });
+  }
+  return out;
+}
+function canonicalConflicts(conflicts, canonicals, operations, live, pins, workspaceId) {
+  const out = [];
+  for (const conflict of conflicts.filter((c) => c.kind === "canonical")) {
+    const wanted = canonicals.find((c) => c.guid !== void 0 && c.guid === conflict.archiveGuid) ?? canonicals.find((c) => c.outcome === "conflict" && c.requested === conflict.identity);
+    const kind = wanted === void 0 ? "object" : sectionKind(planTypeSection(wanted.kind));
+    const name = wanted?.name ?? conflict.archiveGuid ?? conflict.identity;
+    const section = wanted === void 0 ? void 0 : planTypeSection(wanted.kind);
+    const holder = section === void 0 ? void 0 : payloadRows(live, section).find(
+      (r) => conflict.owner.guid !== void 0 && r.guid === conflict.owner.guid || slugOf(r) === conflict.identity && r.name !== name
+    );
+    const deleted = holder !== void 0 && operations.some((o) => o.action === "delete" && planTypeSection(o.type) === section && o.name === holder.name);
+    const entry = {
+      kind,
+      name,
+      canonical: conflict.identity,
+      ownerGuid: conflict.owner.guid ?? null
+    };
+    if (deleted && holder !== void 0 && typeof holder.name === "string") {
+      entry.heldBy = {
+        kind: sectionKind(section, holder),
+        name: holder.name,
+        guid: typeof holder.guid === "string" ? holder.guid : conflict.owner.guid ?? null
+      };
+      const fix = pins?.keyFixUps?.(`${section}:${holder.name}`, name);
+      if (fix !== void 0) entry.rename = fix.rename;
+    } else if (conflict.owner.workspaceId !== workspaceId) {
+      entry.elsewhere = conflict.owner.workspaceId;
+    } else {
+      const kept = canonicals.find(
+        (c) => c.guid !== void 0 && c.guid === conflict.owner.guid && c.guid !== conflict.archiveGuid
+      );
+      if (kept?.guid !== void 0 && kept.requested !== void 0 && kept.requested !== conflict.identity) {
+        const row = liveCanonicalRow(live, kept.kind, kept.guid, kept.name);
+        entry.sibling = { kind: sectionKind(planTypeSection(kept.kind), row), name: kept.name, guid: kept.guid, to: kept.requested };
+      }
+    }
+    out.push(entry);
+  }
+  return out;
+}
+function siblingSlugSteps(conflicts, canonicals, live) {
+  if (conflicts.length === 0 || conflicts.some((c) => c.sibling === void 0)) return void 0;
+  const held = /* @__PURE__ */ new Map();
+  for (const section of /* @__PURE__ */ new Set(["app", ...canonicals.map((c) => planTypeSection(c.kind))])) {
+    for (const row of payloadRows(live, section)) {
+      const slug = slugOf(row);
+      if (slug !== void 0 && typeof row.guid === "string") held.set(slug, row.guid);
+    }
+  }
+  const moves = [];
+  for (const c of canonicals) {
+    if (c.guid === void 0 || c.requested === void 0) continue;
+    const row = liveCanonicalRow(live, c.kind, c.guid, c.name);
+    const from = slugOf(row);
+    if (from === c.requested) continue;
+    moves.push({ kind: sectionKind(planTypeSection(c.kind), row), name: c.name, guid: c.guid, from, to: c.requested });
+  }
+  return slugMoveSteps(moves, held);
+}
+function canonicalConflictError(label, conflicts, resetRerun, steps) {
+  const lines = [];
+  for (const c of conflicts) {
+    if (c.sibling !== void 0) {
+      lines.push(
+        `  ${c.kind} "${c.name}" pins canonical "${c.canonical}", which ${c.sibling.kind} "${c.sibling.name}" of this environment serves now and this deploy moves to "${c.sibling.to}".`
+      );
+    } else if (c.heldBy !== void 0) {
+      lines.push(
+        `  ${c.kind} "${c.name}" pins canonical "${c.canonical}", which ${c.heldBy.kind} "${c.heldBy.name}" serves \u2014 the merge would create "${c.name}" beside it and delete "${c.heldBy.name}" after, so the slug is not free when it is asked for.`
+      );
+      if (c.rename !== void 0) lines.push(`    renamed? run: ${c.rename}`);
+    } else {
+      lines.push(
+        `  ${c.kind} "${c.name}" pins canonical "${c.canonical}", which ` + (c.elsewhere === void 0 ? "another object in this environment serves" : `an object in workspace ${c.elsewhere} on the same backend serves`) + `${c.ownerGuid === null ? "" : ` (guid ${c.ownerGuid})`}.`
+      );
+    }
+  }
+  const renames = conflicts.some((c) => c.rename !== void 0);
+  return new CliError(
+    "SDK_IDENTITY_CONFLICT",
+    `${label} was not merged: ${conflicts.length === 1 ? "a public URL slug" : "public URL slugs"} the project pins cannot be served as declared:
+${lines.join("\n")}
+Nothing was written \u2014 the environment's data is intact.
+` + (steps !== void 0 ? `One deploy cannot hand a slug from one object to another: each pinned slug is checked against what the environment serves when the deploy starts. Move them in ${steps.list.length} deploys, each keeping the data:
+` + renderSlugSteps(steps.list, steps.rerun).join("\n") : renames ? `If it is a rename, run the \`lock rename\` and deploy again: the merge then renames the object in place and it keeps its URL. If not, pick another \`canonical\`, or rebuild the environment with \`${resetRerun}\` (that replaces its rows with the seed rows).` : `Pick another \`canonical\`, or \u2014 when the holder is this environment's own object \u2014 rebuild the environment with \`${resetRerun}\` (that replaces its rows with the seed rows).`),
+    {
+      exitCode: EXIT_CONFLICT,
+      details: {
+        ...refusalDetails("identityConflict", {
+          conflicts: conflicts.map((c) => {
+            const holder = c.sibling ?? c.heldBy;
+            return {
+              kind: c.kind,
+              name: c.name,
+              canonical: c.canonical,
+              liveGuid: holder?.guid ?? c.ownerGuid,
+              ...holder === void 0 ? {} : { heldBy: `${holder.kind}:${holder.name}` },
+              ...c.rename === void 0 ? {} : { rename: c.rename }
+            };
+          })
+        }),
+        ...steps === void 0 ? {} : {
+          steps: steps.list.map((step) => ({
+            set: step.map((o) => ({ object: `${o.kind}:${o.name}`, canonical: o.slug, why: o.why })),
+            run: steps.rerun
+          }))
+        }
+      }
+    }
+  );
+}
+function canonicalNotServedError(label, missed, resetRerun) {
+  const lines = missed.map(
+    (c) => `  ${sectionKind(planTypeSection(c.kind))} "${c.name}" \u2014 pinned "${c.requested ?? ""}", serves ${c.served === void 0 ? "a slug the environment chose" : `"${c.served}"`} (${c.outcome})`
+  );
+  return new CliError(
+    "SDK_ERROR",
+    `${label} merged, but ${missed.length === 1 ? "a pinned public URL is" : "pinned public URLs are"} not served as declared \u2014 every endpoint under the declared slug answers 404:
+${lines.join("\n")}
+Rebuild the environment from the project with \`${resetRerun}\` (that replaces its rows with the seed rows).`,
+    {
+      details: {
+        landed: true,
+        canonicals: missed.map((c) => ({
+          kind: sectionKind(planTypeSection(c.kind)),
+          name: c.name,
+          requested: c.requested ?? null,
+          served: c.served ?? null,
+          outcome: c.outcome
+        }))
+      }
+    }
+  );
+}
+var KeepDataDeclined = class extends Error {
+  declined = true;
+  constructor(label, verb = "merged") {
+    super(`Nothing was ${verb} \u2014 ${label} and its data are as they were.`);
+    this.name = "KeepDataDeclined";
+  }
+};
+async function gateForeignReplace(req) {
+  const answered = req.allowForeignDeletes === true;
+  let live;
+  try {
+    live = await withSpinner(
+      "Reading the environment to check what the replace clears\u2026",
+      () => exportWorkspaceBundle(req.auth, { base: req.baseUrl, workspaceId: req.workspaceId, label: `${req.label} live read` })
+    );
+  } catch (err) {
+    if (answered) {
+      warn(
+        `Could not read ${req.label} to list what the replace clears that this project did not land; \`--yes\` deletes it unlisted.`,
+        "plan.object-remove-unlisted",
+        [err instanceof Error ? err.message : String(err)]
+      );
+      return;
+    }
+    throw await unansweredReadError(err, req);
+  }
+  const foreign = foreignObjects(live, JSON.parse(req.bundle), req.landedGuids);
+  if (foreign.length === 0) return;
+  const one = foreign.length === 1;
+  const what = `${plural(foreign.length, "object", "objects")} ${NOT_LANDED}`;
+  warn(
+    answered ? `The replace DELETES ${what} \u2014 a replace clears everything ${req.label} holds:` : `The replace would DELETE ${what} \u2014 a replace clears everything ${req.label} holds:`,
+    "plan.object-remove",
+    foreign.map((o) => o.label)
+  );
+  if (answered) return;
+  if (req.confirm !== void 0) {
+    if (await req.confirm(`Delete ${what} from ${req.label}?`)) return;
+    throw new KeepDataDeclined(req.label, "deployed");
+  }
+  const rerun = req.rerun === void 0 ? void 0 : withFlag(req.rerun.command, "--yes", "-y");
+  throw new CliError(
+    "SDK_PRUNE_OUT_OF_SCOPE",
+    `${req.label} was not replaced: the replace would delete ${what} (${foreign.map((o) => o.label).join(", ")}) \u2014 this project's landing record does not name ${one ? "it" : "them"}. Nothing was written.
+To delete ${one ? "it" : "them"}, ${rerun === void 0 ? "pass `--yes`" : `run \`${rerun}\``}${req.rerun?.note ?? ""}; to keep ${one ? "it" : "them"}, declare ${one ? "it" : "them"} in this project.`,
+    { exitCode: EXIT_CONFLICT, details: refusalDetails("pruneOutOfScope", { outOfScope: foreign }) }
+  );
+}
+function foreignObjects(live, outgoing, landedGuids) {
+  const sent = /* @__PURE__ */ new Set();
+  for (const key of LOCK_PAYLOAD_KEYS) {
+    for (const row of payloadRows(outgoing, key)) if (typeof row.guid === "string") sent.add(row.guid);
+  }
+  const label = rowLabeler(payloadOf(live));
+  const out = [];
+  for (const key of LOCK_PAYLOAD_KEYS) {
+    for (const row of payloadRows(live, key)) {
+      if (typeof row.guid !== "string" || row.guid === "" || sent.has(row.guid) || landedGuids.has(row.guid)) continue;
+      out.push({ type: sectionKind(key, row), name: typeof row.name === "string" ? row.name : "", label: label(key, row) });
+    }
+  }
+  return out;
+}
+async function gateForeignDeletes(req, notLanded) {
+  if (notLanded.length === 0 || req.allowForeignDeletes === true) return;
+  const one = notLanded.length === 1;
+  const what = `${plural(notLanded.length, "object", "objects")} ${NOT_LANDED} (${notLanded.map((o) => o.label).join(", ")})`;
+  if (req.confirm !== void 0) {
+    if (await req.confirm(`Delete ${what} from ${req.label}?`)) return;
+    throw new KeepDataDeclined(req.label);
+  }
+  const rerun = req.rerun === void 0 ? void 0 : withFlag(req.rerun.command, "--yes", "-y");
+  throw new CliError(
+    "SDK_PRUNE_OUT_OF_SCOPE",
+    `${req.label} was not merged: the merge would delete ${what} \u2014 this project's landing record does not name ${one ? "it" : "them"}. Nothing was written.
+To delete ${one ? "it" : "them"}, ${rerun === void 0 ? "pass `--yes`" : `run \`${rerun}\``}${req.rerun?.note ?? ""}; to keep ${one ? "it" : "them"}, declare ${one ? "it" : "them"} in this project.`,
+    { exitCode: EXIT_CONFLICT, details: refusalDetails("pruneOutOfScope", { outOfScope: [...notLanded] }) }
+  );
+}
+function withFlag(command, flag, alias) {
+  const words = command.split(" ");
+  if (words.some((w) => w === flag || w === alias)) return command;
+  const mode = flag === "--reset" ? words.indexOf("--keep-data") : -1;
+  if (mode === -1) return `${command} ${flag}`;
+  words.splice(mode + 1, 0, flag);
+  return words.join(" ");
+}
+function plural(n, one, many) {
+  return `${n} ${n === 1 ? one : many}`;
+}
+function seededTableNames(bundle, content) {
+  const seeded = new Set(seedRowsByTableGuid(content).keys());
+  const out = /* @__PURE__ */ new Set();
+  const dbo = bundle?.payload?.dbo;
+  if (!Array.isArray(dbo)) return out;
+  for (const table of dbo) {
+    const { guid, name } = table ?? {};
+    if (typeof guid === "string" && typeof name === "string" && seeded.has(guid)) out.add(name);
+  }
+  return out;
+}
+function renamedTables(live, outgoing) {
+  return renamedRows(live, outgoing, "dbo");
+}
+function renamedRows(live, outgoing, section) {
+  const liveNames = /* @__PURE__ */ new Map();
+  for (const row of payloadRows(live, section)) {
+    if (typeof row.guid === "string" && typeof row.name === "string") liveNames.set(row.guid, row.name);
+  }
+  const out = [];
+  for (const row of payloadRows(outgoing, section)) {
+    if (typeof row.guid !== "string" || typeof row.name !== "string") continue;
+    const from = liveNames.get(row.guid);
+    if (from !== void 0 && from !== row.name) out.push({ from, to: row.name });
+  }
+  return out;
+}
+function payloadRows(bundle, key) {
+  const rows = bundle?.payload?.[key];
+  return Array.isArray(rows) ? rows.filter((r) => r !== null && typeof r === "object") : [];
+}
+function planLabel(op) {
+  return `${sectionKind(planTypeSection(op.type))}:${op.name}`;
+}
+function deleteNamer(live, outgoing) {
+  const label = rowLabeler(payloadOf(live));
+  const claimed = /* @__PURE__ */ new Set();
+  return (op) => {
+    const section = planTypeSection(op.type);
+    const kept = new Set(
+      payloadRows(outgoing, section).map((r) => r.guid).filter((g) => typeof g === "string")
+    );
+    const row = payloadRows(live, section).find(
+      (r) => !claimed.has(r) && r.name === op.name && (typeof r.guid !== "string" || !kept.has(r.guid))
+    );
+    if (row === void 0) return { type: sectionKind(section), label: planLabel(op) };
+    claimed.add(row);
+    return {
+      type: sectionKind(section, row),
+      label: label(section, row),
+      ...typeof row.guid === "string" ? { guid: row.guid } : {}
+    };
+  };
+}
+var NOT_LANDED = "not in this project (landed by another source)";
+var MIRRORS = "keep-data mirrors this project's source";
+function classifyDeletes(operations, nameDelete, landedGuids) {
+  const deletes = operations.filter((o) => o.action === "delete");
+  const landed = (guid) => landedGuids === void 0 || guid !== void 0 && landedGuids.has(guid);
+  const tables = deletes.filter((o) => TABLE_KINDS.has(o.type)).map((o) => ({ name: o.name, guid: nameDelete(o).guid })).map((t) => ({ name: t.name, ours: landed(t.guid), ...t.guid === void 0 ? {} : { guid: t.guid } }));
+  const others = deletes.filter((o) => !TABLE_KINDS.has(o.type)).map((o) => ({ op: o, ...nameDelete(o) })).map((d) => ({ label: d.label, ours: landed(d.guid), type: d.type, name: d.op.name, ...d.guid === void 0 ? {} : { guid: d.guid } }));
+  const notLanded = [
+    ...tables.filter((t) => !t.ours).map((t) => ({ type: "table", name: t.name, label: `table:${t.name}` })),
+    ...others.filter((o) => !o.ours).map((o) => ({ type: o.type, name: o.name, label: o.label }))
+  ];
+  return { tables, others, notLanded };
+}
+function discloseMerge(operations, diff, seeded, deletes, renamed, envSetTo = "", resetRerun = "xanosdk deploy --keep-data --reset", asking = false, slugMoves = [], channelRenames = [], addedColumns = []) {
+  const tableDeletes = deletes.tables;
+  const droppedTables = tableDeletes.map((t) => t.name);
+  const will = asking ? "would" : "will";
+  const effects = tableEffectsOf(diff, { createdTables: [], addedColumns: [...addedColumns], addedDefaults: {}, renamedTables: [] }, { mode: "merge" });
+  const unseededTables = operations.filter((o) => o.action === "create" && TABLE_KINDS.has(o.type) && seeded.has(o.name)).map((o) => o.name);
+  const keptEnv = diff.unchangedEnv.map((e) => e.name);
+  for (const { from, to } of renamed) detail(`The merge ${will} rename table ${from} \u2192 ${to} (rows kept).`);
+  if (slugMoves.length > 0) {
+    warn(
+      `The merge ${will} move ${plural(slugMoves.length, "public URL", "public URLs")} \u2014 the project pins another \`canonical\`, and every endpoint under the old slug stops answering:`,
+      "plan.canonical-change",
+      slugMoves.map((m) => `${m.kind} "${m.name}": ${m.from} \u2192 ${m.to}`)
+    );
+  }
+  const detached = [
+    ...slugMoves.filter((m) => m.kind === "realtimeServer").map((m) => `${m.kind} "${m.name}": ${m.from} \u2192 ${m.to}`),
+    ...channelRenames.map((c) => `realtimeChannel "${c.from}" \u2192 "${c.to}"`)
+  ];
+  if (detached.length > 0) {
+    warn(
+      `The merge ${will} detach realtime history: sockets on the old ${channelRenames.length === 0 ? "slug" : slugMoves.some((m) => m.kind === "realtimeServer") ? "slug or channel" : "channel"} stop connecting, and the \`conversation\` transcript and the \`at_least_once\` replay stay under the old name \u2014 a client joins with no history. Moving the name back restores them:`,
+      "plan.realtime-history-detached",
+      detached
+    );
+  }
+  for (const ours of [true, false]) {
+    const tables = tableDeletes.filter((t) => t.ours === ours).map((t) => t.name);
+    if (tables.length === 0) continue;
+    const rows = `with every row in ${tables.length === 1 ? "it" : "them"}`;
+    warn(
+      ours ? `The merge ${will} DROP ${plural(tables.length, "table", "tables")} the project no longer declares, ${rows}:` : `The merge ${will} DROP ${plural(tables.length, "table", "tables")} ${NOT_LANDED}, ${rows} \u2014 ${MIRRORS}:`,
+      "plan.table-drop",
+      tables
+    );
+  }
+  discloseTableEffects(effects, {
+    subject: "the merge",
+    stages: "deploys",
+    will,
+    remedies: {
+      "plan.column-retype": "`--reset` re-seeds instead.",
+      "plan.enum-values-removed": "`--reset` re-seeds instead.",
+      "plan.not-null-kept": `A replace recreates the table, which relaxes it (and replaces its rows with the seed rows): \`${resetRerun}\`, or a deploy without \`--keep-data\`.`,
+      "plan.not-null-tightened": `Give ${effects.notNullTightened.length === 1 ? "it" : "them"} a value in each row, or keep \`nullable: true\`; a replace re-seeds instead (\`${resetRerun}\`).`
+    }
+  });
+  const removed = deletes.others.map((d) => d.label);
+  const removedOurs = deletes.others.filter((d) => d.ours).map((d) => d.label);
+  const removedOthers = deletes.others.filter((d) => !d.ours).map((d) => d.label);
+  if (removedOurs.length > 0) {
+    warn(
+      `The merge ${will} also remove, as the project no longer declares ${removedOurs.length === 1 ? "it" : "them"}:`,
+      "plan.object-remove",
+      removedOurs
+    );
+  }
+  if (removedOthers.length > 0) {
+    warn(`The merge ${will} also remove, ${NOT_LANDED} \u2014 ${MIRRORS}:`, "plan.object-remove", removedOthers);
+  }
+  const notLanded = deletes.notLanded.map((o) => o.label);
+  if (unseededTables.length > 0) {
+    warn(
+      `${plural(unseededTables.length, "new table declares", "new tables declare")} seed rows a merge does not write \u2014 ${unseededTables.join(", ")}. \`--reset\` seeds ${unseededTables.length === 1 ? "it" : "them"}, and replaces every other table's rows with its seeds too.`,
+      "plan.seed-not-written"
+    );
+  }
+  const differing = diff.unchangedEnv.filter((e) => !e.empty).map((e) => e.name);
+  const unfilled = diff.unchangedEnv.filter((e) => e.empty).map((e) => e.name);
+  if (differing.length > 0) {
+    const one = differing.length === 1;
+    warn(
+      `${plural(differing.length, "environment variable keeps its", "environment variables keep their")} live value \u2014 the project's differs, and a merge does not update values: ${differing.join(", ")}. To apply the project's, run:`,
+      "plan.env-kept",
+      [
+        ...differing.map((name) => envSetFromStdin(name, envSetTo)),
+        `or deploy with \`--reset\`, which applies ${one ? "it" : "them"} and also replaces the rows with the seed rows.`
+      ]
+    );
+  }
+  if (unfilled.length > 0) {
+    const one = unfilled.length === 1;
+    warn(
+      `${plural(unfilled.length, "environment variable keeps its", "environment variables keep their")} live value \u2014 the project's is empty: ${unfilled.join(", ")}. A merge never updates a value; to change ${one ? "it" : "them"}, run:`,
+      "plan.env-kept",
+      [
+        ...unfilled.map((name) => envSetFromStdin(name, envSetTo)),
+        `or fill ${one ? "it" : "them"} in the backend's \`.env\` and deploy with \`--reset\` (which also replaces the rows with the seed rows).`
+      ]
+    );
+  }
+  const unappliedDocumentation = [...diff.unappliedDocumentation];
+  if (unappliedDocumentation.length > 0) {
+    const what = unappliedDocumentation.includes("require_token") ? unappliedDocumentation.includes("token") ? "documentation gate and token" : "documentation gate" : "documentation token";
+    warn(
+      `The workspace ${what} ${will} NOT be updated \u2014 a merge does not write the workspace's \`documentation\` block. \`--reset\` writes it.`,
+      "plan.doc-not-updated"
+    );
+  }
+  return {
+    droppedTables,
+    ...tableEffectFields(effects),
+    removed,
+    removedGuids: [...deletes.tables, ...deletes.others].filter((d) => d.ours && d.guid !== void 0).map((d) => d.guid),
+    notLanded,
+    unseededTables,
+    renamedTables: renamed,
+    keptEnv,
+    unappliedDocumentation,
+    canonicalChanges: [...slugMoves],
+    pairedColumns: droppedAndAdded(effects)
+  };
+}
+async function mergeKeepingData(req) {
+  const target = {
+    baseUrl: req.baseUrl,
+    workspaceId: req.workspaceId,
+    label: req.label,
+    ...req.stateCheck === void 0 ? {} : { stateCheck: req.stateCheck },
+    ...req.fetchFn === void 0 ? {} : { fetchFn: req.fetchFn }
+  };
+  let capable;
+  try {
+    capable = await detectXanoSdkImportRoute(req.auth, target);
+  } catch (err) {
+    throw await unreachableProbeError(err, req);
+  }
+  if (!capable) throw cannotMergeError(req.label);
+  const outgoing = JSON.parse(req.bundle);
+  let live;
+  try {
+    live = await withSpinner(
+      "Reading the environment to preview the merge\u2026",
+      () => exportWorkspaceBundle(req.auth, { base: req.baseUrl, workspaceId: req.workspaceId, label: `${req.label} live read` })
+    );
+  } catch (err) {
+    throw await unansweredReadError(err, req);
+  }
+  const triggers = req.kind === "local-engine" ? [] : liveTableTriggers(live);
+  if (triggers.length > 0) {
+    const reset = req.rerun === void 0 ? "xanosdk deploy --keep-data --reset" : withFlag(req.rerun.command, "--reset");
+    throw tableTriggerMergeError(req.label, triggers, { command: reset, note: req.rerun?.note ?? "" });
+  }
+  const diff = diffAgainstLive(outgoing, live, { mode: "merge", ...req.storedColumns === void 0 ? {} : { stored: req.storedColumns } });
+  const resetRerun = req.rerun === void 0 ? "xanosdk deploy --keep-data --reset" : withFlag(req.rerun.command, "--reset");
+  if (req.kind !== "local-engine") {
+    await assertStorageModesKept(diff.storageChanges, tableRowCounter(req.auth, { workspaceId: req.workspaceId, base: req.baseUrl }), {
+      target: req.label,
+      subject: "the merge",
+      remedy: `rebuild the environment with \`${resetRerun}\` ` + (req.content.length > 0 ? "(that replaces its rows with the seed rows)." : "(that leaves its tables EMPTY \u2014 this deploy carries no seed rows to put back).") + (req.rerun?.note ?? "")
+    });
+  }
+  const archive = encodeWorkspaceArchive(req.bundle, req.files ?? []);
+  const pinned = req.pinned ?? [];
+  const request = { ...target, archive, mode: "merge", prune: true, pinned };
+  let plan;
+  try {
+    plan = await withSpinner("Previewing the merge\u2026", () => xanosdkImport(req.auth, { ...request, dryRun: true }));
+  } catch (err) {
+    if (err instanceof XanoSdkImportRefusal) throw refusedError(req.label, err, diff.indexChanges, req.rerun);
+    const unanswered = await unansweredReadError(err, req);
+    if (unanswered !== err) throw unanswered;
+    if (!(err instanceof Error && /writes nothing|untouched|intact/.test(err.message))) {
+      detail("The preview writes nothing, so the environment's data is untouched.");
+    }
+    throw err;
+  }
+  const operations = plan.plan.operations;
+  const renames = pendingRenames(operations, deleteNamer(live, outgoing), req.lockPins);
+  if (renames.length > 0) throw pendingRenameError(req.label, renames, resetRerun);
+  const collisions = nameCollisions(operations, live, outgoing);
+  if (collisions.length > 0) {
+    const parents = parentRenames(collisions, live, outgoing, req.lockPins);
+    throw parents.length > 0 ? parentRenameError(req.label, parents, collisions, resetRerun) : collisionError(req.label, collisions, resetRerun);
+  }
+  const slugConflicts = canonicalConflicts(plan.conflicts, plan.canonicals, operations, live, req.lockPins, req.workspaceId);
+  if (slugConflicts.length > 0) {
+    const steps = siblingSlugSteps(slugConflicts, plan.canonicals, live);
+    const again = req.rerun?.command ?? "xanosdk deploy --keep-data";
+    throw canonicalConflictError(req.label, slugConflicts, resetRerun, steps === void 0 ? void 0 : { list: steps, rerun: again });
+  }
+  const deletes = classifyDeletes(operations, deleteNamer(live, outgoing), req.landedGuids);
+  const foreign = deletes.notLanded.length > 0 && req.allowForeignDeletes !== true;
+  if (foreign && req.confirm === void 0) await gateForeignDeletes(req, deletes.notLanded);
+  const result = discloseMerge(
+    operations,
+    diff,
+    seededTableNames(outgoing, req.content),
+    deletes,
+    renamedTables(live, outgoing),
+    req.envSetTo,
+    req.rerun === void 0 ? void 0 : withFlag(req.rerun.command, "--reset"),
+    foreign,
+    canonicalChanges(plan.canonicals, live),
+    renamedRows(live, outgoing, "channel"),
+    tableAdditions(outgoing, live).addedColumns
+  );
+  await gateForeignDeletes(req, deletes.notLanded);
+  const relabel = await req.beforeWrite?.() ?? {};
+  const label = relabel.label ?? req.label;
+  const stateCheck = relabel.stateCheck ?? req.stateCheck;
+  let applied;
+  try {
+    applied = await withSpinner(
+      "Merging the workspace, keeping its data\u2026",
+      () => xanosdkImport(req.auth, { ...request, label, ...stateCheck === void 0 ? {} : { stateCheck }, dryRun: false })
+    );
+  } catch (err) {
+    if (err instanceof XanoSdkImportRefusal) throw refusedError(label, err, diff.indexChanges, req.rerun);
+    throw err;
+  }
+  const missed = applied.canonicals.filter(
+    (c) => c.guid !== void 0 && pinned.includes(c.guid) && c.outcome !== "honored"
+  );
+  if (missed.length > 0) throw canonicalNotServedError(label, missed, resetRerun);
+  return {
+    ...result,
+    canonicalChanges: canonicalChanges(applied.canonicals, live),
+    storedColumns: storedColumnsAfter(outgoing, live, req.storedColumns ?? /* @__PURE__ */ new Map(), "merge")
+  };
+}
+function envSetFromStdin(name, to) {
+  return `printf %s "$VALUE" | xanosdk env set ${shellQuote(name)}${to}`;
+}
+export {
+  KeepDataDeclined,
+  cannotMergeError,
+  clearReplacedCommand,
+  gateForeignReplace,
+  importInProgressError,
+  liveTableTriggers,
+  mergeKeepingData,
+  pendingRenameDetail,
+  pendingRenameFollowUp,
+  pendingRenameLines,
+  sameNameRepin,
+  setGuidRemedy,
+  tableTriggerMergeError,
+  unansweredReadError,
+  unreachableProbeError
+};
+//# sourceMappingURL=keep-data-merge-7MPLVAVI.js.map