@xanots/sdk 0.0.5 → 0.0.6

package/dist/{release-command-FKQ6E3TD.js → release-command-V4K4IORX.js}

@@ -1,14 +1,27 @@
 import {
+  assertBranchTargetHonored,
   importWorkspaceArchive,
   planWorkspaceImport
-} from "./chunk-5WGEURVI.js";
+} from "./chunk-6AAT2AYQ.js";
 import {
   assertBundleInput,
   loadBundleText
-} from "./chunk-QA5ICJ4M.js";
+} from "./chunk-QVSUMHNN.js";
+import {
+  sharedSchemaChanges
+} from "./chunk-5HCDZ2XN.js";
+import {
+  assertBranchAbsent,
+  assertUsableBranchLabel,
+  createBranch,
+  listBranches,
+  liveBranchLabel,
+  setLiveBranch
+} from "./chunk-EQW3YT5U.js";
+import "./chunk-ZOYMZZ3S.js";
 import {
   confirm
-} from "./chunk-PGBK64U5.js";
+} from "./chunk-4PTSTDIG.js";
 import {
   getAccessToken
 } from "./chunk-SG4UBJ47.js";
@@ -24,14 +37,14 @@ import {
 import "./chunk-3IGNIP6R.js";
 import {
   resolveLockPath
-} from "./chunk-MS3BRZAZ.js";
+} from "./chunk-SOCYCBYG.js";
 import {
   UsageError,
   assertWritableDest
-} from "./chunk-IVP6TS26.js";
+} from "./chunk-JQLR64UC.js";
 import {
   readLockFile
-} from "./chunk-MFIHIS6B.js";
+} from "./chunk-OLQLJY5T.js";
 import "./chunk-GNPVYOPB.js";
 import {
   blank,
@@ -42,22 +55,57 @@ import {
   success,
   warn
 } from "./chunk-EZG76F7R.js";
-import "./chunk-BPEEGJJA.js";
-import "./chunk-F5T45NAM.js";
-import "./chunk-YUPQOLFX.js";
+import "./chunk-3FQD3QME.js";
+import "./chunk-OKNSR7MT.js";
+import "./chunk-CQBJNFDK.js";
 import "./chunk-WHOJWOSV.js";
 import "./chunk-5XZ744TS.js";
 import {
   REFERENCEABLE_KIND_PAYLOAD_KEYS,
   lockKey
-} from "./chunk-YUBJLB6G.js";
+} from "./chunk-EFH4NFPY.js";
 
 // src/emit/release-command.ts
 import { existsSync } from "fs";
 var DESTRUCTIVE_ACTIONS = /* @__PURE__ */ new Set(["delete", "truncate", "drop"]);
 var IDENTITY_EXEMPT_TYPES = /* @__PURE__ */ new Set(["workspace"]);
+var BRANCH_INCOMPATIBLE = [
+  {
+    flag: "--replace",
+    why: "a replace wipes the whole workspace, which is not something a branch can scope"
+  },
+  {
+    flag: "--backup-branch",
+    why: "a branch release does not overwrite the live branch, so there is nothing for a backup to protect"
+  }
+];
 function resolveRequest(args) {
+  if (args.branch !== void 0) {
+    assertUsableBranchLabel(args.branch, "--branch");
+    const conflicting = BRANCH_INCOMPATIBLE.filter(
+      ({ flag }) => flag === "--replace" ? args.replace : args.backupBranch !== void 0
+    );
+    if (conflicting.length > 0) {
+      const { flag, why } = conflicting[0];
+      throw new UsageError(
+        `\`--branch\` cannot be combined with \`${flag}\`: ${why}.
+Drop \`${flag}\` to stage this release on "${args.branch}", or drop \`--branch\` to release to the live branch.`,
+        { helpFor: { command: "release" } }
+      );
+    }
+  } else if (args.setLive) {
+    throw new UsageError(
+      "`--set-live` promotes the branch a release just landed on, and this release names no branch.\nAdd `--branch <label>` to stage the release and promote it, or use `xanots workspace branch set-live <label>` to promote a branch that already exists.",
+      { helpFor: { command: "release" } }
+    );
+  }
   if (args.replace) {
+    if (args.backupBranch !== void 0) {
+      throw new UsageError(
+        "`--replace` cannot be combined with `--backup-branch`: a replace deletes the workspace's non-live branches, so it would destroy the snapshot along with everything else and leave you with a rollback target that does not exist.\nDrop `--replace` to merge (which a backup CAN protect), or take a workspace export first with `xanots workspace export`.",
+        { helpFor: { command: "release" } }
+      );
+    }
     const conflicting = [
       args.prune ? "--prune" : "",
       args.resetData ? "--reset-data" : "",
@@ -75,9 +123,14 @@ function resolveRequest(args) {
     mode: "merge",
     prune: args.prune,
     records: args.seed,
-    truncate: args.resetData
+    truncate: args.resetData,
+    ...args.branch !== void 0 ? { branch: args.branch } : {}
   };
 }
+function derivedBackupLabel(now) {
+  const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+  return `backup-${stamp}`;
+}
 function isDestructive(req) {
   return req.mode === "replace" || req.prune === true || req.truncate === true || req.records === true;
 }
@@ -153,8 +206,8 @@ async function reconcileLockAfterReplace(args, auth, workspaceId) {
     return;
   }
   try {
-    const { adoptFromBundle } = await import("./lock-KXOJIGCG.js");
-    const { readLockFile: readLockFile2, writeLockFile } = await import("./io-7VIA5SON.js");
+    const { adoptFromBundle } = await import("./lock-PDFCNYUW.js");
+    const { readLockFile: readLockFile2, writeLockFile } = await import("./io-65CJNLYI.js");
     const { lock, added, changed } = adoptFromBundle(readLockFile2(lockPath), live, lockPath);
     writeLockFile(lockPath, lock);
     const touched = added.length + changed.length;
@@ -192,7 +245,7 @@ function targetIsEmpty(live) {
 async function convergedWithLive(live, req, outgoingBundle) {
   if (live === void 0 || req.mode !== "merge") return false;
   if (req.records === true || req.truncate === true) return false;
-  const { compareToLive } = await import("./live-diff-FP4SFNT4.js");
+  const { compareToLive } = await import("./live-diff-QK4KC2FJ.js");
   let result;
   try {
     result = compareToLive(JSON.parse(outgoingBundle), live);
@@ -209,7 +262,7 @@ async function warnAboutLiveLosses(live, req, outgoingBundle) {
     warn("Could not read the target workspace, so this plan does not account for dropped columns or env that will not update.");
     return { droppedColumns: 0, unchangedEnv: [] };
   }
-  const { diffAgainstLive } = await import("./live-diff-FP4SFNT4.js");
+  const { diffAgainstLive } = await import("./live-diff-QK4KC2FJ.js");
   let diff;
   try {
     diff = diffAgainstLive(JSON.parse(outgoingBundle), live, { mode: req.mode });
@@ -327,6 +380,46 @@ function renderPlan(plan, req, workspaceId, targetIsEmpty2, converged = false) {
   warnOnZeroCorrespondence(plan, req, targetIsEmpty2);
   blank();
 }
+function assertSharedSchemaAcknowledged(args, live, bundle, branch) {
+  const changes = sharedSchemaChanges(JSON.parse(bundle), live, { prune: args.prune });
+  if (changes === void 0) {
+    if (args.allowSharedSchemaChanges) return void 0;
+    throw new UsageError(
+      `Refusing to release to branch "${branch}": the live workspace could not be read, so whether this release changes shared schema is unknown.
+Tables and microservices are shared by every branch, so a schema change reaches production even on a branch release. A failed read is not evidence that there is none.
+Retry when the instance is reachable, or pass \`--allow-shared-schema-changes\` to proceed without the check.`,
+      { helpFor: { command: "release" } }
+    );
+  }
+  if (changes.length === 0 || args.allowSharedSchemaChanges) return changes;
+  const lines = changes.map((c) => {
+    const detailText = c.details === void 0 || c.details.length === 0 ? "" : ` \u2014 ${c.details.join(", ")}`;
+    return `  ${c.action} ${c.kind === "dbo" ? "table" : "microservice"} "${c.name}"${detailText}`;
+  });
+  throw new UsageError(
+    `\`--branch ${branch}\` cannot stage ${changes.length} change${changes.length === 1 ? "" : "s"} to this workspace's SHARED schema:
+${lines.join("\n")}
+
+Tables and microservices carry no branch in Xano \u2014 one set is shared by every branch. These would be applied to the LIVE workspace by the same import that stages your logic on "${branch}", and the plan would report them as routine.
+Release without \`--branch\` if applying them is what you want, take them out of this release, or pass \`--allow-shared-schema-changes\` to stage the logic and apply the schema knowing both happen.`,
+    { helpFor: { command: "release" } }
+  );
+}
+function reportBranchCaveats(branch, setLive, changed) {
+  blank();
+  if (changed === void 0) {
+    warn("The live workspace could not be read, so whether this changed shared schema is UNKNOWN.");
+    detail("Tables and microservices are shared by every branch \u2014 a change there reached production.");
+  } else if (changed > 0) {
+    warn(`${changed} shared-schema change${changed === 1 ? "" : "s"} were applied to the LIVE workspace.`);
+    detail("Tables and microservices are shared by every branch \u2014 only your logic is staged.");
+  } else {
+    detail(`Only logic was staged on "${branch}" \u2014 this release changed no shared schema.`);
+  }
+  if (!setLive) {
+    detail(`Nothing serves "${branch}" yet. Promote it with \`xanots workspace branch set-live ${branch}\`.`);
+  }
+}
 async function runReleaseCommand(args) {
   assertWritableDest(args.dest, "release");
   const req = resolveRequest(args);
@@ -338,7 +431,7 @@ async function runReleaseCommand(args) {
     { withSeed: req.records === true }
   );
   if (args.static !== void 0) {
-    const { assertNoSeedLeaks } = await import("./deploy-command-XOH76USO.js");
+    const { assertNoSeedLeaks } = await import("./deploy-command-MTQQXPOO.js");
     await assertNoSeedLeaks(args.static, nonPublicSeedValues, args.allowSeedInStatic);
   }
   const workspaceId = auth.workspaceId;
@@ -347,21 +440,27 @@ async function runReleaseCommand(args) {
     warn("`--seed` was passed, but no table in this project declares seed rows \u2014 no rows will be written.");
   }
   const target = { baseUrl: auth.instance, archive, workspaceId, ...req };
+  const branches = req.branch !== void 0 || args.backupBranch !== void 0 ? await listBranches(auth, { baseUrl: auth.instance, workspaceId }) : [];
+  if (req.branch !== void 0) assertBranchAbsent(branches, req.branch);
   step(
-    `Releasing ${source} \u2192 instance workspace #${workspaceId}` + (req.mode === "replace" ? " (full replace)" : " (merge)")
+    `Releasing ${source} \u2192 instance workspace #${workspaceId}` + (req.branch !== void 0 ? ` branch "${req.branch}"` : "") + (req.mode === "replace" ? " (full replace)" : " (merge)")
   );
   const plan = await planWorkspaceImport(auth, target);
+  if (req.branch !== void 0) assertBranchTargetHonored(plan, req.branch, auth.instance);
   const live = await readLiveWorkspace(auth, workspaceId);
   const converged = await convergedWithLive(live, req, bundle);
   renderPlan(plan, req, workspaceId, targetIsEmpty(live), converged);
   const losses = await warnAboutLiveLosses(live, req, bundle);
+  const sharedChanges = req.branch === void 0 ? [] : assertSharedSchemaAcknowledged(args, live, bundle, req.branch);
   if (req.prune === true) assertPruneStaysInScope(args, plan);
   if (args.dryRun) {
     info("Dry run \u2014 nothing was sent.");
     if (isMachineOutput(args)) writeJson({ released: false, dryRun: true, workspaceId, plan });
     return;
   }
-  const upToDate = plan.operations.length === 0 || converged;
+  let backupLabel;
+  let promoted = args.setLive;
+  const upToDate = req.branch === void 0 && (plan.operations.length === 0 || converged);
   if (upToDate) {
     success(`Workspace #${workspaceId} is already up to date \u2014 no import sent.`);
   } else {
@@ -375,8 +474,72 @@ async function runReleaseCommand(args) {
         return;
       }
     }
-    await importWorkspaceArchive(auth, target);
-    success(`Released to instance workspace #${workspaceId}`);
+    if (args.backupBranch !== void 0) {
+      const sourceLabel = liveBranchLabel(branches);
+      const label = typeof args.backupBranch === "string" ? args.backupBranch : derivedBackupLabel(/* @__PURE__ */ new Date());
+      assertUsableBranchLabel(label, "--backup-branch");
+      assertBranchAbsent(branches, label);
+      step(`Snapshotting the live branch as "${label}" before importing\u2026`);
+      try {
+        await createBranch(auth, {
+          baseUrl: auth.instance,
+          workspaceId,
+          label,
+          ...sourceLabel !== void 0 ? { sourceBranch: sourceLabel } : {},
+          description: `Pre-release snapshot taken by xanots from ${source}`
+        });
+      } catch (err) {
+        throw new Error(
+          `The pre-release backup branch could not be created, so the release was not sent.
+Nothing has changed in workspace #${workspaceId}.
+Retry, or drop \`--backup-branch\` to release without one.`,
+          { cause: err }
+        );
+      }
+      backupLabel = label;
+      success(`Live branch snapshotted as "${label}".`);
+    }
+    try {
+      await importWorkspaceArchive(auth, target);
+    } catch (err) {
+      if (backupLabel !== void 0) {
+        blank();
+        warn(`The import failed. Your pre-release snapshot is on branch "${backupLabel}".`);
+        detail(`Restore it with \`xanots workspace branch set-live ${backupLabel}\`.`);
+      }
+      throw err;
+    }
+    success(
+      req.branch !== void 0 ? `Released to workspace #${workspaceId} on branch "${req.branch}"` : `Released to instance workspace #${workspaceId}`
+    );
+    if (req.branch !== void 0) {
+      if (args.setLive) {
+        const previous = liveBranchLabel(branches);
+        blank();
+        warn(`Promoting "${req.branch}" is a production cutover for workspace #${workspaceId}.`);
+        if (previous !== void 0) {
+          detail(`The runtime stops serving "${previous}" and starts serving "${req.branch}".`);
+        }
+        if (!args.yes && !args.force && !await confirm(`Make "${req.branch}" the live branch?`, {
+          flag: "--yes",
+          helpFor: { command: "release" }
+        })) {
+          info(`Cancelled the promote \u2014 the release is staged on "${req.branch}" and nothing serves it yet.`);
+          detail(`Promote it later with \`xanots workspace branch set-live ${req.branch}\`.`);
+          promoted = false;
+        } else {
+          await setLiveBranch(auth, { baseUrl: auth.instance, workspaceId, label: req.branch });
+          success(`Branch "${req.branch}" is now live.`);
+          if (previous !== void 0) {
+            detail(`Roll back with \`xanots workspace branch set-live ${previous}\`.`);
+          }
+        }
+      }
+      reportBranchCaveats(req.branch, promoted, sharedChanges?.length);
+    } else if (backupLabel !== void 0) {
+      blank();
+      detail(`Roll back this release with \`xanots workspace branch set-live ${backupLabel}\`.`);
+    }
     if (req.mode === "replace") await reconcileLockAfterReplace(args, auth, workspaceId);
   }
   link(auth.instance);
@@ -402,10 +565,15 @@ async function runReleaseCommand(args) {
     // beside `upToDate: true` would contradict it.
     operations: upToDate ? 0 : plan.operations.length,
     droppedColumns: losses.droppedColumns,
-    unchangedEnv: losses.unchangedEnv
+    unchangedEnv: losses.unchangedEnv,
+    // Present only when they mean something: a plain release carries no branch
+    // fields at all, so a wrapper reading `branch` cannot mistake "released to
+    // live" for "released to a branch named undefined".
+    ...req.branch !== void 0 ? { branch: req.branch, setLive: promoted, sharedSchemaChanges: sharedChanges?.length } : {},
+    ...backupLabel !== void 0 ? { backupBranch: backupLabel } : {}
   };
   if (args.static !== void 0) {
-    const { buildStaticEnv, deployStaticTo } = await import("./deploy-command-XOH76USO.js");
+    const { buildStaticEnv, deployStaticTo } = await import("./deploy-command-MTQQXPOO.js");
     const env = buildStaticEnv(auth.instance, args.staticEnv);
     const explicit = Object.keys(args.staticEnv).length > 0;
     summary.static = await deployStaticTo(
@@ -424,4 +592,4 @@ async function runReleaseCommand(args) {
 export {
   runReleaseCommand
 };
-//# sourceMappingURL=release-command-FKQ6E3TD.js.map
+//# sourceMappingURL=release-command-V4K4IORX.js.map

package/dist/scaffold.d.ts

@@ -1319,8 +1319,7 @@ declare function iconLibraryOf(id: IconLibraryId | undefined): IconLibrary;
  * light/dark token map under a schema, so it lands as a {@link Theme} too.
  *
  * Browser-safe: pure string building and arithmetic, no node:* imports. The
- * flag parsing that reads a URL and the prompt that reads a TTY live in
- * `theme-resolve.ts`, mirroring the `frontend-presets` / `frontend-resolve`
+ * flag parsing that reads a URL lives in `theme-resolve.ts`, mirroring the `frontend-presets` / `frontend-resolve`
  * split.
  */
 
@@ -1357,7 +1356,7 @@ declare const DEFAULT_DARK_MODE: DarkMode;
 interface Theme {
     /** Stable id — `neutral`, `zinc-blue`, or an imported item's registry name. */
     readonly id: string;
-    /** Human label for prose and the interactive prompt, e.g. `Zinc Blue`. */
+    /** Human label for prose and any theme picker, e.g. `Zinc Blue`. */
     readonly label: string;
     /**
      * The base color this theme was built from, for `components.json`'s
@@ -1493,15 +1492,13 @@ declare function isAccent(id: string): id is AccentId;
 /** Validate a `--dark` value, mirroring the other scaffold flags' hard errors. */
 declare function resolveDarkModeFlag(raw: string): DarkMode;
 /**
- * The interactive menu: a short, opinionated list rather than all 126
- * combinations.
+ * The shortlist: a short, opinionated set for anyone offering a theme picker
+ * over this module, rather than all 126 combinations.
  *
- * A prompt is for someone who wants to not think about this. The full space
- * stays reachable — the prompt accepts any `<base>-<accent>` or URL typed in
- * place of a number, and `--theme` accepts the same — so this list is a
- * shortcut, not the supported set. One entry per base color, each paired with
- * an accent that suits its temperature, keeps the menu one screen tall while
- * still showing what every base looks like.
+ * The full space stays reachable — `--theme` takes any `<base>-<accent>` or
+ * registry URL — so this list is a shortcut, not the supported set. One entry
+ * per base color, each paired with an accent that suits its temperature, shows
+ * what every base looks like in one screen.
  */
 declare const CURATED_THEMES: readonly string[];
 /** {@link CURATED_THEMES}, resolved. Throws at import time if an id ever rots. */
@@ -1574,14 +1571,14 @@ declare function colorTokens(vars: Readonly<Record<string, string>>): string[];
  *   is a second source of truth for one boolean.
  */
 declare function themeGuidanceSection(choice: ThemeChoice): string;
-/** An sRGB triple, 0–255, for painting a swatch in the interactive prompt. */
+/** An sRGB triple, 0–255, for painting a theme swatch. */
 interface Rgb {
     readonly r: number;
     readonly g: number;
     readonly b: number;
 }
 /**
- * The colors that identify a theme at a glance in the prompt: the primary, the
+ * The colors that identify a theme at a glance in a picker: the primary, the
  * page background, and a muted midtone.
  *
  * Three is the smallest set that distinguishes the menu's entries — the accent

package/dist/scaffold.js

@@ -4,10 +4,10 @@ import {
   allFrontendPresets,
   findFrontendPreset,
   resolveFrameworkFlag
-} from "./chunk-WGDAOOXG.js";
+} from "./chunk-MU3O43L2.js";
 import {
   renderIndexCss
-} from "./chunk-QUUB7HYK.js";
+} from "./chunk-P5C2YKAM.js";
 import {
   ACCENTS,
   ACCENT_TOKENS,
@@ -50,7 +50,7 @@ import {
   themeGuidanceSection,
   themeSwatch,
   withRadius
-} from "./chunk-6DHJVLYP.js";
+} from "./chunk-Q77KNEUL.js";
 export {
   ACCENTS,
   ACCENT_TOKENS,

package/dist/{test-command-56IAEYHX.js → test-command-OEBIGOPP.js}

@@ -1,6 +1,6 @@
 import {
   resolveMetaTarget
-} from "./chunk-APOR6TCV.js";
+} from "./chunk-CEFYM6N5.js";
 import "./chunk-WJYB7DSI.js";
 import "./chunk-OR43PDCW.js";
 import "./chunk-NDZFBZHC.js";
@@ -19,7 +19,7 @@ import {
 } from "./chunk-3IGNIP6R.js";
 import {
   unknownSubcommand
-} from "./chunk-IVP6TS26.js";
+} from "./chunk-JQLR64UC.js";
 import "./chunk-GNPVYOPB.js";
 import {
   blank,
@@ -29,7 +29,7 @@ import {
   success,
   warn
 } from "./chunk-EZG76F7R.js";
-import "./chunk-F5T45NAM.js";
+import "./chunk-OKNSR7MT.js";
 
 // src/deploy/tests.ts
 var TIMEOUT_MS = 12e4;
@@ -380,4 +380,4 @@ export {
   runSuite,
   runTestCommand
 };
-//# sourceMappingURL=test-command-56IAEYHX.js.map
+//# sourceMappingURL=test-command-OEBIGOPP.js.map

package/dist/{upgrade-command-M2DZ3ZPD.js → upgrade-command-52AAZ3NV.js}

@@ -7,25 +7,25 @@ import {
 } from "./chunk-NUQCEOKA.js";
 import {
   refreshAgentFiles
-} from "./chunk-D6OGU2AI.js";
-import "./chunk-7SISR3CS.js";
+} from "./chunk-P5OAM3G2.js";
+import "./chunk-2SUCC4DV.js";
 import {
   runNpm
 } from "./chunk-ZSYZTGJH.js";
 import {
   sdkDep
-} from "./chunk-QUUB7HYK.js";
-import "./chunk-6DHJVLYP.js";
+} from "./chunk-P5C2YKAM.js";
+import "./chunk-Q77KNEUL.js";
 import {
   checkForUpgrade,
   detectInstallMode,
   registryUrl,
   suppressUpdateNotice,
   upgradeCommand
-} from "./chunk-ZGA5MUNC.js";
-import "./chunk-MS3BRZAZ.js";
-import "./chunk-IVP6TS26.js";
-import "./chunk-MFIHIS6B.js";
+} from "./chunk-Y7BARS25.js";
+import "./chunk-SOCYCBYG.js";
+import "./chunk-JQLR64UC.js";
+import "./chunk-OLQLJY5T.js";
 import "./chunk-GNPVYOPB.js";
 import {
   blank,
@@ -35,12 +35,12 @@ import {
   success,
   warn
 } from "./chunk-EZG76F7R.js";
-import "./chunk-BPEEGJJA.js";
-import "./chunk-F5T45NAM.js";
-import "./chunk-YUPQOLFX.js";
+import "./chunk-3FQD3QME.js";
+import "./chunk-OKNSR7MT.js";
+import "./chunk-CQBJNFDK.js";
 import "./chunk-WHOJWOSV.js";
 import "./chunk-5XZ744TS.js";
-import "./chunk-YUBJLB6G.js";
+import "./chunk-EFH4NFPY.js";
 
 // src/emit/upgrade-command.ts
 import { readFileSync, writeFileSync } from "fs";
@@ -174,4 +174,4 @@ function messageOf(err) {
 export {
   runUpgradeCommand
 };
-//# sourceMappingURL=upgrade-command-M2DZ3ZPD.js.map
+//# sourceMappingURL=upgrade-command-52AAZ3NV.js.map

package/dist/{validate-command-CIBQJND7.js → validate-command-KTLPSSH7.js}

@@ -1,10 +1,10 @@
 import {
   assertBundleInput,
   loadBundleText
-} from "./chunk-QA5ICJ4M.js";
-import "./chunk-MS3BRZAZ.js";
-import "./chunk-IVP6TS26.js";
-import "./chunk-MFIHIS6B.js";
+} from "./chunk-QVSUMHNN.js";
+import "./chunk-SOCYCBYG.js";
+import "./chunk-JQLR64UC.js";
+import "./chunk-OLQLJY5T.js";
 import "./chunk-GNPVYOPB.js";
 import {
   blank,
@@ -14,19 +14,19 @@ import {
   success,
   warn
 } from "./chunk-EZG76F7R.js";
-import "./chunk-BPEEGJJA.js";
-import "./chunk-F5T45NAM.js";
-import "./chunk-YUPQOLFX.js";
+import "./chunk-3FQD3QME.js";
+import "./chunk-OKNSR7MT.js";
+import "./chunk-CQBJNFDK.js";
 import "./chunk-WHOJWOSV.js";
 import "./chunk-5XZ744TS.js";
-import "./chunk-YUBJLB6G.js";
+import "./chunk-EFH4NFPY.js";
 
 // src/emit/validate-command.ts
 var EXIT_VALIDATION_FAILED = 2;
 async function runValidateCommand(args) {
   assertBundleInput(args, { command: "validate" });
   const { resolveValidateConfig, verifyToken } = await import("./config-NL33PN4D.js");
-  const { MetaClient } = await import("./meta-client-OW5WKWW7.js");
+  const { MetaClient } = await import("./meta-client-57ZWVHST.js");
   const config = resolveValidateConfig({ instance: args.instance });
   const who = await verifyToken(config);
   const host = new URL(config.instance).host;
@@ -119,4 +119,4 @@ function fmt(v) {
 export {
   runValidateCommand
 };
-//# sourceMappingURL=validate-command-CIBQJND7.js.map
+//# sourceMappingURL=validate-command-KTLPSSH7.js.map

package/dist/{workspace-command-HZS43PHJ.js → workspace-command-LX5S5N2H.js}

@@ -1,7 +1,7 @@
 import {
   fetchWorkspaceBundle,
   runCodegenCommand
-} from "./chunk-OARSPAIE.js";
+} from "./chunk-TYBB7ON3.js";
 import "./chunk-ZOYMZZ3S.js";
 import {
   resolveOutputTarget
@@ -19,30 +19,30 @@ import "./chunk-LLWK6H77.js";
 import "./chunk-QTNO2WD6.js";
 import "./chunk-ZUTSMMAG.js";
 import "./chunk-X4DVXBFY.js";
-import "./chunk-KXCPZUUM.js";
+import "./chunk-4HDOP7LH.js";
 import {
   isMachineOutput,
   writeJson
 } from "./chunk-NUQCEOKA.js";
-import "./chunk-7SISR3CS.js";
+import "./chunk-2SUCC4DV.js";
 import "./chunk-ZSYZTGJH.js";
 import {
   fetchOrExplain,
   httpFailure
 } from "./chunk-3IGNIP6R.js";
-import "./chunk-PXXLBXOP.js";
+import "./chunk-JRGDLAEA.js";
 import "./chunk-LU7TRWMC.js";
-import "./chunk-WGDAOOXG.js";
-import "./chunk-QUUB7HYK.js";
-import "./chunk-6DHJVLYP.js";
+import "./chunk-MU3O43L2.js";
+import "./chunk-P5C2YKAM.js";
+import "./chunk-Q77KNEUL.js";
 import "./chunk-4BXJGVZ3.js";
-import "./chunk-CYJ7R3AD.js";
-import "./chunk-MS3BRZAZ.js";
+import "./chunk-GC7ZQHW7.js";
+import "./chunk-SOCYCBYG.js";
 import {
   removedSubcommand,
   unknownSubcommand
-} from "./chunk-IVP6TS26.js";
-import "./chunk-MFIHIS6B.js";
+} from "./chunk-JQLR64UC.js";
+import "./chunk-OLQLJY5T.js";
 import "./chunk-GNPVYOPB.js";
 import {
   formatFields,
@@ -50,12 +50,12 @@ import {
   step,
   success
 } from "./chunk-EZG76F7R.js";
-import "./chunk-BPEEGJJA.js";
-import "./chunk-F5T45NAM.js";
-import "./chunk-YUPQOLFX.js";
+import "./chunk-3FQD3QME.js";
+import "./chunk-OKNSR7MT.js";
+import "./chunk-CQBJNFDK.js";
 import "./chunk-WHOJWOSV.js";
 import "./chunk-5XZ744TS.js";
-import "./chunk-YUBJLB6G.js";
+import "./chunk-EFH4NFPY.js";
 
 // src/emit/workspace-command.ts
 import { writeFileSync } from "fs";
@@ -69,6 +69,10 @@ async function runWorkspaceCommand(args) {
       return runExport(args);
     case "codegen":
       return runCodegenCommand(args, { kind: "workspace" });
+    case "branch": {
+      const { runBranchCommand } = await import("./branch-commands-R4FR75UW.js");
+      return runBranchCommand(args);
+    }
     case "deploy":
       throw removedSubcommand("workspace", "deploy");
     default:
@@ -156,4 +160,4 @@ async function runExport(args) {
 export {
   runWorkspaceCommand
 };
-//# sourceMappingURL=workspace-command-HZS43PHJ.js.map
+//# sourceMappingURL=workspace-command-LX5S5N2H.js.map

package/guides/scaffold.md

@@ -12,8 +12,9 @@ What `xanots init` writes, the two frontend presets, theming, add-ons, and the S
 `--marketplace <pkg>` (repeatable, comma-separated; installs add-ons and
 registers them — below), `--force` (scaffold into a non-empty folder),
 `--no-install` (skip `npm install`).
-In a terminal, `init` prompts for the framework, the theme, and the AI files;
-every prompt has a default, so pressing enter three times is a valid answer.
+In a terminal, `init` prompts for the framework and the AI files; every prompt
+has a default, so pressing enter twice is a valid answer. The look is never
+prompted for — it comes from the flags above, or from `xanots onboard`.
 The starter backend is empty but already compiles and deploys — grow it from the
 walkthrough in `xano/EXAMPLE.md`.
 

package/llms/statements-calls.md

@@ -13,7 +13,7 @@ Auth & calls:
 - `s.stream.from_request({ url, method?, …tls, as? })` — streaming external HTTP request (`mvp:streaming_api_request`); same typed field surface as `s.api.request` (no description/output envelope). `url` is REQUIRED — it shares `api.request`'s engine declaration, which has no default.
 - `s.webflow.request({ path, method?, …tls, as? })` — Webflow API request (`mvp:connect_webflow_api_request`); like `s.api.request` but addressed by `path` (host is engine-supplied), and `path` is REQUIRED — the engine rejects an empty one. No `headers`: the engine builds its own from the workspace's Webflow connection and ignores an authored value.
 - `s.task.call` / `s.tool.call` / `s.trigger.call` / `s.middleware.call` / `s.addon.call` — same `{ <target>, input?, as? }` shape against the named kind. `s.task.call` and `s.trigger.call` are WORKFLOW-TEST ONLY (see Gotchas in `llms.txt`); `s.tool.call`, `s.middleware.call` and `s.addon.call` run from any stack.
-- `s.action.call({ action, package?, input?, as? })` / `s.action.package.call(…)` — invoke a marketplace action; `package` is its slug.
+- `s.action.call({ actionId, input?, registry?, as? })` / `s.action.package.call({ traceId, versionId, slug, input?, registry?, as? })` — invoke an installed action. Ids are SUPPLIED, never derived from a name: an action is installed onto the instance, so its identity is assigned at install and differs per instance — read them off a call in a pulled workspace. The package form needs all three parts; they are one composite and two of them address nothing. `registry` is the action's own settings, `input` the per-call arguments.
 - `s.cloud.job({ image, command, args?, secret?, template?, await?, as? })` — launch a containerized job. `image`/`command` are REQUIRED; omitted → `Missing param`. ⚠ `await` is SECONDS (default 60), not a boolean.
 - `s.cloud.job.status({ id, as? })` · `s.cloud.job.await({ ids, timeout, as? })` — poll one job, or block on several (`ids` a list `Value`, `timeout` in seconds; both required).