@xano/sdk 1.0.0

package/dist/workspace-2CLHU2LK.js

@@ -0,0 +1,93 @@
+import {
+  debugEnabled,
+  fetchReadOrExplain,
+  parseJsonAnswer,
+  serverMessage,
+  transportTarget
+} from "./chunk-YLDALTWZ.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-PTHVMXZI.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/deploy/workspace.ts
+var RESOLVE_TIMEOUT_MS = 3e4;
+var AmbiguousWorkspace = class extends Error {
+};
+async function resolveScopedWorkspaceId(auth, opts = {}) {
+  const again = opts.again ?? "xanosdk login";
+  try {
+    return await lookup(auth);
+  } catch (err) {
+    const said = (err instanceof Error ? err.message : String(err)).trimEnd();
+    const reason = /[.?!]$/.test(said) ? said.slice(0, -1) + (said.endsWith("?") ? "?" : "") : said;
+    const lead = opts.again === void 0 ? "Reading the workspace this token is scoped to failed" : "Signed in, but reading your workspace failed";
+    const remedy = err instanceof AmbiguousWorkspace ? `Run \`${again}\` again and pick a single workspace at the consent screen. There is no workspace override \u2014 a credential addresses exactly one workspace.` : opts.again === void 0 ? "" : `Nothing was saved \u2014 run \`${again}\` again.`;
+    if (opts.again === void 0) {
+      const unanswered = await unansweredAfterExchange(lead, reason, err);
+      if (unanswered !== void 0) throw unanswered;
+    }
+    const end = reason.endsWith("?") ? "" : ".";
+    throw new Error(`${lead}: ${reason}${end}${remedy === "" ? "" : ` ${remedy}`}`, { cause: err });
+  }
+}
+async function unansweredAfterExchange(lead, reason, err) {
+  const { isUnansweredLookup, LookupFailedError, unansweredCause } = await import("./source-resolve-S2XA3XZF.js");
+  if (!isUnansweredLookup(err)) return void 0;
+  const head = (reason.split("\n")[0] ?? reason).trim().replace(/[.:]$/, "");
+  const failed = new LookupFailedError(
+    `${lead}: ${head}. ${unansweredCause(err)} \u2014 nothing was changed`,
+    "unreachable",
+    "workspace"
+  );
+  failed.trailer = " The XANO_REFRESH_TOKEN exchange before this lookup succeeded, and a refresh token is single-use, so that token is spent: set XANO_REFRESH_TOKEN to a fresh one (and XANO_CLIENT_ID to the client it was minted for) before the rerun.";
+  failed.message += failed.trailer;
+  failed.cause = err;
+  return failed;
+}
+async function lookup(auth) {
+  const url = new URL("/api:meta/auth/me", auth.instance);
+  const res = await fetchReadOrExplain(
+    url.href,
+    {
+      headers: { Authorization: `Bearer ${auth.access_token}` },
+      signal: AbortSignal.timeout(RESOLVE_TIMEOUT_MS)
+    },
+    "the workspace lookup",
+    RESOLVE_TIMEOUT_MS
+  );
+  const text = await res.text();
+  if (!res.ok) {
+    const said = serverMessage(text);
+    const head = `${transportTarget(url.href)} answered HTTP ${res.status}${said === void 0 ? "" : ` \u2014 ${said}`}`;
+    throw Object.assign(new Error(debugEnabled() && text.trim() !== "" ? `${head}
+${text}` : head), {
+      status: res.status
+    });
+  }
+  const data = parseJsonAnswer(text, "the workspace lookup", url.href) ?? {};
+  const extras = data.extras ?? {};
+  const oauth = extras.oauth ?? {};
+  const instance = extras.instance ?? {};
+  const membership = instance.membership ?? {};
+  const list = Array.isArray(membership.workspace) ? membership.workspace : [];
+  const scopedGuid = typeof oauth.workspace === "string" ? oauth.workspace : void 0;
+  if (scopedGuid !== void 0 && scopedGuid !== "") {
+    const match = list.find((w) => w.guid === scopedGuid);
+    if (match !== void 0 && typeof match.id === "number") return match.id;
+  }
+  const ids = list.filter((w) => typeof w.id === "number");
+  if (ids.length === 1) return ids[0].id;
+  throw new AmbiguousWorkspace(
+    `could not resolve which workspace this token is scoped to (scoped workspace ${scopedGuid ?? "(none)"} not found among ${ids.length} membership workspaces)`
+  );
+}
+export {
+  resolveScopedWorkspaceId
+};
+//# sourceMappingURL=workspace-2CLHU2LK.js.map

package/dist/workspace-binding-56PIIPCP.js

@@ -0,0 +1,54 @@
+import {
+  heldElsewhereError,
+  reachableInline,
+  reachableLines,
+  reachableWorkspaces,
+  readReachableWorkspaces,
+  refuseUnreachableWorkspace,
+  rerunInWorkspace,
+  unreachableWorkspaceMessage,
+  whereaboutsOf,
+  workspaceIdFix
+} from "./chunk-KTSDSD36.js";
+import "./chunk-ET4Y4XCB.js";
+import "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import "./chunk-NAQDMEHV.js";
+import "./chunk-FWD7AL6N.js";
+import "./chunk-TLQE7ZN3.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-PTHVMXZI.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-6MR5TI5V.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-XNCP4KYO.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-NZOWWHU5.js";
+import "./chunk-4BW2SG2N.js";
+import "./chunk-CIMQZRRE.js";
+import "./chunk-OHX6MIUZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  heldElsewhereError,
+  reachableInline,
+  reachableLines,
+  reachableWorkspaces,
+  readReachableWorkspaces,
+  refuseUnreachableWorkspace,
+  rerunInWorkspace,
+  unreachableWorkspaceMessage,
+  whereaboutsOf,
+  workspaceIdFix
+};
+//# sourceMappingURL=workspace-binding-56PIIPCP.js.map

package/dist/workspace-command-JEXQETJD.js

@@ -0,0 +1,535 @@
+import {
+  fetchWorkspaceBundle
+} from "./chunk-X677DMZM.js";
+import "./chunk-LRN4ZJCQ.js";
+import "./chunk-RTJRZFFY.js";
+import {
+  printMicroserviceSection,
+  readMicroservices
+} from "./chunk-FXRQOWTE.js";
+import {
+  confirm
+} from "./chunk-65HWOMGV.js";
+import "./chunk-TPHWJ7UG.js";
+import {
+  listTables
+} from "./chunk-C6RIMRU4.js";
+import "./chunk-AOSYVMUS.js";
+import "./chunk-CJHQKJU4.js";
+import "./chunk-3DRXWLJ5.js";
+import "./chunk-X4DVXBFY.js";
+import {
+  listBranches
+} from "./chunk-TRJCALW3.js";
+import {
+  reachableWorkspaces,
+  refuseUnreachableWorkspace,
+  unreachableWorkspaceMessage
+} from "./chunk-KTSDSD36.js";
+import "./chunk-LIEOKXKD.js";
+import "./chunk-D7VGG3WS.js";
+import "./chunk-2TFRR6JV.js";
+import {
+  resolveOutputTarget,
+  secretsPhrase,
+  writeExportFile
+} from "./chunk-SAVJUS2X.js";
+import {
+  secretsCarriedBy
+} from "./chunk-45UIT5T2.js";
+import "./chunk-HRVBLCVJ.js";
+import "./chunk-YHEFQUQB.js";
+import {
+  assertBundleFile,
+  assertBundleInput,
+  assertEntryFile,
+  assertValueFiles,
+  loadBundleText
+} 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 {
+  getAccessToken
+} from "./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 "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import "./chunk-7G3CTU7I.js";
+import "./chunk-6PBR37LN.js";
+import {
+  yesRerun
+} from "./chunk-T5KELPAR.js";
+import "./chunk-622HUCZT.js";
+import {
+  contextFlags
+} from "./chunk-NAQDMEHV.js";
+import "./chunk-5A2PLKZB.js";
+import "./chunk-AHJWCYQO.js";
+import "./chunk-DX4QR4B2.js";
+import "./chunk-6QXLMMT3.js";
+import "./chunk-ZFDZKNGG.js";
+import "./chunk-FWD7AL6N.js";
+import "./chunk-2GNFDZA2.js";
+import "./chunk-JTUKLCXS.js";
+import {
+  describeWrite
+} from "./chunk-4KHEMC32.js";
+import "./chunk-U64O2MXY.js";
+import "./chunk-ROY4YAEQ.js";
+import "./chunk-P2HAGF6H.js";
+import "./chunk-TLQE7ZN3.js";
+import "./chunk-WRBKLYSJ.js";
+import "./chunk-3LDULPRE.js";
+import "./chunk-XW6KISBB.js";
+import {
+  writeData
+} from "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import {
+  bindingFor,
+  fetchOrExplain,
+  httpFailure,
+  parseJsonAnswer
+} from "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-3KZCLN4Z.js";
+import "./chunk-FXFV3KU6.js";
+import "./chunk-OPHB5ORL.js";
+import "./chunk-UCQ2VUTG.js";
+import "./chunk-DGWHAVRG.js";
+import "./chunk-27GWNP2I.js";
+import "./chunk-3YW23UFH.js";
+import "./chunk-JGE7CAWB.js";
+import {
+  UsageError,
+  blank,
+  credentialWriteTarget,
+  detail,
+  discloseWriteTarget,
+  error,
+  formatFields,
+  info,
+  isMachineOutput,
+  printHuman,
+  stdoutStyle,
+  step,
+  success,
+  tablesCommand,
+  unknownSubcommand,
+  warn,
+  writeJson,
+  writeTargetPayload
+} from "./chunk-PTHVMXZI.js";
+import "./chunk-MXHSQOC4.js";
+import "./chunk-6IUMKYWI.js";
+import "./chunk-2CMJZDCL.js";
+import "./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 "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-6MR5TI5V.js";
+import "./chunk-5ZSO4T2G.js";
+import {
+  HOSTED_ROW_PATH_PREFIX
+} from "./chunk-XNCP4KYO.js";
+import "./chunk-AKNCFVKZ.js";
+import "./chunk-YU4HSQW7.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-EHP3WPEG.js";
+import "./chunk-L5JYN3NM.js";
+import "./chunk-Q7DGTQ5G.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/workspace-command.ts
+var TIMEOUT_MS = 3e4;
+var DEFAULT_NAME = "workspace";
+async function runWorkspaceCommand(args) {
+  switch (args.subcommand) {
+    case "details":
+      return runDetails(args);
+    case "export":
+      return runExport(args);
+    case "diff":
+      return runDiff(args);
+    case "reset-tables":
+      return runResetTables(args);
+    case "branch": {
+      const { runBranchCommand } = await import("./branch-commands-ACIRCEQJ.js");
+      return runBranchCommand(args);
+    }
+    default:
+      throw unknownSubcommand("workspace", args.subcommand, args.positionals);
+  }
+}
+async function fetchWorkspaces(auth) {
+  const url = new URL("/api:meta/workspace", auth.instance);
+  const res = await fetchOrExplain(
+    url.href,
+    {
+      headers: { accept: "application/json", Authorization: `Bearer ${auth.access_token}` },
+      signal: AbortSignal.timeout(TIMEOUT_MS)
+    },
+    "workspace list",
+    TIMEOUT_MS
+  );
+  const text = await res.text();
+  if (!res.ok) {
+    throw Object.assign(new Error(httpFailure("workspace list", res, text)), { status: res.status });
+  }
+  const parsed = parseJsonAnswer(text, "workspace list", url.href);
+  return Array.isArray(parsed) ? parsed : [];
+}
+async function runDetails(args) {
+  const auth = await getAccessToken(args);
+  const workspaceId = auth.workspaceId;
+  const all = await fetchWorkspaces(auth).catch(async (err) => {
+    const { unansweredRead } = await import("./source-resolve-S2XA3XZF.js");
+    throw unansweredRead(err, "read the workspace list", "workspace");
+  });
+  const match = all.find((w) => w.id === workspaceId);
+  if (!match) throw new UsageError(unreachableWorkspaceMessage(auth, reachableWorkspaces(all)));
+  const summary = {
+    instance: auth.instance,
+    id: workspaceId,
+    name: typeof match.name === "string" ? match.name : void 0,
+    guid: typeof match.guid === "string" ? match.guid : void 0,
+    /** Which credential this command is acting under — the only thing that selects a workspace. */
+    credential: auth.credentialType
+  };
+  const microservices = await readMicroservices(auth, auth.instance, workspaceId);
+  if (isMachineOutput(args)) {
+    writeJson({ ...summary, microservices, workspaceId, selector: "workspace" });
+    return;
+  }
+  const s = stdoutStyle();
+  const rows = [
+    ["instance", summary.instance],
+    ["workspace", `${summary.name === void 0 ? "(unnamed)" : summary.name} ${s.dim(`#${summary.id}`)}`]
+  ];
+  if (summary.guid !== void 0) rows.push(["guid", summary.guid]);
+  rows.push([
+    "source",
+    summary.credential === "token" ? "your meta API token credential" : "your sign-in (pinned at login)"
+  ]);
+  printHuman(formatFields(rows) + "\n");
+  printMicroserviceSection(microservices);
+}
+async function runExport(args) {
+  if (args.path === "-" && args.name !== void 0) {
+    throw new UsageError(
+      "`--name` names the exported file, and `--path -` writes the bundle to stdout instead of a file. Drop one: `--path -` to pipe it, or `--name` (with or without a `--path` directory) to write a file.",
+      { hintFor: { command: "workspace", subcommand: "export" } }
+    );
+  }
+  const target = resolveOutputTarget({ path: args.path, name: args.name ?? DEFAULT_NAME, ext: "json" });
+  const auth = await getAccessToken(args);
+  const bundle = await fetchWorkspaceBundle(auth, args.branch);
+  const content = JSON.stringify(bundle, null, 2);
+  if (target.kind === "stdout") {
+    writeData(process.stdout, content + "\n");
+    const secrets = secretsCarriedBy(bundle);
+    if (secrets.length > 0) {
+      warn(
+        `The export carries ${secretsPhrase(secrets)} in cleartext \u2014 written to stdout, where no file permission protects it; do not commit or log it.`,
+        "secrets.cleartext-stdout"
+      );
+    }
+    return;
+  }
+  writeExportFile(target.path, content + "\n", secretsCarriedBy(bundle));
+  if (isMachineOutput(args)) writeJson({ path: target.path });
+  success(`Exported workspace \u2192 ${target.path}`);
+}
+var EXIT_DIFF_MISMATCH = 2;
+async function runDiff(args) {
+  if (args.file === void 0 && args.bundle === void 0) {
+    const { resolveProjectEntry } = await import("./deploy-source-3W45CXMP.js");
+    const entry = resolveProjectEntry(process.cwd());
+    if (entry !== void 0) args = { ...args, file: entry };
+  }
+  assertBundleInput(args, { command: "workspace", subcommand: "diff" });
+  assertBundleFile(args, { command: "workspace", subcommand: "diff" });
+  assertEntryFile(args);
+  const auth = await getAccessToken(args);
+  const local = await loadBundleText(args, { command: "workspace", subcommand: "diff" });
+  let live;
+  try {
+    live = await fetchWorkspaceBundle(auth, args.branch);
+  } catch (err) {
+    const { unansweredRead } = await import("./source-resolve-S2XA3XZF.js");
+    throw unansweredRead(err, "read the workspace to compare", "workspace");
+  }
+  const { compareToLive, SETTINGS_LABEL } = await import("./live-diff-YONW2VI3.js");
+  const { codePinnedCanonicals, releaseCanonicalLock } = await import("./release-command-N4ZPKMHR.js");
+  const pinned = codePinnedCanonicals(local.bundle, releaseCanonicalLock(args), args.file !== void 0);
+  const result = compareToLive(
+    JSON.parse(local.bundle),
+    live,
+    new Set(pinned.map((p) => `${p.payloadKey}:${p.name}`)),
+    // Everything, not the report's sample: a caller who ran a diff asked for the
+    // list, and a truncated one would hide the object they are looking for.
+    // The documentation token is compared as a value: this asks what the target
+    // SAYS, and the live token is the outcome of the one this project sends.
+    { sample: "all", documentation: "compare" }
+  );
+  if (!result.converged) process.exitCode = EXIT_DIFF_MISMATCH;
+  const listed = await listBranches(auth, { baseUrl: auth.instance, workspaceId: auth.workspaceId }).catch(
+    () => void 0
+  );
+  const liveLabel = listed?.find((b) => b.live)?.label;
+  const comparedLabel = args.branch ?? liveLabel;
+  const comparedIsLive = args.branch === void 0 ? true : liveLabel === void 0 ? null : args.branch === liveLabel;
+  if (isMachineOutput(args)) {
+    writeJson({
+      branch: comparedLabel ?? null,
+      live: comparedIsLive,
+      compared: result.compared,
+      // Not `converged`: this answers "is everything I declared there, as
+      // declared", and an undeclared object the target also carries does not
+      // make that false. The `unexpected` list is how a caller asks the other
+      // question.
+      matched: result.converged,
+      missing: result.missing,
+      differing: result.differing,
+      // Beside `differing` rather than inside it, so its entries stay plain
+      // `<sdkKind>:<name>` strings a caller can match on.
+      settingsFields: result.settingsFields,
+      unexpected: result.liveOnly,
+      source: local.source
+    });
+    return;
+  }
+  const where = args.branch !== void 0 ? `branch "${args.branch}"` : liveLabel !== void 0 ? `live branch "${liveLabel}"` : "live";
+  if (result.converged) {
+    success(`${where} holds everything this project declares (${result.compared} ${result.compared === 1 ? "object" : "objects"} compared).`);
+    if (result.liveOnly.length > 0) {
+      blank();
+      report("unexpected there, not declared here", result.liveOnly);
+      blank();
+      detail(`Not a failure \u2014 a merge leaves them alone, and so does \`--prune\` unless this project released them.`);
+      detail(`To remove one this project never released, adopt it first (\`xanosdk lock import\`), then prune.`);
+    }
+    return;
+  }
+  warn(
+    `${where} does not match this project\u2019s compile (${result.compared} ${result.compared === 1 ? "object" : "objects"} compared, ${result.differingCount} differing, ${result.missingCount} missing, ${result.liveOnly.length} unexpected).`,
+    "workspace.drift"
+  );
+  blank();
+  report("missing there, declared here", result.missing);
+  report(
+    "differing",
+    result.differing.map(
+      (row) => row === SETTINGS_LABEL && result.settingsFields.length > 0 ? `${row} \u2014 ${result.settingsFields.join(", ")}` : row
+    )
+  );
+  report("unexpected there, not declared here", result.liveOnly);
+  blank();
+  detail(`Compared against ${local.source}. Nothing was written.`);
+}
+function report(label, rows) {
+  if (rows.length === 0) return;
+  step(`${rows.length} ${label}`);
+  for (const row of rows) detail(row);
+}
+function projectTables(bundle) {
+  const dbo = JSON.parse(bundle).payload?.dbo;
+  if (!Array.isArray(dbo)) return [];
+  return dbo.flatMap((t) => {
+    const { guid, name } = t ?? {};
+    return typeof guid === "string" && typeof name === "string" ? [{ guid, name }] : [];
+  });
+}
+async function runResetTables(args) {
+  const target = { command: "workspace", subcommand: "reset-tables" };
+  const guids = args.table ?? [];
+  if (guids.length === 0) {
+    throw new UsageError(
+      `\`xanosdk workspace reset-tables\` needs at least one \`--table <guid>\`. Run \`${tablesCommand("workspace")}${contextFlags(args)}\` to see the guids this workspace holds.
+Tables are named by guid rather than by name because a table name may contain anything at all \u2014 a comma, a space, or nothing but digits \u2014 so a name is display-only.`,
+      { helpFor: target }
+    );
+  }
+  const bundleGiven = args.bundle !== void 0 ? "`--bundle`" : args.file !== void 0 && /\.json$/i.test(args.file) ? `\`${args.file}\`` : void 0;
+  if (bundleGiven !== void 0) {
+    throw new UsageError(
+      `\`workspace reset-tables\` needs the entry file, not ${bundleGiven}. Seed rows are resolved from the table definitions at compile time; an exported bundle carries each table's schema but none of its rows, so there would be nothing to reset to.
+Pass the entry file: \`xanosdk workspace reset-tables ./index.ts --table <guid> --write${contextFlags(args)}\`.`
+    );
+  }
+  const willRefuse = args.write === true && args.yes !== true && process.stdin.isTTY !== true;
+  assertEntryFile(args);
+  assertValueFiles(args, target);
+  const auth = await getAccessToken(args);
+  const local = await loadBundleText(args.write === true && !willRefuse ? args : { ...args, lockReadOnly: true }, target, {
+    withSeed: true
+  });
+  const { seedRowsByTableGuid } = await import("./seed-VU7C3QYS.js");
+  const seeds = seedRowsByTableGuid(local.content);
+  const declared = projectTables(local.bundle);
+  const unknown = guids.filter((guid) => !declared.some((t) => t.guid === guid));
+  if (unknown.length > 0) {
+    throw new UsageError(
+      `${local.source} declares no table with guid ${unknown.join(", ")}.
+` + (declared.length === 0 ? `It declares no tables at all.` : `Its tables:
+${declared.map((t) => `  ${t.guid}  ${t.name}${seeds.has(t.guid) ? "  (seeded)" : ""}`).join("\n")}`)
+    );
+  }
+  const unseeded = guids.filter((guid) => !seeds.has(guid));
+  if (unseeded.length > 0) {
+    throw new UsageError(
+      `${unseeded.join(", ")} ${unseeded.length === 1 ? "is" : "are"} not a seeded table in ${local.source}. This command resets a table to the rows the PROJECT declares, so a table the compile carries no \`seed\` for has nothing to reset to \u2014 it would simply be emptied. Add a \`seed\` to the table, or drop it from this command.`
+    );
+  }
+  const withFiles = guids.filter((guid) => seeds.get(guid).some(holdsHostedFile));
+  if (withFiles.length > 0) {
+    const names = withFiles.map((guid) => declared.find((t) => t.guid === guid)?.name ?? guid);
+    throw new UsageError(
+      `${names.join(", ")} ${names.length === 1 ? "seeds" : "seed"} a file column from hostedFile(), which only lands through a deploy that ships the file. Reset ${names.length === 1 ? "it" : "them"} with \`xanosdk deploy\` instead.`
+    );
+  }
+  const tables = await listTables(auth, {
+    workspaceId: auth.workspaceId,
+    binding: bindingFor(auth, auth.workspaceId, false)
+  });
+  if (tables.length === 0) await refuseUnreachableWorkspace(auth);
+  const byGuid = new Map(tables.map((t) => [t.guid, t]));
+  const absent = guids.filter((guid) => !byGuid.has(guid));
+  if (absent.length > 0) {
+    throw new UsageError(
+      `${absent.join(", ")} ${absent.length === 1 ? "is" : "are"} not in this workspace. Run \`${tablesCommand("workspace")}\` to list the guids it holds.`
+    );
+  }
+  const destination = credentialWriteTarget(auth);
+  const { countTableRows } = await import("./table-ENAVMITR.js");
+  const planned = await Promise.all(
+    guids.map(async (guid) => {
+      const table = byGuid.get(guid);
+      const existing = await countTableRows(auth, {
+        workspaceId: auth.workspaceId,
+        tableId: table.id,
+        binding: bindingFor(auth, auth.workspaceId, false)
+      }).catch(() => void 0);
+      return { guid, id: table.id, name: table.name, rows: seeds.get(guid).length, existing: existing ?? null };
+    })
+  );
+  const tableDoc = (t) => ({ guid: t.guid, name: t.name, existingRows: t.existing, seedRows: t.rows });
+  if (args.write !== true) {
+    step(`Would reset ${planned.length} table(s) \u2014 nothing was written`);
+    discloseWriteTarget(destination);
+    for (const t of planned) detail(`${t.name} \u2014 ${existingPhrase(t.existing)} deleted, ${t.rows} seed row(s) from ${local.source} inserted`);
+    blank();
+    detail(`Re-run with \`--write\` to apply. Every other table is left alone.`);
+    if (isMachineOutput(args)) {
+      writeJson({ destination: writeTargetPayload(destination), dryRun: true, tables: planned.map(tableDoc) });
+    }
+    return;
+  }
+  step(`Resetting ${planned.length} table(s) to their seed rows`);
+  discloseWriteTarget(destination);
+  if (args.yes !== true) {
+    const ok = await confirm(
+      `Delete ${planned.map((t) => `${existingPhrase(t.existing)} from "${t.name}"`).join(", ")} and re-seed ${planned.length === 1 ? "it" : "them"} on workspace #${auth.workspaceId}?`,
+      { flag: "--yes", refusal: { details: { dryRun: false, declined: false, tables: [] }, ...yesRerun(args, "workspace reset-tables") } }
+    );
+    if (!ok) {
+      info("Cancelled \u2014 nothing was written.");
+      if (isMachineOutput(args)) {
+        writeJson({ destination: writeTargetPayload(destination), dryRun: false, declined: true, tables: [] });
+      }
+      return;
+    }
+  }
+  const { truncateTable, insertTableRows } = await import("./table-ENAVMITR.js");
+  const done = [];
+  for (const t of planned) {
+    step(`Resetting ${t.name}`);
+    try {
+      await describeWrite(
+        { what: `the emptying of table "${t.name}"` },
+        () => truncateTable(auth, { workspaceId: auth.workspaceId, tableId: t.id })
+      );
+    } catch (err) {
+      error(`"${t.name}" could not be emptied \u2014 its rows were most likely left as they were.`);
+      detail(`Nothing was re-seeded for it. Re-run once the cause is fixed; the rows come from ${local.source}.`);
+      if (done.length > 0) detail(`Already reset: ${done.map((d) => d.name).join(", ")}.`);
+      throw err;
+    }
+    try {
+      await describeWrite(
+        { what: `the re-seed of table "${t.name}"` },
+        () => insertTableRows(auth, {
+          workspaceId: auth.workspaceId,
+          tableId: t.id,
+          rows: seeds.get(t.guid)
+        })
+      );
+    } catch (err) {
+      error(`"${t.name}" was emptied but its seed rows did not land \u2014 it is EMPTY now.`);
+      detail(`Run the same command again to finish it. The rows come from ${local.source}, so nothing is lost.`);
+      if (done.length > 0) detail(`Already reset: ${done.map((d) => d.name).join(", ")}.`);
+      throw err;
+    }
+    done.push(t);
+  }
+  success(`Reset ${done.length} table(s) to their seed rows`);
+  for (const t of done) detail(`${t.name} \u2014 ${existingPhrase(t.existing)} deleted, ${t.rows} seed row(s) inserted`);
+  detail(`Every other table in this workspace was left alone.`);
+  if (isMachineOutput(args)) {
+    writeJson({ destination: writeTargetPayload(destination), dryRun: false, tables: done.map(tableDoc) });
+  }
+}
+function existingPhrase(existing) {
+  return existing === null ? "its existing rows (count unreadable)" : `${existing} existing row${existing === 1 ? "" : "s"}`;
+}
+function holdsHostedFile(row) {
+  const hosted = (v) => typeof v === "object" && v !== null && typeof v.path === "string" && v.path.startsWith(HOSTED_ROW_PATH_PREFIX);
+  return Object.values(row).some((v) => Array.isArray(v) ? v.some(hosted) : hosted(v));
+}
+export {
+  EXIT_DIFF_MISMATCH,
+  runWorkspaceCommand
+};
+//# sourceMappingURL=workspace-command-JEXQETJD.js.map