@xano/sdk 1.0.0

package/dist/lock-commands-2QG25HL7.js

@@ -0,0 +1,963 @@
+import {
+  checkStandInTokens,
+  loadDefault,
+  renameCandidatesFor
+} from "./chunk-ETO6LGLD.js";
+import "./chunk-ZIY7RNUT.js";
+import "./chunk-DAD3ONIS.js";
+import "./chunk-HHN734BU.js";
+import "./chunk-LPECSJ2J.js";
+import "./chunk-6NNTNXN7.js";
+import "./chunk-QCNYHBL7.js";
+import "./chunk-2ZUEE4EK.js";
+import "./chunk-AN6BL47T.js";
+import "./chunk-ET4Y4XCB.js";
+import "./chunk-SWBF2LTK.js";
+import "./chunk-UZ6QQWJT.js";
+import "./chunk-A3UDOZB6.js";
+import "./chunk-2MNLRIOX.js";
+import "./chunk-3M4LFYNQ.js";
+import "./chunk-AM4FKL4J.js";
+import "./chunk-Q325JKYB.js";
+import "./chunk-STSFNCY4.js";
+import "./chunk-I4F5TCJH.js";
+import {
+  allLandings
+} from "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import "./chunk-7G3CTU7I.js";
+import "./chunk-6PBR37LN.js";
+import "./chunk-T5KELPAR.js";
+import "./chunk-622HUCZT.js";
+import {
+  contextFlags
+} from "./chunk-NAQDMEHV.js";
+import {
+  backendDirIn
+} from "./chunk-5A2PLKZB.js";
+import {
+  XANO_DIR
+} from "./chunk-AHJWCYQO.js";
+import "./chunk-DX4QR4B2.js";
+import "./chunk-6QXLMMT3.js";
+import "./chunk-ZFDZKNGG.js";
+import {
+  shellWord
+} from "./chunk-FWD7AL6N.js";
+import "./chunk-2GNFDZA2.js";
+import "./chunk-JTUKLCXS.js";
+import "./chunk-4KHEMC32.js";
+import "./chunk-U64O2MXY.js";
+import "./chunk-ROY4YAEQ.js";
+import {
+  readLockFile,
+  writeLockFile
+} from "./chunk-P2HAGF6H.js";
+import "./chunk-TLQE7ZN3.js";
+import "./chunk-WRBKLYSJ.js";
+import "./chunk-3LDULPRE.js";
+import "./chunk-XW6KISBB.js";
+import "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-OPHB5ORL.js";
+import "./chunk-UCQ2VUTG.js";
+import "./chunk-DGWHAVRG.js";
+import "./chunk-JGE7CAWB.js";
+import {
+  CliError,
+  LocalFileNotFoundError,
+  UsageError,
+  detail,
+  displayPath,
+  info,
+  isMachineOutput,
+  missingArgument,
+  pastePath,
+  relForwardSlash,
+  safeText,
+  unknownSubcommand,
+  warn,
+  writeJson
+} from "./chunk-PTHVMXZI.js";
+import "./chunk-MXHSQOC4.js";
+import "./chunk-6IUMKYWI.js";
+import "./chunk-2CMJZDCL.js";
+import {
+  Xano
+} from "./chunk-CTMO46PK.js";
+import "./chunk-ZDPP6RKB.js";
+import "./chunk-K5BBGTYZ.js";
+import "./chunk-LQCMKAJ7.js";
+import "./chunk-YGZHHAAB.js";
+import "./chunk-XVBGLISP.js";
+import "./chunk-6HO3NCSJ.js";
+import "./chunk-5V5XU32D.js";
+import "./chunk-GSGDWJB5.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 {
+  suggest
+} from "./chunk-UTI5G6OJ.js";
+import {
+  setDiagnosticSink
+} from "./chunk-2EZ3ZJZZ.js";
+import {
+  LOCK_PAYLOAD_KEYS,
+  LockEntryNotFoundError,
+  LockImportConflictError,
+  LockRenameConflictError,
+  NotABundleError,
+  UnknownLockKindError,
+  WORKSPACE_KEY,
+  acceptedLockKinds,
+  adoptFromBundle,
+  checkRenameTarget,
+  createLockContext,
+  displayLockKey,
+  emptyLock,
+  normalizeLockKey,
+  renameLockEntry,
+  resolvePayloadKey,
+  sdkKindName2 as sdkKindName,
+  toolsetKindsFromLock,
+  toolsetKindsFromPayload,
+  withObjects
+} from "./chunk-6MR5TI5V.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-XNCP4KYO.js";
+import "./chunk-AKNCFVKZ.js";
+import "./chunk-YU4HSQW7.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-G554NZNI.js";
+import "./chunk-N5GKCWE5.js";
+import "./chunk-OXA6PSZT.js";
+import "./chunk-VAX3UZOY.js";
+import {
+  rawDeriveGuid
+} from "./chunk-NZOWWHU5.js";
+import {
+  resetLockOverrides,
+  seedLockOverrides
+} from "./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/lock-commands.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { basename, dirname, join, resolve } from "path";
+import { execFileSync } from "child_process";
+function readExistingLock(lockPath, subcommand, tolerateDuplicates = false) {
+  if (!existsSync(lockPath)) {
+    throw new UsageError(
+      `lock ${subcommand}: no lock file at ${displayPath(lockPath)}. The first \`xanosdk export\` writes xano.lock beside the entry file; point at an existing one with \`--lock=<path>\` or \`--entry=<entry-file>\`.`,
+      { hintFor: { command: "lock", subcommand } }
+    );
+  }
+  return readLockFile(lockPath, { tolerateDuplicates });
+}
+function warnRemainingDuplicates(lockPath) {
+  try {
+    readLockFile(lockPath);
+  } catch (err) {
+    warn(err instanceof Error ? err.message : String(err), "lock.duplicate-identity");
+  }
+}
+function payloadKeyFor(kind, subcommand) {
+  try {
+    return resolvePayloadKey(kind);
+  } catch (err) {
+    if (err instanceof UnknownLockKindError) {
+      const meant = suggest(kind, acceptedLockKinds());
+      throw new UsageError(meant === void 0 ? err.message : `${err.message} Did you mean "${safeText(meant)}"?`, {
+        hintFor: { command: "lock", subcommand }
+      });
+    }
+    throw err;
+  }
+}
+function humanOut(args) {
+  return isMachineOutput(args) ? process.stderr : process.stdout;
+}
+function entryDoc(entry) {
+  return {
+    ...entry.guid !== void 0 ? { guid: entry.guid } : {},
+    ...entry.canonical !== void 0 ? { canonical: entry.canonical } : {}
+  };
+}
+async function runLockCommand(args) {
+  const [sub] = args.positionals;
+  switch (sub) {
+    case "rename":
+      return lockRename(args);
+    case "prune":
+      return lockPrune(args);
+    case "import":
+      return await lockAdopt(args);
+    default:
+      throw unknownSubcommand("lock", sub);
+  }
+}
+function describeEntry(entry) {
+  const parts = [];
+  if (entry.guid !== void 0) parts.push(`guid ${entry.guid}`);
+  if (entry.canonical !== void 0) parts.push(`canonical ${entry.canonical}`);
+  return parts.join(", ");
+}
+function lockBesideEntry(entryFile) {
+  return join(dirname(resolve(entryFile)), "xano.lock");
+}
+function commandLockPath(args, subcommand) {
+  if (args.lockPath !== void 0) return resolve(args.lockPath);
+  if (args.entryPath !== void 0) return lockBesideEntry(args.entryPath);
+  const found = defaultLockPath();
+  const cwdLock = resolve("xano.lock");
+  if (found !== cwdLock && existsSync(cwdLock)) {
+    const shown = displayPath(found);
+    warn(
+      `A xano.lock also sits at the project root, but \`xanosdk export\` reads ${shown} (beside ${displayPath(entryBesideLock(found) ?? found)}), so ${subcommand === "import" ? "this import writes" : "this uses"} ${shown}. If the root one holds identities you adopted, move it there before exporting (\`mv ${pasteShown(cwdLock)} ${pasteShown(found)}\`); otherwise delete it.`,
+      "lock.root-shadowed"
+    );
+  }
+  if (found === cwdLock && !existsSync(cwdLock)) {
+    const backendDir = relForwardSlash(process.cwd(), backendDirIn(process.cwd())) || XANO_DIR;
+    const nested = resolve(backendDir, "xano.lock");
+    if (existsSync(nested)) {
+      const where = pastePath(".") === "." ? "in this directory" : "at the project root";
+      throw new UsageError(
+        `lock ${subcommand}: no xano.lock ${where}, but one exists at ${pasteShown(nested)} \u2014 the lock sits beside the entry file, in this project's backend directory. Re-run with \`--entry=${pasteShown(resolve(backendDir, "index.ts"))}\` (or \`--lock=${pasteShown(nested)}\`).`
+      );
+    }
+  }
+  return found;
+}
+function defaultLockPath() {
+  const cwd = process.cwd();
+  const cwdLock = resolve("xano.lock");
+  if (entryBesideLock(cwdLock) !== void 0) return cwdLock;
+  const backendDir = backendDirIn(cwd);
+  if (resolve(backendDir) === resolve(cwd)) return cwdLock;
+  const nestedLock = join(backendDir, "xano.lock");
+  return entryBesideLock(nestedLock) !== void 0 ? nestedLock : cwdLock;
+}
+function lockFlags(args, lockPath) {
+  if (args.entryPath !== void 0) return ` --entry=${pasteShown(resolve(args.entryPath))}`;
+  return resolve(lockPath) === defaultLockPath() ? "" : ` --lock=${pasteShown(lockPath)}`;
+}
+function staleRecordRemedies(destKeys, flags, tenantLock) {
+  const out = [];
+  for (const key of destKeys) {
+    const m = /\/(tenant|ephemeral)\/([^/]+)$/.exec(key);
+    if (m === null) continue;
+    out.push(`\`xanosdk ${m[1]} delete ${shellWord(m[2])}${m[1] === "tenant" ? tenantLock : ""}${flags}\``);
+  }
+  return out;
+}
+var ADOPTED_NOTE = "They pin objects still serving on the backend they were adopted from, so pruning them would hand the engine back its own objects as strangers.";
+function pasteShown(path) {
+  return shellWord(displayPath(path));
+}
+async function lockRename(args) {
+  const [, kind, oldName, newName] = args.positionals;
+  if (!kind || !oldName || !newName) {
+    throw missingArgument(!kind ? "kind" : !oldName ? "old" : "new", { command: "lock", subcommand: "rename" });
+  }
+  const payloadKey = payloadKeyFor(kind, "rename");
+  try {
+    checkRenameTarget(payloadKey, oldName, newName);
+  } catch (err) {
+    throw new UsageError(err instanceof Error ? err.message : String(err), {
+      hintFor: { command: "lock", subcommand: "rename" }
+    });
+  }
+  const lockPath = commandLockPath(args, "rename");
+  const lock = readExistingLock(lockPath, "rename", true);
+  const shownKind = payloadKey === "toolset" ? kind === "agent" ? "agent" : "mcpServer" : sdkKindName(payloadKey);
+  const newKey = `${payloadKey}:${newName}`;
+  const shownNew = `${shownKind}:${newName}`;
+  const shownOld = `${shownKind}:${oldName}`;
+  const oldKey = `${payloadKey}:${oldName}`;
+  const moved = lock.objects[newKey];
+  const wasOld = (guid) => guid === rawDeriveGuid(oldKey) || Object.values(lock.landed ?? {}).some((record) => record[oldKey]?.guid === guid) || lockHistory(lockPath)?.(oldKey) === true;
+  if (!(oldKey in lock.objects) && moved?.guid !== void 0 && moved.guid !== rawDeriveGuid(newKey) && wasOld(moved.guid)) {
+    humanOut(args).write(
+      `Lock entry "${shownOld}" is already renamed: "${shownNew}" carries its identity (${describeEntry(moved)}). Nothing to do.
+`
+    );
+    if (isMachineOutput(args)) {
+      writeJson({ verb: "rename", lock: lockPath, from: shownOld, to: shownNew, entry: entryDoc(moved), discardedCanonical: null, movedChildren: [], alreadyRenamed: true });
+    }
+    return;
+  }
+  if (!(oldKey in lock.objects)) {
+    const sameKind = Object.keys(lock.objects).filter((k) => k.startsWith(`${payloadKey}:`)).map((k) => k.slice(payloadKey.length + 1));
+    const meant = suggest(oldName, sameKind);
+    throw new LockEntryNotFoundError(
+      `No lock entry "${shownOld}" in ${displayPath(lockPath)}` + (meant === void 0 ? "." : ` \u2014 did you mean "${shownKind}:${meant}"?`) + ` \`lock rename\` moves an existing entry \u2014 check the kind and the old name (kinds: ${acceptedKinds()}).`,
+      // Kind-qualified, as `lock prune`'s suggestions are (E2E pass 26).
+      meant === void 0 ? {} : { suggestion: `${shownKind}:${meant}` }
+    );
+  }
+  const moving = lock.objects[oldKey].guid;
+  const heldAt = allLandings(process.cwd(), lock).filter(
+    ([, record]) => record[newKey] !== void 0 && record[newKey].guid !== moving
+  );
+  const target = heldAt[0]?.[1][newKey].guid;
+  const landedAt = heldAt.map(([dest]) => dest);
+  if (landedAt.length > 0) {
+    const prune = `\`xanosdk lock prune --identity-only ${shellWord(shownOld)} --yes${lockFlags(args, lockPath)}\``;
+    const landingDefault = join(backendDirIn(process.cwd()), "xano.lock");
+    const tenantLock = resolve(lockPath) === resolve(landingDefault) ? "" : ` --lock=${pasteShown(lockPath)}`;
+    const stale = staleRecordRemedies(landedAt, contextFlags(args), tenantLock);
+    throw new CliError(
+      "SDK_IDENTITY_CONFLICT",
+      `${newKey in lock.objects ? "Lock entry " : ""}"${shownNew}" (guid ${target}) is live: this project landed it on ${landedAt.join(", ")}, so it is an object of its own there, not "${shownOld}" renamed. Moving "${shownOld}"'s identity onto it would give that backend two identities under one name, and its next deploy would refuse.` + (stale.length === 0 ? "" : ` If ${stale.length === 1 ? "that backend no longer exists" : "a backend named there no longer exists"}, clear this project's stale record of it \u2014 ${stale.join(", ")} \u2014 and run this rename again.`) + ` If "${shownOld}" was deleted (or a deploy already recreated it as "${shownNew}"), drop its entry: ${prune}.`,
+      { exitCode: 2, details: { from: shownOld, to: shownNew, guid: target, landedOn: landedAt } }
+    );
+  }
+  const held = lock.objects[newKey];
+  if (held !== void 0 && (held.imported === true || held.adopted === true) && held.guid !== moving) {
+    const prune = `\`xanosdk lock prune --identity-only ${shellWord(shownOld)} --yes${lockFlags(args, lockPath)}\``;
+    throw new CliError(
+      "SDK_IDENTITY_CONFLICT",
+      `Lock entry "${shownNew}" (${describeEntry(held)}) holds the identity \`lock import\` took from a live backend: it is that backend's object, not "${shownOld}" renamed. Moving "${shownOld}"'s identity onto it would replace the live object's guid, and the next deploy there would recreate it. Nothing was written. If "${shownOld}" was deleted (or folded into "${shownNew}"), drop its entry: ${prune}.`,
+      { exitCode: 2, details: { from: shownOld, to: shownNew, guid: held.guid ?? null, imported: true } }
+    );
+  }
+  const sourceRequired = newKey in lock.objects;
+  const implicitEntry = args.entryPath === void 0 ? entryBesideLock(lockPath) : void 0;
+  const entryPath = args.entryPath ?? implicitEntry;
+  if (implicitEntry !== void 0) {
+    humanOut(args).write(`Reading the workspace from ${displayPath(implicitEntry)} (beside the lock) to check the rename.
+`);
+  }
+  let observed;
+  let observedEntries;
+  if (entryPath !== void 0) {
+    try {
+      observedEntries = await observedRenameEntries(entryPath, lock, `${payloadKey}:${oldName}`);
+      observed = new Set(Object.keys(observedEntries));
+    } catch (err) {
+      if (args.entryPath !== void 0 || sourceRequired) throw err;
+      warn(
+        `Could not evaluate ${displayPath(entryPath)} to check this rename, so nothing confirms "${shownOld}" was renamed in code. Pass \`--entry=<path>\` to check against the workspace.`,
+        "lock.rename-unchecked"
+      );
+    }
+  }
+  if (observed !== void 0 && entryPath !== void 0) {
+    if (observed.has(`${payloadKey}:${oldName}`) && !sourceRequired) {
+      throw new UsageError(
+        `"${displayPath(entryPath)}" still exports ${shownKind} "${oldName}", so this is not a rename: moving "${shownOld}" to "${shownNew}" would take its identity away from an object that still uses it. Rename the object in code first, then re-run \`lock rename\`.`,
+        { hintFor: { command: "lock", subcommand: "rename" } }
+      );
+    }
+    if (!observed.has(newKey)) {
+      const unpinned = [...observed].filter((k) => k.startsWith(`${payloadKey}:`) && !(k in lock.objects)).map((k) => JSON.stringify(k.slice(payloadKey.length + 1)));
+      throw new UsageError(
+        `"${entryPath}" exports no ${shownKind} "${newName}", so an entry moved to "${shownNew}" would match nothing. ` + (unpinned.length > 0 ? `${shownKind} names it exports that the lock does not pin yet: ${unpinned.join(", ")}.` : `Rename the object in code first, then re-run \`lock rename\`.`)
+      );
+    }
+    const pins = observedEntries?.[newKey]?.guid;
+    const inCode = observedEntries?.[newKey]?.guid_source === "code" || pins !== (lock.objects[newKey]?.guid ?? rawDeriveGuid(newKey));
+    if (pins !== void 0 && moving !== void 0 && pins !== moving && inCode) {
+      throw new CliError(
+        "SDK_IDENTITY_CONFLICT",
+        `${shownKind} "${newName}" pins its own guid in its def (${pins}), and a def's guid replaces any lock entry: the next export would re-pin "${shownNew}" to it, and a deploy would drop "${oldName}" (guid ${moving}) with everything it holds. Nothing was written. If "${newName}" is "${oldName}" renamed, set its def to \`guid: "${moving}"\` \u2014 the identity then moves with no \`lock rename\`. If it is a new object, "${shownOld}" was deleted: \`xanosdk lock prune --identity-only ${shellWord(shownOld)} --yes${lockFlags(args, lockPath)}\`.`,
+        { exitCode: 2, details: { from: shownOld, to: shownNew, guid: moving, pins } }
+      );
+    }
+  }
+  let result;
+  try {
+    result = renameLockEntry(lock, payloadKey, oldName, newName, observed, shownKind);
+  } catch (err) {
+    if (!(err instanceof LockRenameConflictError)) throw err;
+    const flags = lockFlags(args, lockPath);
+    const prune = (key) => `\`xanosdk lock prune --identity-only ${shellWord(key)} --yes${flags}\``;
+    throw new LockRenameConflictError(
+      `${err.message} If "${shownOld}" was deleted and "${shownNew}" is the object to keep, drop the old entry: ${prune(shownOld)}. If "${shownNew}" is the renamed "${shownOld}" and its own entry is stale, drop that one first \u2014 ${prune(shownNew)} \u2014 then re-run this rename.`,
+      err.keys
+    );
+  }
+  const { lock: renamed, discardedNewcomer } = result;
+  const movedChildren = result.movedChildren.map((c) => ({
+    kind: sdkKindName(c.kind),
+    from: displayLockKey(c.from),
+    to: displayLockKey(c.to)
+  }));
+  writeLockFile(lockPath, renamed);
+  warnRemainingDuplicates(lockPath);
+  humanOut(args).write(
+    `Renamed lock entry "${shownOld}" \u2192 "${shownNew}" (${describeEntry(renamed.objects[`${payloadKey}:${newName}`])}).
+`
+  );
+  for (const c of movedChildren) humanOut(args).write(`  and its ${c.kind} "${c.from}" \u2192 "${c.to}".
+`);
+  const codeCanonical = discardedNewcomer?.canonical_source === "code" ? discardedNewcomer.canonical : void 0;
+  const discardedCanonical = codeCanonical === void 0 ? discardedNewcomer?.canonical : void 0;
+  if (discardedNewcomer) {
+    const said = `replaced the name-derived entry "${shownNew}" held` + (discardedNewcomer.guid !== void 0 ? ` (guid ${discardedNewcomer.guid})` : "") + ` \u2014 it was never the renamed object's identity` + (codeCanonical !== void 0 ? `; kept the canonical ${codeCanonical} your code pins` : discardedCanonical !== void 0 ? `; its minted canonical ${discardedCanonical} was discarded` : "") + `.`;
+    humanOut(args).write(`  ${said}
+`);
+  }
+  const exportEntry = entryPath === void 0 ? void 0 : resolve(entryPath);
+  const exportLock = exportEntry !== void 0 && lockBesideEntry(exportEntry) === resolve(lockPath) ? "" : ` --lock=${pasteShown(lockPath)}`;
+  humanOut(args).write(
+    `The next export or deploy emits the original guid under the new name \u2014 \`xanosdk export ${exportEntry === void 0 ? "<entry-file>" : pasteShown(exportEntry)}${exportLock} --out ${process.platform === "win32" ? "NUL" : "/dev/null"}\` records it now, if you want the lock settled first.
+`
+  );
+  if (isMachineOutput(args)) {
+    writeJson({
+      verb: "rename",
+      lock: lockPath,
+      from: shownOld,
+      to: shownNew,
+      entry: entryDoc(renamed.objects[`${payloadKey}:${newName}`]),
+      discardedCanonical: discardedCanonical ?? null,
+      movedChildren,
+      alreadyRenamed: false
+    });
+  }
+}
+async function observedRenameEntries(entryFile, lock, oldKey) {
+  const objects = { ...lock.objects };
+  delete objects[oldKey];
+  return observedLockEntries(entryFile, withObjects(lock, objects), "lock rename");
+}
+async function observedLockKeys(entryFile, lock, verb = "lock prune") {
+  return new Set(Object.keys(await observedLockEntries(entryFile, lock, verb)));
+}
+async function observedLockEntries(entryFile, lock, verb) {
+  resetLockOverrides();
+  seedLockOverrides(lock);
+  let def;
+  try {
+    def = await loadDefault(entryFile);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `${verb} evaluated "${entryFile}" to find out which lock entries are still live, and loading it failed:
+  ${reason}
+Finding orphans requires running your workspace source \u2014 anything the entry file does at module scope (asserting env vars, reading config) runs too. To drop entries you can name yourself, no evaluation is needed: \`xanosdk lock prune --identity-only --yes <key>\u2026\` (e.g. \`table:users\`) with \`--lock=<path>\` or \`--entry=<path>\` to locate the lock.`,
+      { cause: err }
+    );
+  }
+  if (!Xano.isXano(def)) {
+    throw new UsageError(`Module "${entryFile}" must default-export a Xano registry for \`${verb}\`.`);
+  }
+  const ctx = createLockContext(lock);
+  const previousSink = setDiagnosticSink(() => {
+  });
+  try {
+    def.export({ lock: ctx, documentationTokens: checkStandInTokens(def).values });
+  } finally {
+    setDiagnosticSink(previousSink);
+  }
+  return ctx.observed;
+}
+var ENGINE_WORKSPACE_KEYS = ["salt", "iv", "checksum", "domain_prefix", "sql_schema_name", "installed_services"];
+function isCompiledBundle(bundle) {
+  if (bundle === null || typeof bundle !== "object") return false;
+  const payload = bundle.payload;
+  if (payload === null || typeof payload !== "object") return false;
+  const ws = payload.workspace;
+  if (ws === null || typeof ws !== "object" || Array.isArray(ws)) return false;
+  return !ENGINE_WORKSPACE_KEYS.some((key) => key in ws);
+}
+function isFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+async function lockPrune(args) {
+  const [, ...rest] = args.positionals;
+  if (args.identityOnly) {
+    const [first, ...others] = rest;
+    if (args.entryPath === void 0 && first !== void 0 && isFile(first)) {
+      return lockPruneNamed({ ...args, entryPath: first }, others, false);
+    }
+    return lockPruneNamed(args, rest, args.entryPath !== void 0);
+  }
+  let entryFile;
+  let typedKeys;
+  if (args.entryPath !== void 0) {
+    entryFile = args.entryPath;
+    typedKeys = rest;
+  } else {
+    [entryFile, ...typedKeys] = rest;
+  }
+  if (!entryFile) {
+    throw missingArgument("entry-file", { command: "lock", subcommand: "prune" });
+  }
+  if (!isFile(entryFile)) {
+    throw new UsageError(`lock prune: no entry file at ${entryFile}.`, {
+      hintFor: { command: "lock", subcommand: "prune" }
+    });
+  }
+  const keys = typedKeys.map(normalizeLockKey);
+  const lockPath = args.lockPath !== void 0 ? resolve(args.lockPath) : lockBesideEntry(entryFile);
+  const lock = readExistingLock(lockPath, "prune");
+  const kinds = typedToolsetKinds(typedKeys, lock);
+  const observed = await observedLockKeys(entryFile, lock);
+  const orphans = Object.keys(lock.objects).filter((key) => !observed.has(key));
+  let targets;
+  let gone = [];
+  let unproven = [];
+  let adopted = [];
+  if (keys.length > 0) {
+    ({ present: targets, gone, unproven } = splitGone(lock, lockPath, keys, args.entryPath !== void 0, kinds));
+    for (const key of targets) {
+      if (!orphans.includes(key)) {
+        throw new UsageError(`Lock entry "${displayLockKey(key, kinds)}" still matches an exported object \u2014 not pruning it.`);
+      }
+    }
+  } else {
+    targets = orphans.filter((key) => lock.objects[key].adopted !== true);
+    adopted = orphans.filter((key) => lock.objects[key].adopted === true);
+    if (adopted.length > 0) {
+      const shown = adopted.map((key) => displayLockKey(key, kinds));
+      warn(
+        `Kept ${entries(adopted.length)} \`lock import\` adopted that this code does not declare: ${shown.join(", ")}. ${ADOPTED_NOTE} To drop them anyway, name them:`,
+        "lock.prune-adopted-kept",
+        [
+          `xanosdk lock prune ${pasteShown(entryFile)} ${shown.map(shellWord).join(" ")}${args.lockPath === void 0 ? "" : ` --lock=${pasteShown(lockPath)}`} --yes`
+        ]
+      );
+    }
+  }
+  if (targets.length === 0 && gone.length === 0) {
+    humanOut(args).write(
+      adopted.length === 0 ? "Nothing to prune \u2014 every lock entry matches an exported object.\n" : "Nothing else to prune \u2014 every other lock entry matches an exported object.\n"
+    );
+    if (isMachineOutput(args)) {
+      writeJson({
+        verb: "prune",
+        lock: lockPath,
+        pruned: [],
+        alreadyGone: [],
+        ...adopted.length === 0 ? {} : { keptAdopted: adopted.map((key) => displayLockKey(key, kinds)) },
+        discardedCanonicals: 0
+      });
+    }
+    return;
+  }
+  const candidates = renameCandidatesFor(
+    targets,
+    lock,
+    Object.fromEntries([...observed].map((k) => [k, true])),
+    kinds
+  );
+  const renames = /* @__PURE__ */ new Map();
+  for (const key of targets) {
+    const c = candidates.get(key);
+    if (c === void 0 || c.only === void 0 && c.hint === "") continue;
+    const sep = key.indexOf(":");
+    const shownKey = displayLockKey(key, kinds);
+    const kind = shownKey.slice(0, shownKey.indexOf(":"));
+    const placeholder = key.slice(0, sep) === "query" ? `'<group>|<VERB>|<name>'` : "<new-name>";
+    const command = `\`xanosdk lock rename ${kind} ${shellWord(key.slice(sep + 1))} ${c.only === void 0 ? placeholder : shellWord(c.only)}${args.lockPath === void 0 ? "" : ` --lock=${pasteShown(lockPath)}`} --entry=${pasteShown(entryFile)}\``;
+    renames.set(
+      key,
+      c.only === void 0 ? `renamed? ${command} keeps its identity${c.hint}` : `renamed to "${c.only}"? ${command} keeps its identity`
+    );
+  }
+  await applyPrune(args, lockPath, lock, targets, kinds, gone, unproven, renames, adopted, entryFile, new Set(orphans));
+}
+function splitGone(lock, lockPath, keys, entryFlag, kinds) {
+  const present = [];
+  const gone = [];
+  const unproven = [];
+  let history = null;
+  for (const key of keys) {
+    if (key in lock.objects) {
+      present.push(key);
+      continue;
+    }
+    const colon = key.indexOf(":");
+    const knownKind = key === "workspace" || colon > 0 && LOCK_PAYLOAD_KEYS.has(key.slice(0, colon));
+    if (!knownKind || isFile(key)) throw noLockEntry(lock, key, entryFlag, kinds, lockPath);
+    gone.push(key);
+    if (Object.values(lock.landed ?? {}).some((record) => key in record)) continue;
+    if (history === null) history = lockHistory(lockPath);
+    if (history === void 0 || !history(key)) unproven.push(key);
+  }
+  return { present, gone, unproven };
+}
+function lockHistory(lockPath) {
+  const git = (...argv) => execFileSync("git", argv, {
+    cwd: dirname(resolve(lockPath)),
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: 5e3,
+    encoding: "utf8"
+  }).trim();
+  const file = `./${basename(lockPath)}`;
+  try {
+    if (git("rev-parse", "--is-shallow-repository") === "true") return void 0;
+    if (git("log", "-1", "--format=%H", "--", file) === "") return void 0;
+  } catch {
+    return void 0;
+  }
+  return (key) => {
+    try {
+      return git("log", "-1", "--format=%H", `-S${JSON.stringify(key)}`, "--", file) !== "";
+    } catch {
+      return false;
+    }
+  };
+}
+async function lockPruneNamed(args, keys, entryFlag) {
+  if (keys.length === 0) {
+    throw new UsageError(
+      "`lock prune --identity-only` prunes the entries you name, so it needs at least one key (`table:users`). Without keys there is nothing to prune, because finding orphans is exactly the step --identity-only skips \u2014 drop the flag and pass the entry file to do that.",
+      { helpFor: { command: "lock", subcommand: "prune" } }
+    );
+  }
+  const lockPath = commandLockPath(args, "prune");
+  const lock = readExistingLock(lockPath, "prune", true);
+  const kinds = typedToolsetKinds(keys, lock);
+  const { present, gone, unproven } = splitGone(lock, lockPath, keys.map(normalizeLockKey), entryFlag, kinds);
+  keys = present;
+  if (keys.length > 0) {
+    warn(
+      `--identity-only \u2014 nothing was evaluated, so nothing confirms ${keys.length === 1 ? "this key is" : "these keys are"} orphaned. A key the workspace still exports gets a NEW identity at the next export.`,
+      "lock.identity-only"
+    );
+  }
+  await applyPrune(args, lockPath, lock, keys, kinds, gone, unproven);
+}
+function typedToolsetKinds(typed, lock) {
+  const kinds = toolsetKindsFromLock(lock.objects);
+  for (const key of typed) {
+    const colon = key.indexOf(":");
+    const kind = key.slice(0, colon);
+    if (kind === "agent" || kind === "mcpServer" || kind === "mcp_server") {
+      kinds.set(key.slice(colon + 1), kind === "agent" ? "agent" : "mcpServer");
+    }
+  }
+  return kinds;
+}
+function noLockEntry(lock, key, entryFlag, kinds, lockPath) {
+  const known = Object.keys(lock.objects);
+  const meant = isFile(key) ? void 0 : closestKey(lock, key, kinds);
+  const entry = entryBesideLock(lockPath);
+  return new LockEntryNotFoundError(
+    `No lock entry "${displayLockKey(key, kinds)}" to prune${meant === void 0 ? "." : ` \u2014 did you mean "${meant}"?`}` + (isFile(key) ? entryFlag ? ` It is a file: with \`--entry\` given, every positional is a lock key.` : ` It is a file: only the first positional is the entry file, and every one after it is a lock key.` : "") + (known.length === 0 ? " The lock is empty." : ` Keys look like ${JSON.stringify(displayLockKey(known[0]))} \u2014 run \`xanosdk lock prune ${entry === void 0 ? "<entry-file>" : pasteShown(entry)}\` without keys to list the orphans.`),
+    meant === void 0 ? {} : { suggestion: meant }
+  );
+}
+function closestKey(lock, key, kinds) {
+  return suggest(displayLockKey(key, kinds), Object.keys(lock.objects).map((k) => displayLockKey(k, kinds)));
+}
+function entries(n) {
+  return `${n} lock ${n === 1 ? "entry" : "entries"}`;
+}
+function acceptedKinds() {
+  return acceptedLockKinds().join(", ");
+}
+function entryBesideLock(lockPath) {
+  const dir = dirname(lockPath);
+  for (const name of ["index.ts", "index.mts", "index.js", "index.mjs"]) {
+    const candidate = join(dir, name);
+    if (isFile(candidate)) return candidate;
+  }
+  return void 0;
+}
+async function applyPrune(args, lockPath, lock, targets, kinds, gone = [], unproven = [], renames = /* @__PURE__ */ new Map(), keptAdopted = [], entryFile, prunable) {
+  const proven = unproven.length === 0;
+  const kept = keptAdopted.length === 0 ? {} : { keptAdopted: keptAdopted.map((key) => displayLockKey(key, kinds)) };
+  const namedAdopted = targets.filter((key) => lock.objects[key]?.adopted === true);
+  if (namedAdopted.length > 0) {
+    warn(
+      `${namedAdopted.map((key) => `"${displayLockKey(key, kinds)}"`).join(", ")} ${namedAdopted.length === 1 ? "was" : "were"} adopted by \`lock import\`. ${ADOPTED_NOTE}`,
+      "lock.prune-adopted"
+    );
+  }
+  const goneShown = gone.map((key) => displayLockKey(key, kinds));
+  const nearMisses = {};
+  for (const key of unproven) {
+    const meant = suggest(
+      displayLockKey(key, kinds),
+      Object.keys(lock.objects).filter((k) => lock.objects[k].adopted !== true && (prunable === void 0 || prunable.has(k))).map((k) => displayLockKey(k, kinds))
+    );
+    if (meant !== void 0) nearMisses[displayLockKey(key, kinds)] = meant;
+  }
+  const meants = [...new Set(Object.values(nearMisses))];
+  const suggested = meants.length > 0 ? { suggestion: meants[0], ...meants.length > 1 ? { suggestions: meants } : {}, nearMisses } : {};
+  const entryWord = args.identityOnly === true ? " --identity-only" : entryFile === void 0 ? "" : ` ${pasteShown(resolve(entryFile))}`;
+  const lockWord = args.identityOnly === true ? lockFlags(args, lockPath) : ` --lock=${pasteShown(lockPath)}`;
+  for (const [shown, meant] of Object.entries(nearMisses)) {
+    warn(`"${shown}" is not in ${displayPath(lockPath)}.`, "lock.prune-near-miss", [
+      `Did you mean "${safeText(meant)}"? \`xanosdk lock prune${entryWord} ${shellWord(meant)}${lockWord}\` prunes it, after asking to confirm.`
+    ]);
+  }
+  const goneNote = gone.length > 0 ? proven ? `Already pruned (not in ${displayPath(lockPath)}): ${goneShown.join(", ")}.
+` : (
+    // No history to tell a typo from a finished prune, so the answer
+    // stays the idempotent one; a near miss is named once, by the
+    // warning that prints the prune running it (E2E pass 30).
+    `Not in ${displayPath(lockPath)} \u2014 already pruned, or never there: ${goneShown.join(", ")}.
+`
+  ) : "";
+  if (targets.length === 0) {
+    humanOut(args).write(`Nothing to prune. ${goneNote}`);
+    if (isMachineOutput(args)) {
+      writeJson({ verb: "prune", lock: lockPath, pruned: [], alreadyGone: goneShown, ...suggested, ...kept, discardedCanonicals: 0 });
+    }
+    return;
+  }
+  const lines = targets.sort().map((key) => `  ${displayLockKey(key, kinds)} (${describeEntry(lock.objects[key])})`).join("\n");
+  const renameLines = targets.filter((key) => renames.has(key)).map((key) => `  ${displayLockKey(key, kinds)}: ${renames.get(key)} instead.
+`).join("");
+  const discarded = targets.filter((key) => lock.objects[key].canonical !== void 0);
+  const canonicalNote = (done) => discarded.length > 0 ? `${done ? "Discarded" : "Would discard"} ${discarded.length} ${discarded.length === 1 ? "canonical" : "canonicals"} \u2014 a pruned canonical's public URL is unrecoverable.
+` : "";
+  if (!args.yes) {
+    humanOut(args).write(`Would prune ${entries(targets.length)}:
+${lines}
+${renameLines}${canonicalNote(false)}${goneNote}`);
+    const { confirm } = await import("./prompt-II3F3LND.js");
+    const { yesRerun } = await import("./retry-command-AS5EVREX.js");
+    const { rerun, note } = yesRerun(args, `lock prune${entryWord}${targets.map((k) => ` ${shellWord(displayLockKey(k, kinds))}`).join("")}${lockWord}`);
+    const refusal = {
+      details: {
+        wouldPrune: targets.map((key) => displayLockKey(key, kinds)),
+        alreadyGone: goneShown,
+        ...suggested,
+        ...kept,
+        wouldDiscardCanonicals: discarded.length
+      },
+      rerun,
+      note
+    };
+    if (!await confirm(`Prune ${targets.length === 1 ? "it" : "them"} from ${displayPath(lockPath)}?`, { flag: "--yes", refusal })) {
+      info(`Lock prune cancelled. Nothing was written to ${displayPath(lockPath)}.`);
+      if (isMachineOutput(args)) {
+        writeJson({ verb: "prune", lock: lockPath, declined: true, pruned: [], alreadyGone: goneShown, ...suggested, ...kept, discardedCanonicals: 0 });
+      }
+      return;
+    }
+  }
+  const objects = { ...lock.objects };
+  for (const key of targets) delete objects[key];
+  writeLockFile(lockPath, withObjects(lock, objects));
+  warnRemainingDuplicates(lockPath);
+  humanOut(args).write(`Pruned ${entries(targets.length)}:
+${lines}
+${canonicalNote(true)}${goneNote}`);
+  if (isMachineOutput(args)) {
+    writeJson({
+      verb: "prune",
+      lock: lockPath,
+      pruned: targets.map((key) => displayLockKey(key, kinds)),
+      alreadyGone: goneShown,
+      ...suggested,
+      ...kept,
+      discardedCanonicals: discarded.length
+    });
+  }
+}
+async function lockAdopt(args) {
+  const [, bundlePath] = args.positionals;
+  if (!bundlePath) {
+    throw missingArgument("bundle.json", { command: "lock", subcommand: "import" });
+  }
+  if (!isFile(bundlePath)) {
+    throw new (existsSync(bundlePath) ? UsageError : LocalFileNotFoundError)(
+      `lock import: no file at ${bundlePath}. It takes a live backend's exported bundle \u2014 \`xanosdk workspace export --path <file>${contextFlags()}\` writes one.`,
+      { hintFor: { command: "lock", subcommand: "import" } }
+    );
+  }
+  const lockPath = commandLockPath(args, "import");
+  const lock = existsSync(lockPath) ? readLockFile(lockPath) : emptyLock();
+  let bundle;
+  try {
+    bundle = JSON.parse(readFileSync(bundlePath, "utf8"));
+  } catch (err) {
+    throw new UsageError(
+      `lock import: ${bundlePath} is not JSON (${err instanceof Error ? err.message : String(err)}). It takes a live backend's exported bundle \u2014 \`xanosdk workspace export --path <file>${contextFlags()}\` writes one.`
+    );
+  }
+  if (isCompiledBundle(bundle)) {
+    throw new UsageError(
+      `lock import: ${bundlePath} is a bundle this CLI compiled (\`xanosdk export\`), not an export of a live backend. Its identities are the ones your code already derives, so importing it would adopt nothing the backend actually holds. Export the live backend with \`xanosdk workspace export --path <file>${contextFlags()}\` and import that.`,
+      { hintFor: { command: "lock", subcommand: "import" } }
+    );
+  }
+  let result;
+  try {
+    result = adoptFromBundle(lock, bundle, bundlePath);
+  } catch (err) {
+    if (err instanceof LockImportConflictError) {
+      const message = err.clash !== void 0 ? await clashMessage(args, lockPath, lock, bundlePath, err.clash) : err.message;
+      throw new LockImportConflictError(`lock import: nothing was written. ${message}`);
+    }
+    if (err instanceof NotABundleError) {
+      throw new UsageError(
+        `lock import: ${err.message} It takes a live backend's exported bundle \u2014 \`xanosdk workspace export --path <file>${contextFlags()}\` writes one.`,
+        { hintFor: { command: "lock", subcommand: "import" } }
+      );
+    }
+    throw err;
+  }
+  const { added, changed, canonicalsSeen, vaultCount, privateVaultCount } = result;
+  const adopted = markImported(markAdopted(result.lock, added), result.seen.filter((key) => !added.includes(key)));
+  const kinds = toolsetKindsFromPayload(bundle.payload, lock.objects);
+  if (changed.length > 0 && !args.yes) {
+    const lines = changed.map((c) => `  ${displayLockKey(c.key, kinds)}: ${describeEntry(c.before)} \u2192 ${describeEntry(c.after)}`).join("\n");
+    humanOut(args).write(`Adoption would overwrite ${changed.length} existing ${changed.length === 1 ? "lock entry" : "lock entries"}:
+${lines}
+`);
+    const { confirm } = await import("./prompt-II3F3LND.js");
+    const { yesRerun } = await import("./retry-command-AS5EVREX.js");
+    const { rerun, note } = yesRerun(args, `lock import ${shellWord(bundlePath)}`);
+    const question = `Overwrite ${changed.length === 1 ? "it" : "them"} with what ${bundlePath} holds?`;
+    const refusal = {
+      details: { verb: "import", written: false, wouldUpdate: changed.map((c) => displayLockKey(c.key, kinds)) },
+      rerun,
+      note
+    };
+    if (!await confirm(question, { flag: "--yes", refusal })) {
+      info(`Lock import cancelled. Nothing was written to ${lockPath}.`);
+      if (isMachineOutput(args)) {
+        writeJson({
+          verb: "import",
+          lock: lockPath,
+          bundle: resolve(bundlePath),
+          declined: true,
+          added: [],
+          updated: [],
+          canonicalsSeen,
+          vaultEntries: vaultCount
+        });
+      }
+      return;
+    }
+  }
+  if (privateVaultCount > 0) {
+    warn(
+      `${bundlePath} contains ${privateVaultCount} private stored ${privateVaultCount === 1 ? "file entry" : "file entries"}. Do NOT commit the bundle file; delete it once the import is done.`,
+      "secrets.vault-in-bundle"
+    );
+  }
+  if (!canonicalsSeen) {
+    warn(
+      // NOT a safety guarantee. A public URL
+      // slug is unique across the whole INSTANCE, and an import resolves a
+      // clash by inventing an identity rather than refusing it — it keeps
+      // whatever the object already stored and substitutes a random token when
+      // another workspace owns the one asked for, reporting neither. What is
+      // true is narrower: the slugs this workspace serves today are not in this
+      // file, so adoption cannot have changed them.
+      `No canonicals found in ${bundlePath} \u2014 a configuration-only export strips them, so only guids were adopted. Nothing here changed the public URLs this workspace serves, but the lock does not know them either: until an export records one, a release treats every slug as a preference and accepts whatever the workspace already serves. Pin the ones your frontend is built from in code (\`canonical: "..."\`) and re-export \u2014 a pinned slug a release cannot serve fails the release instead of 404-ing your routes.`,
+      "lock.no-canonicals"
+    );
+  }
+  for (const p of result.codePinned) {
+    const shown = displayLockKey(p.key, kinds);
+    warn(
+      `${shown} was not adopted: its def pins \`guid: "${p.guid}"\` in code, which wins over xano.lock, so the live guid ${p.live} would be replaced again at the next export. If the live object is this one, set its def to \`guid: "${p.live}"\` and export; otherwise nothing to do \u2014 the def declares another object than the live one.`,
+      "lock.import-code-pinned"
+    );
+  }
+  writeLockFile(lockPath, adopted);
+  humanOut(args).write(
+    // A re-import of a bundle already adopted: "Adopted …: 0 added, 0 updated"
+    // read as something done (E2E pass 16).
+    added.length === 0 && changed.length === 0 ? `${lockPath} is already up to date with ${bundlePath} \u2014 nothing to adopt.
+` : `Adopted ${bundlePath} into ${lockPath}: ${added.length} added, ${changed.length} updated.
+`
+  );
+  const entry = args.entryPath ?? entryBesideLock(lockPath);
+  const shownEntry = entry === void 0 ? "<entry-file>" : pasteShown(entry);
+  const lockFlag = entry !== void 0 && lockBesideEntry(entry) === resolve(lockPath) ? "" : ` --lock=${pasteShown(lockPath)}`;
+  if (added.some((key) => key !== WORKSPACE_KEY) || changed.length > 0) {
+    detail(
+      `Every identity in ${bundlePath} is now this project's: once a deploy or release lands them on a destination, a \`--prune\` from this project can delete those objects there. If you meant to take over only some, remove the rest before anything lands: \`xanosdk lock prune ${shownEntry} <kind>:<name>\u2026${lockFlag} --yes\`.`
+    );
+  }
+  if (added.length > 0 || changed.length > 0) {
+    detail(
+      `Next: \`xanosdk export ${shownEntry}${lockFlag} --out ${process.platform === "win32" ? "NUL" : "/dev/null"}\` records what this code emits against it, so \`export --check\` and \`--frozen-lock\` pass \u2014 with \`--allow-lock-orphans\` while this code ports only part of what was adopted: an adopted entry it does not declare is an orphan to them, one still serving live.`
+    );
+  }
+  if (isMachineOutput(args)) {
+    writeJson({
+      verb: "import",
+      lock: lockPath,
+      bundle: resolve(bundlePath),
+      declined: false,
+      added: added.map((key) => displayLockKey(key, kinds)),
+      updated: changed.map((c) => displayLockKey(c.key, kinds)),
+      codePinned: result.codePinned.map((p) => ({ key: displayLockKey(p.key, kinds), guid: p.guid, live: p.live })),
+      canonicalsSeen,
+      vaultEntries: vaultCount
+    });
+  }
+}
+function markImported(lock, keys) {
+  const objects = { ...lock.objects };
+  for (const key of keys) {
+    const entry = objects[key];
+    if (key !== WORKSPACE_KEY && entry?.guid !== void 0 && entry.adopted !== true) objects[key] = { ...entry, imported: true };
+  }
+  return withObjects(lock, objects);
+}
+function markAdopted(lock, keys) {
+  if (keys.length === 0) return lock;
+  const objects = { ...lock.objects };
+  for (const key of keys) if (key !== WORKSPACE_KEY) objects[key] = { ...objects[key], adopted: true };
+  return withObjects(lock, objects);
+}
+async function clashMessage(args, lockPath, lock, bundlePath, clash) {
+  const { kind, kindWord, workspaceName, lockName, workspaceKey, lockKey: pinnedKey, guid } = clash;
+  const entryPath = args.entryPath ?? entryBesideLock(lockPath);
+  const flags = lockFlags(args, lockPath);
+  const rename = `\`xanosdk lock rename ${kindWord} ${lockName} ${workspaceName}${flags}\``;
+  const head = `${bundlePath} holds guid ${guid} under "${workspaceKey}", but the lock already pins it to "${pinnedKey}".`;
+  let observed;
+  if (entryPath !== void 0) {
+    try {
+      observed = await observedLockKeys(entryPath, lock, "lock import");
+    } catch {
+      observed = void 0;
+    } finally {
+      resetLockOverrides();
+    }
+  }
+  if (observed === void 0) {
+    return `${head} One side renamed it. If the workspace did, rename it in code to "${workspaceName}" too, then ${rename} and re-run the import. If your source did, the lock already follows it: deploy the rename, then export the workspace again and re-import.`;
+  }
+  const exportsPinned = observed.has(`${kind}:${lockName}`);
+  const exportsWorkspace = observed.has(`${kind}:${workspaceName}`);
+  if (exportsPinned && !exportsWorkspace) {
+    return `${head} Your source renamed it \u2014 it exports "${lockName}", which the lock already follows \u2014 and the workspace has not received the rename yet. Deploy it, then export the workspace again and re-run the import. To keep the workspace's name instead, rename it back to "${workspaceName}" in code, then ${rename}.`;
+  }
+  if (exportsWorkspace && !exportsPinned) {
+    return `${head} It was renamed on both sides; move the lock entry to match \u2014 ${rename} \u2014 then re-run the import.`;
+  }
+  if (!exportsPinned) {
+    return `${head} The workspace renamed it. Rename it to "${workspaceName}" in code too, then ${rename} and re-run the import.`;
+  }
+  return `${head} Your source exports both "${lockName}" and "${workspaceName}", so this is not a rename: the workspace's "${workspaceName}" carries the identity your "${lockName}" is pinned to. Export the workspace again after deploying, and re-import.`;
+}
+export {
+  isCompiledBundle,
+  runLockCommand
+};
+//# sourceMappingURL=lock-commands-2QG25HL7.js.map