superslate 0.2.1 → 0.4.0

package/dist/cli.js

@@ -1,15 +1,1691 @@
 #!/usr/bin/env node
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// node_modules/sisteransi/src/index.js
+var require_src = __commonJS((exports, module) => {
+  var ESC2 = "\x1B";
+  var CSI2 = `${ESC2}[`;
+  var beep = "\x07";
+  var cursor = {
+    to(x, y) {
+      if (!y)
+        return `${CSI2}${x + 1}G`;
+      return `${CSI2}${y + 1};${x + 1}H`;
+    },
+    move(x, y) {
+      let ret = "";
+      if (x < 0)
+        ret += `${CSI2}${-x}D`;
+      else if (x > 0)
+        ret += `${CSI2}${x}C`;
+      if (y < 0)
+        ret += `${CSI2}${-y}A`;
+      else if (y > 0)
+        ret += `${CSI2}${y}B`;
+      return ret;
+    },
+    up: (count = 1) => `${CSI2}${count}A`,
+    down: (count = 1) => `${CSI2}${count}B`,
+    forward: (count = 1) => `${CSI2}${count}C`,
+    backward: (count = 1) => `${CSI2}${count}D`,
+    nextLine: (count = 1) => `${CSI2}E`.repeat(count),
+    prevLine: (count = 1) => `${CSI2}F`.repeat(count),
+    left: `${CSI2}G`,
+    hide: `${CSI2}?25l`,
+    show: `${CSI2}?25h`,
+    save: `${ESC2}7`,
+    restore: `${ESC2}8`
+  };
+  var scroll = {
+    up: (count = 1) => `${CSI2}S`.repeat(count),
+    down: (count = 1) => `${CSI2}T`.repeat(count)
+  };
+  var erase = {
+    screen: `${CSI2}2J`,
+    up: (count = 1) => `${CSI2}1J`.repeat(count),
+    down: (count = 1) => `${CSI2}J`.repeat(count),
+    line: `${CSI2}2K`,
+    lineEnd: `${CSI2}K`,
+    lineStart: `${CSI2}1K`,
+    lines(count) {
+      let clear = "";
+      for (let i = 0;i < count; i++)
+        clear += this.line + (i < count - 1 ? cursor.up() : "");
+      if (count)
+        clear += cursor.left;
+      return clear;
+    }
+  };
+  module.exports = { cursor, scroll, erase, beep };
+});
+
+// node_modules/@clack/core/dist/index.mjs
+import { styleText } from "node:util";
+import { stdout, stdin } from "node:process";
+import * as l from "node:readline";
+import l__default from "node:readline";
+
+// node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = (() => {
+  const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  return (input) => {
+    let surrogatePairsNr = 0;
+    SURROGATE_PAIR_RE.lastIndex = 0;
+    while (SURROGATE_PAIR_RE.test(input)) {
+      surrogatePairsNr += 1;
+    }
+    return input.length - surrogatePairsNr;
+  };
+})();
+var isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x) => {
+  return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+// node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/yu;
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = /\p{M}+/gu;
+var NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+  const PARSE_BLOCKS = [
+    [LATIN_RE, REGULAR_WIDTH],
+    [ANSI_RE, ANSI_WIDTH],
+    [CONTROL_RE, CONTROL_WIDTH],
+    [TAB_RE, TAB_WIDTH],
+    [EMOJI_RE, EMOJI_WIDTH],
+    [CJKT_WIDE_RE, WIDE_WIDTH]
+  ];
+  let indexPrev = 0;
+  let index = 0;
+  let length = input.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
+  let widthExtra = 0;
+  outer:
+    while (true) {
+      if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+        const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+        lengthExtra = 0;
+        for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+          const codePoint = char.codePointAt(0) || 0;
+          if (isFullWidth(codePoint)) {
+            widthExtra = FULL_WIDTH_WIDTH;
+          } else if (isWideNotCJKTNotEmoji(codePoint)) {
+            widthExtra = WIDE_WIDTH;
+          } else {
+            widthExtra = REGULAR_WIDTH;
+          }
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          lengthExtra += char.length;
+          width += widthExtra;
+        }
+        unmatchedStart = unmatchedEnd = 0;
+      }
+      if (index >= length) {
+        break outer;
+      }
+      for (let i = 0, l = PARSE_BLOCKS.length;i < l; i++) {
+        const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+        BLOCK_RE.lastIndex = index;
+        if (BLOCK_RE.test(input)) {
+          lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+          widthExtra = lengthExtra * BLOCK_WIDTH;
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          width += widthExtra;
+          unmatchedStart = indexPrev;
+          unmatchedEnd = index;
+          index = indexPrev = BLOCK_RE.lastIndex;
+          continue outer;
+        }
+      }
+      index += 1;
+    }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+};
+var dist_default = getStringTruncatedWidth;
+
+// node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+  return dist_default(input, NO_TRUNCATION2, options).width;
+};
+var dist_default2 = fastStringWidth;
+
+// node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "›";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return;
+};
+var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible = lastRow === undefined ? 0 : dist_default2(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default2(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible += characterLength;
+      if (visible === columns && !nextCharacter.done) {
+        rows.push("");
+        visible = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows.at(-1);
+  if (!visible && lastRow !== undefined && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default2(words[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index = 0;index < words.length; index++) {
+    const word = words[index];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default2(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    const wordLength = dist_default2(word);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default2(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join(`
+`);
+  let inSurrogate = false;
+  for (let i = 0;i < preString.length; i++) {
+    const character = preString[i];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== undefined) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? undefined : code;
+      } else if (groups?.uri !== undefined) {
+        escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+      }
+    }
+    if (preString[i + 1] === `
+`) {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : undefined;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === `
+`) {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+  }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join(`
+`);
+}
+
+// node_modules/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+import { ReadStream } from "node:tty";
+function findCursor(s, o, l2) {
+  if (!l2.some((r) => !r.disabled))
+    return s;
+  const t = s + o, n = Math.max(l2.length - 1, 0), e = t < 0 ? n : t > n ? 0 : t;
+  return l2[e]?.disabled ? findCursor(e, o < 0 ? -1 : 1, l2) : e;
+}
+function findTextCursor(s, o, l2, i) {
+  const t = i.split(`
+`);
+  let n = 0, e = s;
+  for (const r of t) {
+    if (e <= r.length)
+      break;
+    e -= r.length + 1, n++;
+  }
+  for (n = Math.max(0, Math.min(t.length - 1, n + l2)), e = Math.min(e, t[n].length) + o;e < 0 && n > 0; )
+    n--, e += t[n].length + 1;
+  for (;e > t[n].length && n < t.length - 1; )
+    e -= t[n].length + 1, n++;
+  e = Math.max(0, Math.min(t[n].length, e));
+  let h = 0;
+  for (let r = 0;r < n; r++)
+    h += t[r].length + 1;
+  return h + e;
+}
+var a$1 = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var t = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var settings = {
+  actions: new Set(a$1),
+  aliases: /* @__PURE__ */ new Map([
+    ["k", "up"],
+    ["j", "down"],
+    ["h", "left"],
+    ["l", "right"],
+    ["\x03", "cancel"],
+    ["escape", "cancel"]
+  ]),
+  messages: {
+    cancel: "Canceled",
+    error: "Something went wrong"
+  },
+  withGuide: true,
+  date: {
+    monthNames: [...t],
+    messages: {
+      required: "Please enter a valid date",
+      invalidMonth: "There are only 12 months in a year",
+      invalidDay: (n, e) => `There are only ${n} days in ${e}`,
+      afterMin: (n) => `Date must be on or after ${n.toISOString().slice(0, 10)}`,
+      beforeMax: (n) => `Date must be on or before ${n.toISOString().slice(0, 10)}`
+    }
+  }
+};
+function isActionKey(n, e) {
+  if (typeof n == "string")
+    return settings.aliases.get(n) === e;
+  for (const s of n)
+    if (s !== undefined && isActionKey(s, e))
+      return true;
+  return false;
+}
+function diffLines(i, s) {
+  if (i === s)
+    return;
+  const e = i.split(`
+`), t2 = s.split(`
+`), r = Math.max(e.length, t2.length), f = [];
+  for (let n = 0;n < r; n++)
+    e[n] !== t2[n] && f.push(n);
+  return {
+    lines: f,
+    numLinesBefore: e.length,
+    numLinesAfter: t2.length,
+    numLines: r
+  };
+}
+var R = globalThis.process.platform.startsWith("win");
+var CANCEL_SYMBOL = Symbol("clack:cancel");
+function isCancel(e) {
+  return e === CANCEL_SYMBOL;
+}
+function setRawMode(e, r) {
+  const o = e;
+  o.isTTY && o.setRawMode(r);
+}
+function block({
+  input: e = stdin,
+  output: r = stdout,
+  overwrite: o = true,
+  hideCursor: t2 = true
+} = {}) {
+  const s = l.createInterface({
+    input: e,
+    output: r,
+    prompt: "",
+    tabSize: 1
+  });
+  l.emitKeypressEvents(e, s), e instanceof ReadStream && e.isTTY && e.setRawMode(true);
+  const n = (f, { name: a, sequence: p }) => {
+    const c = String(f);
+    if (isActionKey([c, a, p], "cancel")) {
+      t2 && r.write(import_sisteransi.cursor.show), process.exit(0);
+      return;
+    }
+    if (!o)
+      return;
+    const i = a === "return" ? 0 : -1, m = a === "return" ? -1 : 0;
+    l.moveCursor(r, i, m, () => {
+      l.clearLine(r, 1, () => {
+        e.once("keypress", n);
+      });
+    });
+  };
+  return t2 && r.write(import_sisteransi.cursor.hide), e.once("keypress", n), () => {
+    e.off("keypress", n), t2 && r.write(import_sisteransi.cursor.show), e instanceof ReadStream && e.isTTY && !R && e.setRawMode(false), s.terminal = false, s.close();
+  };
+}
+var getColumns = (e) => ("columns" in e) && typeof e.columns == "number" ? e.columns : 80;
+var getRows = (e) => ("rows" in e) && typeof e.rows == "number" ? e.rows : 20;
+function wrapTextWithPrefix(e, r, o, t2 = o, s = o, n) {
+  const f = getColumns(e ?? stdout);
+  return wrapAnsi(r, f - o.length, {
+    hard: true,
+    trim: false
+  }).split(`
+`).map((c, i, m) => {
+    const d = n ? n(c, i) : c;
+    return i === 0 ? `${t2}${d}` : i === m.length - 1 ? `${s}${d}` : `${o}${d}`;
+  }).join(`
+`);
+}
+function runValidation(e, n) {
+  if ("~standard" in e) {
+    const a = e["~standard"].validate(n);
+    if (a instanceof Promise)
+      throw new TypeError("Schema validation must be synchronous. Update `validate()` and remove any asynchronous logic.");
+    return a.issues?.at(0)?.message;
+  }
+  return e(n);
+}
+
+class V {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map;
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  constructor(t2, e = true) {
+    const { input: i = stdin, output: n = stdout, render: s, signal: r, ...o } = t2;
+    this.opts = o, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = s.bind(this), this._track = e, this._abortSignal = r, this.input = i, this.output = n;
+  }
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  setSubscriber(t2, e) {
+    const i = this._subscribers.get(t2) ?? [];
+    i.push(e), this._subscribers.set(t2, i);
+  }
+  on(t2, e) {
+    this.setSubscriber(t2, { cb: e });
+  }
+  once(t2, e) {
+    this.setSubscriber(t2, { cb: e, once: true });
+  }
+  emit(t2, ...e) {
+    const i = this._subscribers.get(t2) ?? [], n = [];
+    for (const s of i)
+      s.cb(...e), s.once && n.push(() => i.splice(i.indexOf(s), 1));
+    for (const s of n)
+      s();
+  }
+  prompt() {
+    return new Promise((t2) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted)
+          return this.state = "cancel", this.close(), t2(CANCEL_SYMBOL);
+        this._abortSignal.addEventListener("abort", () => {
+          this.state = "cancel", this.close();
+        }, { once: true });
+      }
+      this.rl = l__default.createInterface({
+        input: this.input,
+        tabSize: 2,
+        prompt: "",
+        escapeCodeTimeout: 50,
+        terminal: true
+      }), this.rl.prompt(), this.opts.initialUserInput !== undefined && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), setRawMode(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(this.value);
+      }), this.once("cancel", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(CANCEL_SYMBOL);
+      });
+    });
+  }
+  _isActionKey(t2, e) {
+    return t2 === "\t";
+  }
+  _shouldSubmit(t2, e) {
+    return true;
+  }
+  _setValue(t2) {
+    this.value = t2, this.emit("value", this.value);
+  }
+  _setUserInput(t2, e) {
+    this.userInput = t2 ?? "", this.emit("userInput", this.userInput), e && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
+  }
+  _clearUserInput() {
+    this.rl?.write(null, { ctrl: true, name: "u" }), this._setUserInput("");
+  }
+  onKeypress(t2, e) {
+    if (this._track && e.name !== "return" && (e.name && this._isActionKey(t2, e) && this.rl?.write(null, { ctrl: true, name: "h" }), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), e?.name && (!this._track && settings.aliases.has(e.name) && this.emit("cursor", settings.aliases.get(e.name)), settings.actions.has(e.name) && this.emit("cursor", e.name)), t2 && (t2.toLowerCase() === "y" || t2.toLowerCase() === "n") && this.emit("confirm", t2.toLowerCase() === "y"), this.emit("key", t2, e), e?.name === "return" && this._shouldSubmit(t2, e)) {
+      if (this.opts.validate) {
+        const i = runValidation(this.opts.validate, this.value);
+        i && (this.error = i instanceof Error ? i.message : i, this.state = "error", this.rl?.write(this.userInput));
+      }
+      this.state !== "error" && (this.state = "submit");
+    }
+    isActionKey([t2, e?.name, e?.sequence], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+  }
+  close() {
+    this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), setRawMode(this.input, false), this.rl?.close(), this.rl = undefined, this.emit(`${this.state}`, this.value), this.unsubscribe();
+  }
+  restoreCursor() {
+    const t2 = wrapAnsi(this._prevFrame, process.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(import_sisteransi.cursor.move(-999, t2 * -1));
+  }
+  render() {
+    const t2 = wrapAnsi(this._render(this) ?? "", process.stdout.columns, {
+      hard: true,
+      trim: false
+    });
+    if (t2 !== this._prevFrame) {
+      if (this.state === "initial")
+        this.output.write(import_sisteransi.cursor.hide);
+      else {
+        const e = diffLines(this._prevFrame, t2), i = getRows(this.output);
+        if (this.restoreCursor(), e) {
+          const n = Math.max(0, e.numLinesAfter - i), s = Math.max(0, e.numLinesBefore - i);
+          let r = e.lines.find((o) => o >= n);
+          if (r === undefined) {
+            this._prevFrame = t2;
+            return;
+          }
+          if (e.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, r - s)), this.output.write(import_sisteransi.erase.lines(1));
+            const o = t2.split(`
+`);
+            this.output.write(o[r]), this._prevFrame = t2, this.output.write(import_sisteransi.cursor.move(0, o.length - r - 1));
+            return;
+          } else if (e.lines.length > 1) {
+            if (n < s)
+              r = n;
+            else {
+              const h = r - s;
+              h > 0 && this.output.write(import_sisteransi.cursor.move(0, h));
+            }
+            this.output.write(import_sisteransi.erase.down());
+            const f = t2.split(`
+`).slice(r);
+            this.output.write(f.join(`
+`)), this._prevFrame = t2;
+            return;
+          }
+        }
+        this.output.write(import_sisteransi.erase.down());
+      }
+      this.output.write(t2), this.state === "initial" && (this.state = "active"), this._prevFrame = t2;
+    }
+  }
+}
+function p$1(l2, e) {
+  if (l2 === undefined || e.length === 0)
+    return 0;
+  const i = e.findIndex((s) => s.value === l2);
+  return i !== -1 ? i : 0;
+}
+function g(l2, e) {
+  return (e.label ?? String(e.value)).toLowerCase().includes(l2.toLowerCase());
+}
+function m(l2, e) {
+  if (e)
+    return l2 ? e : e[0];
+}
+var T$1 = class T extends V {
+  filteredOptions;
+  multiple;
+  isNavigating = false;
+  selectedValues = [];
+  focusedValue;
+  #e = 0;
+  #s = "";
+  #t;
+  #i;
+  #n;
+  get cursor() {
+    return this.#e;
+  }
+  get userInputWithCursor() {
+    if (!this.userInput)
+      return styleText(["inverse", "hidden"], "_");
+    if (this._cursor >= this.userInput.length)
+      return `${this.userInput}█`;
+    const e = this.userInput.slice(0, this.cursor), t2 = this.userInput.slice(this.cursor, this.cursor + 1), i = this.userInput.slice(this.cursor + 1);
+    return `${e}${styleText("inverse", t2)}${i}`;
+  }
+  get options() {
+    return typeof this.#i == "function" ? this.#i() : this.#i;
+  }
+  constructor(e) {
+    super(e), this.#i = e.options, this.#n = e.placeholder;
+    const t2 = this.options;
+    this.filteredOptions = [...t2], this.multiple = e.multiple === true, this.#t = typeof e.options == "function" ? e.filter : e.filter ?? g;
+    let i;
+    if (e.initialValue && Array.isArray(e.initialValue) ? this.multiple ? i = e.initialValue : i = e.initialValue.slice(0, 1) : !this.multiple && this.options.length > 0 && (i = [this.options[0]?.value]), i)
+      for (const s of i) {
+        const n = t2.findIndex((o) => o.value === s);
+        n !== -1 && (this.toggleSelected(s), this.#e = n);
+      }
+    this.focusedValue = this.options[this.#e]?.value, this.on("key", (s, n) => this.#l(s, n)), this.on("userInput", (s) => this.#u(s));
+  }
+  _isActionKey(e, t2) {
+    return e === "\t" || this.multiple && this.isNavigating && t2.name === "space" && e !== undefined && e !== "";
+  }
+  #l(e, t2) {
+    const i = t2.name === "up", s = t2.name === "down", n = t2.name === "return", o = this.userInput === "" || this.userInput === "\t", u = this.#n, a = this.options, f = u !== undefined && u !== "" && a.some((r) => !r.disabled && (this.#t ? this.#t(u, r) : true));
+    if (t2.name === "tab" && o && f) {
+      this.userInput === "\t" && this._clearUserInput(), this._setUserInput(u, true), this.isNavigating = false;
+      return;
+    }
+    i || s ? (this.#e = findCursor(this.#e, i ? -1 : 1, this.filteredOptions), this.focusedValue = this.filteredOptions[this.#e]?.value, this.multiple || (this.selectedValues = [this.focusedValue]), this.isNavigating = true) : n ? this.value = m(this.multiple, this.selectedValues) : this.multiple ? this.focusedValue !== undefined && (t2.name === "tab" || this.isNavigating && t2.name === "space") ? this.toggleSelected(this.focusedValue) : this.isNavigating = false : (this.focusedValue && (this.selectedValues = [this.focusedValue]), this.isNavigating = false);
+  }
+  deselectAll() {
+    this.selectedValues = [];
+  }
+  toggleSelected(e) {
+    this.filteredOptions.length !== 0 && (this.multiple ? this.selectedValues.includes(e) ? this.selectedValues = this.selectedValues.filter((t2) => t2 !== e) : this.selectedValues = [...this.selectedValues, e] : this.selectedValues = [e]);
+  }
+  #u(e) {
+    if (e !== this.#s) {
+      this.#s = e;
+      const t2 = this.options;
+      e && this.#t ? this.filteredOptions = t2.filter((n) => this.#t?.(e, n)) : this.filteredOptions = [...t2];
+      const i = p$1(this.focusedValue, this.filteredOptions);
+      this.#e = findCursor(i, 0, this.filteredOptions);
+      const s = this.filteredOptions[this.#e];
+      s && !s.disabled ? this.focusedValue = s.value : this.focusedValue = undefined, this.multiple || (this.focusedValue !== undefined ? this.toggleSelected(this.focusedValue) : this.deselectAll());
+    }
+  }
+};
+
+class r extends V {
+  get cursor() {
+    return this.value ? 0 : 1;
+  }
+  get _value() {
+    return this.cursor === 0;
+  }
+  constructor(t2) {
+    super(t2, false), this.value = !!t2.initialValue, this.on("userInput", () => {
+      this.value = this._value;
+    }), this.on("confirm", (i) => {
+      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = i, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+}
+var _ = {
+  Y: { type: "year", len: 4 },
+  M: { type: "month", len: 2 },
+  D: { type: "day", len: 2 }
+};
+function M(r2) {
+  return [...r2].map((t2) => _[t2]);
+}
+function P(r2) {
+  const i = new Intl.DateTimeFormat(r2, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(new Date(2000, 0, 15)), s = [];
+  let n = "/";
+  for (const e of i)
+    e.type === "literal" ? n = e.value.trim() || e.value : (e.type === "year" || e.type === "month" || e.type === "day") && s.push({ type: e.type, len: e.type === "year" ? 4 : 2 });
+  return { segments: s, separator: n };
+}
+function p(r2) {
+  return Number.parseInt((r2 || "0").replace(/_/g, "0"), 10) || 0;
+}
+function f(r2) {
+  return {
+    year: p(r2.year),
+    month: p(r2.month),
+    day: p(r2.day)
+  };
+}
+function c(r2, t2) {
+  return new Date(r2 || 2001, t2 || 1, 0).getDate();
+}
+function b(r2) {
+  const { year: t2, month: i, day: s } = f(r2);
+  if (!t2 || t2 < 0 || t2 > 9999 || !i || i < 1 || i > 12 || !s || s < 1)
+    return;
+  const n = new Date(Date.UTC(t2, i - 1, s));
+  if (!(n.getUTCFullYear() !== t2 || n.getUTCMonth() !== i - 1 || n.getUTCDate() !== s))
+    return { year: t2, month: i, day: s };
+}
+function C(r2) {
+  const t2 = b(r2);
+  return t2 ? new Date(Date.UTC(t2.year, t2.month - 1, t2.day)) : undefined;
+}
+function T2(r2, t2, i, s) {
+  const n = i ? {
+    year: i.getUTCFullYear(),
+    month: i.getUTCMonth() + 1,
+    day: i.getUTCDate()
+  } : null, e = s ? {
+    year: s.getUTCFullYear(),
+    month: s.getUTCMonth() + 1,
+    day: s.getUTCDate()
+  } : null;
+  return r2 === "year" ? { min: n?.year ?? 1, max: e?.year ?? 9999 } : r2 === "month" ? {
+    min: n && t2.year === n.year ? n.month : 1,
+    max: e && t2.year === e.year ? e.month : 12
+  } : {
+    min: n && t2.year === n.year && t2.month === n.month ? n.day : 1,
+    max: e && t2.year === e.year && t2.month === e.month ? e.day : c(t2.year, t2.month)
+  };
+}
+
+class U extends V {
+  #i;
+  #o;
+  #t;
+  #h;
+  #u;
+  #e = { segmentIndex: 0, positionInSegment: 0 };
+  #n = true;
+  #s = null;
+  inlineError = "";
+  get segmentCursor() {
+    return { ...this.#e };
+  }
+  get segmentValues() {
+    return { ...this.#t };
+  }
+  get segments() {
+    return this.#i;
+  }
+  get separator() {
+    return this.#o;
+  }
+  get formattedValue() {
+    return this.#l(this.#t);
+  }
+  #l(t2) {
+    return this.#i.map((i) => t2[i.type]).join(this.#o);
+  }
+  #r() {
+    this._setUserInput(this.#l(this.#t)), this._setValue(C(this.#t) ?? undefined);
+  }
+  constructor(t2) {
+    const i = t2.format ? { segments: M(t2.format), separator: t2.separator ?? "/" } : P(t2.locale), s = t2.separator ?? i.separator, n = t2.format ? M(t2.format) : i.segments, e = t2.initialValue ?? t2.defaultValue, m2 = e ? {
+      year: String(e.getUTCFullYear()).padStart(4, "0"),
+      month: String(e.getUTCMonth() + 1).padStart(2, "0"),
+      day: String(e.getUTCDate()).padStart(2, "0")
+    } : { year: "____", month: "__", day: "__" }, o = n.map((a) => m2[a.type]).join(s);
+    super({ ...t2, initialUserInput: o }, false), this.#i = n, this.#o = s, this.#t = m2, this.#h = t2.minDate, this.#u = t2.maxDate, this.#r(), this.on("cursor", (a) => this.#f(a)), this.on("key", (a, u) => this.#y(a, u)), this.on("finalize", () => this.#p(t2));
+  }
+  #a() {
+    const t2 = Math.max(0, Math.min(this.#e.segmentIndex, this.#i.length - 1)), i = this.#i[t2];
+    if (i)
+      return this.#e.positionInSegment = Math.max(0, Math.min(this.#e.positionInSegment, i.len - 1)), { segment: i, index: t2 };
+  }
+  #m(t2) {
+    this.inlineError = "", this.#s = null;
+    const i = this.#a();
+    i && (this.#e.segmentIndex = Math.max(0, Math.min(this.#i.length - 1, i.index + t2)), this.#e.positionInSegment = 0, this.#n = true);
+  }
+  #d(t2) {
+    const i = this.#a();
+    if (!i)
+      return;
+    const { segment: s } = i, n = this.#t[s.type], e = !n || n.replace(/_/g, "") === "", m2 = Number.parseInt((n || "0").replace(/_/g, "0"), 10) || 0, o = T2(s.type, f(this.#t), this.#h, this.#u);
+    let a;
+    e ? a = t2 === 1 ? o.min : o.max : a = Math.max(Math.min(o.max, m2 + t2), o.min), this.#t = {
+      ...this.#t,
+      [s.type]: a.toString().padStart(s.len, "0")
+    }, this.#n = true, this.#s = null, this.#r();
+  }
+  #f(t2) {
+    if (t2)
+      switch (t2) {
+        case "right":
+          return this.#m(1);
+        case "left":
+          return this.#m(-1);
+        case "up":
+          return this.#d(1);
+        case "down":
+          return this.#d(-1);
+      }
+  }
+  #y(t2, i) {
+    if (i?.name === "backspace" || i?.sequence === "" || i?.sequence === "\b" || t2 === "" || t2 === "\b") {
+      this.inlineError = "";
+      const n = this.#a();
+      if (!n)
+        return;
+      if (!this.#t[n.segment.type].replace(/_/g, "")) {
+        this.#m(-1);
+        return;
+      }
+      this.#t[n.segment.type] = "_".repeat(n.segment.len), this.#n = true, this.#e.positionInSegment = 0, this.#r();
+      return;
+    }
+    if (i?.name === "tab") {
+      this.inlineError = "";
+      const n = this.#a();
+      if (!n)
+        return;
+      const e = i.shift ? -1 : 1, m2 = n.index + e;
+      m2 >= 0 && m2 < this.#i.length && (this.#e.segmentIndex = m2, this.#e.positionInSegment = 0, this.#n = true);
+      return;
+    }
+    if (t2 && /^[0-9]$/.test(t2)) {
+      const n = this.#a();
+      if (!n)
+        return;
+      const { segment: e } = n, m2 = !this.#t[e.type].replace(/_/g, "");
+      if (this.#n && this.#s !== null && !m2) {
+        const h = this.#s + t2, d = { ...this.#t, [e.type]: h }, g2 = this.#g(d, e);
+        if (g2) {
+          this.inlineError = g2, this.#s = null, this.#n = false;
+          return;
+        }
+        this.inlineError = "", this.#t[e.type] = h, this.#s = null, this.#n = false, this.#r(), n.index < this.#i.length - 1 && (this.#e.segmentIndex = n.index + 1, this.#e.positionInSegment = 0, this.#n = true);
+        return;
+      }
+      this.#n && !m2 && (this.#t[e.type] = "_".repeat(e.len), this.#e.positionInSegment = 0), this.#n = false, this.#s = null;
+      const o = this.#t[e.type], a = o.indexOf("_"), u = a >= 0 ? a : Math.min(this.#e.positionInSegment, e.len - 1);
+      if (u < 0 || u >= e.len)
+        return;
+      let l2 = o.slice(0, u) + t2 + o.slice(u + 1), D = false;
+      if (u === 0 && o === "__" && (e.type === "month" || e.type === "day")) {
+        const h = Number.parseInt(t2, 10);
+        l2 = `0${t2}`, D = h <= (e.type === "month" ? 1 : 2);
+      }
+      if (e.type === "year" && (l2 = (o.replace(/_/g, "") + t2).padStart(e.len, "_")), !l2.includes("_")) {
+        const h = { ...this.#t, [e.type]: l2 }, d = this.#g(h, e);
+        if (d) {
+          this.inlineError = d;
+          return;
+        }
+      }
+      this.inlineError = "", this.#t[e.type] = l2;
+      const y = l2.includes("_") ? undefined : b(this.#t);
+      if (y) {
+        const { year: h, month: d } = y, g2 = c(h, d);
+        this.#t = {
+          year: String(Math.max(0, Math.min(9999, h))).padStart(4, "0"),
+          month: String(Math.max(1, Math.min(12, d))).padStart(2, "0"),
+          day: String(Math.max(1, Math.min(g2, y.day))).padStart(2, "0")
+        };
+      }
+      this.#r();
+      const S = l2.indexOf("_");
+      D ? (this.#n = true, this.#s = t2) : S >= 0 ? this.#e.positionInSegment = S : a >= 0 && n.index < this.#i.length - 1 ? (this.#e.segmentIndex = n.index + 1, this.#e.positionInSegment = 0, this.#n = true) : this.#e.positionInSegment = Math.min(u + 1, e.len - 1);
+    }
+  }
+  #g(t2, i) {
+    const { month: s, day: n } = f(t2);
+    if (i.type === "month" && (s < 0 || s > 12))
+      return settings.date.messages.invalidMonth;
+    if (i.type === "day" && (n < 0 || n > 31))
+      return settings.date.messages.invalidDay(31, "any month");
+  }
+  #p(t2) {
+    const { year: i, month: s, day: n } = f(this.#t);
+    if (i && s && n) {
+      const e = c(i, s);
+      this.#t = {
+        ...this.#t,
+        day: String(Math.min(n, e)).padStart(2, "0")
+      };
+    }
+    this.value = C(this.#t) ?? t2.defaultValue ?? undefined;
+  }
+}
+var u$2 = class u extends V {
+  options;
+  cursor = 0;
+  #t;
+  getGroupItems(t2) {
+    return this.options.filter((r2) => r2.group === t2);
+  }
+  isGroupSelected(t2) {
+    const r2 = this.getGroupItems(t2), e = this.value;
+    return e === undefined ? false : r2.every((s) => e.includes(s.value));
+  }
+  toggleValue() {
+    const t2 = this.options[this.cursor];
+    if (t2 !== undefined)
+      if (this.value === undefined && (this.value = []), t2.group === true) {
+        const r2 = t2.value, e = this.getGroupItems(r2);
+        this.isGroupSelected(r2) ? this.value = this.value.filter((s) => e.findIndex((i) => i.value === s) === -1) : this.value = [...this.value, ...e.map((s) => s.value)], this.value = Array.from(new Set(this.value));
+      } else {
+        const r2 = this.value.includes(t2.value);
+        this.value = r2 ? this.value.filter((e) => e !== t2.value) : [...this.value, t2.value];
+      }
+  }
+  constructor(t2) {
+    super(t2, false);
+    const { options: r2 } = t2;
+    this.#t = t2.selectableGroups !== false, this.options = Object.entries(r2).flatMap(([e, s]) => [
+      { value: e, group: true, label: e },
+      ...s.map((i) => ({ ...i, group: e }))
+    ]), this.value = [...t2.initialValues ?? []], this.cursor = Math.max(this.options.findIndex(({ value: e }) => e === t2.cursorAt), this.#t ? 0 : 1), this.on("cursor", (e) => {
+      switch (e) {
+        case "left":
+        case "up": {
+          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+          const s = this.options[this.cursor]?.group === true;
+          !this.#t && s && (this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1);
+          break;
+        }
+        case "down":
+        case "right": {
+          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+          const s = this.options[this.cursor]?.group === true;
+          !this.#t && s && (this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1);
+          break;
+        }
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+};
+var o = /* @__PURE__ */ new Set(["up", "down", "left", "right"]);
+
+class h extends V {
+  #t = false;
+  #s;
+  focused = "editor";
+  get userInputWithCursor() {
+    if (this.state === "submit")
+      return this.userInput;
+    const t2 = this.userInput;
+    if (this.cursor >= t2.length)
+      return `${t2}█`;
+    const s = t2.slice(0, this.cursor), r2 = t2.slice(this.cursor, this.cursor + 1), i = t2.slice(this.cursor + 1);
+    return r2 === `
+` ? `${s}█
+${i}` : `${s}${styleText("inverse", r2)}${i}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  #r(t2) {
+    if (this.userInput.length === 0) {
+      this._setUserInput(t2);
+      return;
+    }
+    this._setUserInput(this.userInput.slice(0, this.cursor) + t2 + this.userInput.slice(this.cursor));
+  }
+  #i(t2) {
+    const s = this.value ?? "";
+    switch (t2) {
+      case "up":
+        this._cursor = findTextCursor(this._cursor, 0, -1, s);
+        return;
+      case "down":
+        this._cursor = findTextCursor(this._cursor, 0, 1, s);
+        return;
+      case "left":
+        this._cursor = findTextCursor(this._cursor, -1, 0, s);
+        return;
+      case "right":
+        this._cursor = findTextCursor(this._cursor, 1, 0, s);
+        return;
+    }
+  }
+  _shouldSubmit(t2, s) {
+    if (this.#s)
+      return this.focused === "submit" ? true : (this.#r(`
+`), this._cursor++, false);
+    const r2 = this.#t;
+    return this.#t = true, r2 && this.cursor === this.userInput.length ? (this.userInput[this.cursor - 1] === `
+` && (this._setUserInput(this.userInput.slice(0, this.cursor - 1) + this.userInput.slice(this.cursor)), this._cursor--), true) : (this.#r(`
+`), this._cursor++, false);
+  }
+  constructor(t2) {
+    const s = t2.initialUserInput ?? t2.initialValue;
+    super({
+      ...t2,
+      initialUserInput: s
+    }, false), s !== undefined && (this._cursor = s.length), this.#s = t2.showSubmit ?? false, this.on("key", (r2, i) => {
+      if (i?.name && o.has(i.name)) {
+        this.#t = false, this.#i(i.name);
+        return;
+      }
+      if (r2 === "\t" && this.#s) {
+        this.focused = this.focused === "editor" ? "submit" : "editor";
+        return;
+      }
+      if (i?.name !== "return") {
+        if (this.#t = false, i?.name === "backspace" && this.cursor > 0) {
+          this._setUserInput(this.userInput.slice(0, this.cursor - 1) + this.userInput.slice(this.cursor)), this._cursor--;
+          return;
+        }
+        if (i?.name === "delete" && this.cursor < this.userInput.length) {
+          this._setUserInput(this.userInput.slice(0, this.cursor) + this.userInput.slice(this.cursor + 1));
+          return;
+        }
+        r2 && (this.#s && this.focused === "submit" && (this.focused = "editor"), this.#r(r2 ?? ""), this._cursor++);
+      }
+    }), this.on("userInput", (r2) => {
+      this._setValue(r2);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t2.defaultValue), this.value === undefined && (this.value = "");
+    });
+  }
+}
+
+class a extends V {
+  options;
+  cursor = 0;
+  get _value() {
+    return this.options[this.cursor]?.value;
+  }
+  get _enabledOptions() {
+    return this.options.filter((e) => e.disabled !== true);
+  }
+  toggleAll() {
+    const e = this._enabledOptions, i = this.value !== undefined && this.value.length === e.length;
+    this.value = i ? [] : e.map((t2) => t2.value);
+  }
+  toggleInvert() {
+    const e = this.value;
+    if (!e)
+      return;
+    const i = this._enabledOptions.filter((t2) => !e.includes(t2.value));
+    this.value = i.map((t2) => t2.value);
+  }
+  toggleValue() {
+    this.value === undefined && (this.value = []);
+    const e = this.value.includes(this._value);
+    this.value = e ? this.value.filter((i) => i !== this._value) : [...this.value, this._value];
+  }
+  constructor(e) {
+    super(e, false), this.options = e.options, this.value = [...e.initialValues ?? []];
+    const i = Math.max(this.options.findIndex(({ value: t2 }) => t2 === e.cursorAt), 0);
+    this.cursor = this.options[i]?.disabled ? findCursor(i, 1, this.options) : i, this.on("key", (t2, l2) => {
+      l2.name === "a" && this.toggleAll(), l2.name === "i" && this.toggleInvert();
+    }), this.on("cursor", (t2) => {
+      switch (t2) {
+        case "left":
+        case "up":
+          this.cursor = findCursor(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = findCursor(this.cursor, 1, this.options);
+          break;
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+}
+var u$1 = class u2 extends V {
+  _mask = "•";
+  get cursor() {
+    return this._cursor;
+  }
+  get masked() {
+    return this.userInput.replaceAll(/./g, this._mask);
+  }
+  get userInputWithCursor() {
+    if (this.state === "submit" || this.state === "cancel")
+      return this.masked;
+    const t2 = this.userInput;
+    if (this.cursor >= t2.length)
+      return `${this.masked}${styleText(["inverse", "hidden"], "_")}`;
+    const s = this.masked, r2 = s.slice(0, this.cursor), i = s.slice(this.cursor, this.cursor + 1), o2 = s.slice(this.cursor + 1);
+    return `${r2}${styleText("inverse", i)}${o2}`;
+  }
+  clear() {
+    this._clearUserInput();
+  }
+  constructor({ mask: t2, ...s }) {
+    super(s), this._mask = t2 ?? "•", this.on("userInput", (r2) => {
+      this._setValue(r2);
+    }), this.on("finalize", () => {
+      this.value === undefined && (this.value = "");
+    });
+  }
+};
+var n$1 = class n extends V {
+  options;
+  cursor = 0;
+  get _selectedValue() {
+    return this.options[this.cursor];
+  }
+  changeValue() {
+    const e = this._selectedValue;
+    this.value = e === undefined ? undefined : e.value;
+  }
+  constructor(e) {
+    super(e, false), this.options = e.options;
+    const o2 = this.options.findIndex(({ value: s }) => s === e.initialValue), t2 = o2 === -1 ? 0 : o2;
+    this.cursor = this.options[t2]?.disabled ? findCursor(t2, 1, this.options) : t2, this.changeValue(), this.on("cursor", (s) => {
+      switch (s) {
+        case "left":
+        case "up":
+          this.cursor = findCursor(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = findCursor(this.cursor, 1, this.options);
+          break;
+      }
+      this.changeValue();
+    });
+  }
+};
+class n2 extends V {
+  get userInputWithCursor() {
+    if (this.state === "submit")
+      return this.userInput;
+    const t2 = this.userInput;
+    if (this.cursor >= t2.length)
+      return `${this.userInput}█`;
+    const r2 = t2.slice(0, this.cursor), s = t2.slice(this.cursor, this.cursor + 1), e = t2.slice(this.cursor + 1);
+    return `${r2}${styleText("inverse", s)}${e}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  constructor(t2) {
+    super({
+      ...t2,
+      initialUserInput: t2.initialUserInput ?? t2.initialValue
+    }), this.on("userInput", (r2) => {
+      this._setValue(r2);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t2.defaultValue), this.value === undefined && (this.value = "");
+    });
+  }
+}
+
+// node_modules/@clack/prompts/dist/index.mjs
+import { styleText as styleText2, stripVTControlCharacters } from "node:util";
+import process$1 from "node:process";
+var import_sisteransi2 = __toESM(require_src(), 1);
+function isUnicodeSupported() {
+  if (process$1.platform !== "win32") {
+    return process$1.env.TERM !== "linux";
+  }
+  return Boolean(process$1.env.CI) || Boolean(process$1.env.WT_SESSION) || Boolean(process$1.env.TERMINUS_SUBLIME) || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var unicode = isUnicodeSupported();
+var isCI = () => process.env.CI === "true";
+var isTTY = (o2) => o2.isTTY === true;
+var unicodeOr = (o2, e) => unicode ? o2 : e;
+var S_STEP_ACTIVE = unicodeOr("◆", "*");
+var S_STEP_CANCEL = unicodeOr("■", "x");
+var S_STEP_ERROR = unicodeOr("▲", "x");
+var S_STEP_SUBMIT = unicodeOr("◇", "o");
+var S_BAR_START = unicodeOr("┌", "T");
+var S_BAR = unicodeOr("│", "|");
+var S_BAR_END = unicodeOr("└", "—");
+var S_BAR_START_RIGHT = unicodeOr("┐", "T");
+var S_BAR_END_RIGHT = unicodeOr("┘", "—");
+var S_RADIO_ACTIVE = unicodeOr("●", ">");
+var S_RADIO_INACTIVE = unicodeOr("○", " ");
+var S_CHECKBOX_ACTIVE = unicodeOr("◻", "[•]");
+var S_CHECKBOX_SELECTED = unicodeOr("◼", "[+]");
+var S_CHECKBOX_INACTIVE = unicodeOr("◻", "[ ]");
+var S_PASSWORD_MASK = unicodeOr("▪", "•");
+var S_BAR_H = unicodeOr("─", "-");
+var S_CORNER_TOP_RIGHT = unicodeOr("╮", "+");
+var S_CONNECT_LEFT = unicodeOr("├", "+");
+var S_CORNER_BOTTOM_RIGHT = unicodeOr("╯", "+");
+var S_CORNER_BOTTOM_LEFT = unicodeOr("╰", "+");
+var S_CORNER_TOP_LEFT = unicodeOr("╭", "+");
+var S_INFO = unicodeOr("●", "•");
+var S_SUCCESS = unicodeOr("◆", "*");
+var S_WARN = unicodeOr("▲", "!");
+var S_ERROR = unicodeOr("■", "x");
+var symbol = (o2) => {
+  switch (o2) {
+    case "initial":
+    case "active":
+      return styleText2("cyan", S_STEP_ACTIVE);
+    case "cancel":
+      return styleText2("red", S_STEP_CANCEL);
+    case "error":
+      return styleText2("yellow", S_STEP_ERROR);
+    case "submit":
+      return styleText2("green", S_STEP_SUBMIT);
+  }
+};
+var confirm = (i) => {
+  const a2 = i.active ?? "Yes", s = i.inactive ?? "No";
+  return new r({
+    active: a2,
+    inactive: s,
+    signal: i.signal,
+    input: i.input,
+    output: i.output,
+    initialValue: i.initialValue ?? true,
+    render() {
+      const e = i.withGuide ?? settings.withGuide, u4 = `${symbol(this.state)}  `, l2 = e ? `${styleText2("gray", S_BAR)}  ` : "", f2 = wrapTextWithPrefix(i.output, i.message, l2, u4), o2 = `${e ? `${styleText2("gray", S_BAR)}
+` : ""}${f2}
+`, c2 = this.value ? a2 : s;
+      switch (this.state) {
+        case "submit": {
+          const r2 = e ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${o2}${r2}${styleText2("dim", c2)}`;
+        }
+        case "cancel": {
+          const r2 = e ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${o2}${r2}${styleText2(["strikethrough", "dim"], c2)}${e ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r2 = e ? `${styleText2("cyan", S_BAR)}  ` : "", g2 = e ? styleText2("cyan", S_BAR_END) : "";
+          return `${o2}${r2}${this.value ? `${styleText2("green", S_RADIO_ACTIVE)} ${a2}` : `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", a2)}`}${i.vertical ? e ? `
+${styleText2("cyan", S_BAR)}  ` : `
+` : ` ${styleText2("dim", "/")} `}${this.value ? `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", s)}` : `${styleText2("green", S_RADIO_ACTIVE)} ${s}`}
+${g2}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var MULTISELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "↑/↓")} to navigate`,
+  `${styleText2("dim", "Space:")} select`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var log = {
+  message: (s = [], {
+    symbol: e = styleText2("gray", S_BAR),
+    secondarySymbol: r2 = styleText2("gray", S_BAR),
+    output: m2 = process.stdout,
+    spacing: l2 = 1,
+    withGuide: c2
+  } = {}) => {
+    const t2 = [], o2 = c2 ?? settings.withGuide, f2 = o2 ? r2 : "", O = o2 ? `${e}  ` : "", u4 = o2 ? `${r2}  ` : "";
+    for (let i = 0;i < l2; i++)
+      t2.push(f2);
+    const g2 = Array.isArray(s) ? s : s.split(`
+`);
+    if (g2.length > 0) {
+      const [i, ...y] = g2;
+      i.length > 0 ? t2.push(`${O}${i}`) : t2.push(o2 ? e : "");
+      for (const p2 of y)
+        p2.length > 0 ? t2.push(`${u4}${p2}`) : t2.push(o2 ? r2 : "");
+    }
+    m2.write(`${t2.join(`
+`)}
+`);
+  },
+  info: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("blue", S_INFO) });
+  },
+  success: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("green", S_SUCCESS) });
+  },
+  step: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("green", S_STEP_SUBMIT) });
+  },
+  warn: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("yellow", S_WARN) });
+  },
+  warning: (s, e) => {
+    log.warn(s, e);
+  },
+  error: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("red", S_ERROR) });
+  }
+};
+var cancel = (o2 = "", t2) => {
+  const i = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_END)}  ` : "";
+  i.write(`${e}${styleText2("red", o2)}
+
+`);
+};
+var intro = (o2 = "", t2) => {
+  const i = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_START)}  ` : "";
+  i.write(`${e}${o2}
+`);
+};
+var outro = (o2 = "", t2) => {
+  const i = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR)}
+${styleText2("gray", S_BAR_END)}  ` : "";
+  i.write(`${e}${o2}
+
+`);
+};
+var password = (r2) => new u$1({
+  validate: r2.validate,
+  mask: r2.mask ?? S_PASSWORD_MASK,
+  signal: r2.signal,
+  input: r2.input,
+  output: r2.output,
+  render() {
+    const e = r2.withGuide ?? settings.withGuide, o2 = `${e ? `${styleText2("gray", S_BAR)}
+` : ""}${symbol(this.state)}  ${r2.message}
+`, c2 = this.userInputWithCursor, i = this.masked;
+    switch (this.state) {
+      case "error": {
+        const s = e ? `${styleText2("yellow", S_BAR)}  ` : "", n3 = e ? `${styleText2("yellow", S_BAR_END)}  ` : "", l2 = i ?? "";
+        return r2.clearOnError && this.clear(), `${o2.trim()}
+${s}${l2}
+${n3}${styleText2("yellow", this.error)}
+`;
+      }
+      case "submit": {
+        const s = e ? `${styleText2("gray", S_BAR)}  ` : "", n3 = i ? styleText2("dim", i) : "";
+        return `${o2}${s}${n3}`;
+      }
+      case "cancel": {
+        const s = e ? `${styleText2("gray", S_BAR)}  ` : "", n3 = i ? styleText2(["strikethrough", "dim"], i) : "";
+        return `${o2}${s}${n3}${i && e ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+      }
+      default: {
+        const s = e ? `${styleText2("cyan", S_BAR)}  ` : "", n3 = e ? styleText2("cyan", S_BAR_END) : "";
+        return `${o2}${s}${c2}
+${n3}
+`;
+      }
+    }
+  }
+}).prompt();
+var W = (l2) => styleText2("magenta", l2);
+var spinner = ({
+  indicator: l2 = "dots",
+  onCancel: h2,
+  output: n3 = process.stdout,
+  cancelMessage: G,
+  errorMessage: O,
+  frames: E = unicode ? ["◒", "◐", "◓", "◑"] : ["•", "o", "O", "0"],
+  delay: F = unicode ? 80 : 120,
+  signal: m2,
+  ...I
+} = {}) => {
+  const u4 = isCI();
+  let M2, T3, d = false, S = false, s = "", p2, w = performance.now();
+  const x = getColumns(n3), k = I?.styleFrame ?? W, g2 = (e) => {
+    const r2 = e > 1 ? O ?? settings.messages.error : G ?? settings.messages.cancel;
+    S = e === 1, d && (a2(r2, e), S && typeof h2 == "function" && h2());
+  }, f2 = () => g2(2), i = () => g2(1), A = () => {
+    process.on("uncaughtExceptionMonitor", f2), process.on("unhandledRejection", f2), process.on("SIGINT", i), process.on("SIGTERM", i), process.on("exit", g2), m2 && m2.addEventListener("abort", i);
+  }, H = () => {
+    process.removeListener("uncaughtExceptionMonitor", f2), process.removeListener("unhandledRejection", f2), process.removeListener("SIGINT", i), process.removeListener("SIGTERM", i), process.removeListener("exit", g2), m2 && m2.removeEventListener("abort", i);
+  }, y = () => {
+    if (p2 === undefined)
+      return;
+    u4 && n3.write(`
+`);
+    const r2 = wrapAnsi(p2, x, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    r2.length > 1 && n3.write(import_sisteransi2.cursor.up(r2.length - 1)), n3.write(import_sisteransi2.cursor.to(0)), n3.write(import_sisteransi2.erase.down());
+  }, C2 = (e) => e.replace(/\.+$/, ""), _2 = (e) => {
+    const r2 = (performance.now() - e) / 1000, t2 = Math.floor(r2 / 60), o2 = Math.floor(r2 % 60);
+    return t2 > 0 ? `[${t2}m ${o2}s]` : `[${o2}s]`;
+  }, N = I.withGuide ?? settings.withGuide, P2 = (e = "") => {
+    d = true, M2 = block({ output: n3 }), s = C2(e), w = performance.now(), N && n3.write(`${styleText2("gray", S_BAR)}
+`);
+    let r2 = 0, t2 = 0;
+    A(), T3 = setInterval(() => {
+      if (u4 && s === p2)
+        return;
+      y(), p2 = s;
+      const o2 = k(E[r2]);
+      let v;
+      if (u4)
+        v = `${o2}  ${s}...`;
+      else if (l2 === "timer")
+        v = `${o2}  ${s} ${_2(w)}`;
+      else {
+        const B = ".".repeat(Math.floor(t2)).slice(0, 3);
+        v = `${o2}  ${s}${B}`;
+      }
+      const j = wrapAnsi(v, x, {
+        hard: true,
+        trim: false
+      });
+      n3.write(j), r2 = r2 + 1 < E.length ? r2 + 1 : 0, t2 = t2 < 4 ? t2 + 0.125 : 0;
+    }, F);
+  }, a2 = (e = "", r2 = 0, t2 = false) => {
+    if (!d)
+      return;
+    d = false, clearInterval(T3), y();
+    const o2 = r2 === 0 ? styleText2("green", S_STEP_SUBMIT) : r2 === 1 ? styleText2("red", S_STEP_CANCEL) : styleText2("red", S_STEP_ERROR);
+    s = e ?? s, t2 || (l2 === "timer" ? n3.write(`${o2}  ${s} ${_2(w)}
+`) : n3.write(`${o2}  ${s}
+`)), H(), M2();
+  };
+  return {
+    start: P2,
+    stop: (e = "") => a2(e, 0),
+    message: (e = "") => {
+      s = C2(e ?? s);
+    },
+    cancel: (e = "") => a2(e, 1),
+    error: (e = "") => a2(e, 2),
+    clear: () => a2("", 0, true),
+    get isCancelled() {
+      return S;
+    }
+  };
+};
+var u4 = {
+  light: unicodeOr("─", "-"),
+  heavy: unicodeOr("━", "="),
+  block: unicodeOr("█", "#")
+};
+function progress({
+  style: o2 = "heavy",
+  max: d = 100,
+  size: v = 40,
+  ...x
+} = {}) {
+  const r2 = spinner(x);
+  let a2 = 0, n3 = "";
+  const c2 = Math.max(1, d), l2 = Math.max(1, v), S = (t2) => {
+    switch (t2) {
+      case "initial":
+      case "active":
+        return (e) => styleText2("magenta", e);
+      case "error":
+      case "cancel":
+        return (e) => styleText2("red", e);
+      case "submit":
+        return (e) => styleText2("green", e);
+      default:
+        return (e) => styleText2("magenta", e);
+    }
+  }, p2 = (t2, e) => {
+    const m2 = Math.floor(a2 / c2 * l2);
+    return `${S(t2)(u4[o2].repeat(m2))}${styleText2("dim", u4[o2].repeat(l2 - m2))} ${e}`;
+  }, h2 = (t2 = "") => {
+    n3 = t2, r2.start(p2("initial", t2));
+  }, g2 = (t2 = 1, e) => {
+    a2 = Math.min(c2, t2 + a2), r2.message(p2("active", e ?? n3)), n3 = e ?? n3;
+  };
+  return {
+    start: h2,
+    stop: r2.stop,
+    cancel: r2.cancel,
+    error: r2.error,
+    clear: r2.clear,
+    advance: g2,
+    isCancelled: r2.isCancelled,
+    message: (t2) => g2(0, t2)
+  };
+}
+var SELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "↑/↓")} to navigate`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var i = `${styleText2("gray", S_BAR)}  `;
+var text = (e) => new n2({
+  validate: e.validate,
+  placeholder: e.placeholder,
+  defaultValue: e.defaultValue,
+  initialValue: e.initialValue,
+  output: e.output,
+  signal: e.signal,
+  input: e.input,
+  render() {
+    const i2 = e?.withGuide ?? settings.withGuide, s = `${`${i2 ? `${styleText2("gray", S_BAR)}
+` : ""}${symbol(this.state)}  `}${e.message}
+`, c2 = e.placeholder && e.placeholder.length > 0 ? styleText2("inverse", e.placeholder[0]) + styleText2("dim", e.placeholder.slice(1)) : styleText2(["inverse", "hidden"], "_"), o2 = this.userInput ? this.userInputWithCursor : c2, l2 = this.value ?? "";
+    switch (this.state) {
+      case "error": {
+        const n3 = this.error ? `  ${styleText2("yellow", this.error)}` : "", r2 = i2 ? `${styleText2("yellow", S_BAR)}  ` : "", d = i2 ? styleText2("yellow", S_BAR_END) : "";
+        return `${s.trim()}
+${r2}${o2}
+${d}${n3}
+`;
+      }
+      case "submit": {
+        const n3 = l2 ? `  ${styleText2("dim", l2)}` : "", r2 = i2 ? styleText2("gray", S_BAR) : "";
+        return `${s}${r2}${n3}`;
+      }
+      case "cancel": {
+        const n3 = l2 ? `  ${styleText2(["strikethrough", "dim"], l2)}` : "", r2 = i2 ? styleText2("gray", S_BAR) : "";
+        return `${s}${r2}${n3}${l2.trim() ? `
+${r2}` : ""}`;
+      }
+      default: {
+        const n3 = i2 ? `${styleText2("cyan", S_BAR)}  ` : "", r2 = i2 ? styleText2("cyan", S_BAR_END) : "";
+        return `${s}${n3}${o2}
+${r2}
+`;
+      }
+    }
+  }
+}).prompt();
 
 // src/cli.ts
-import * as prompts5 from "@clack/prompts";
-import { mkdir as mkdir5, mkdtemp as mkdtemp2, readFile as readFile6, readdir as readdir2, rename as rename2, rm as rm4, rmdir, stat as stat5 } from "fs/promises";
+import { existsSync, readdirSync, statSync } from "fs";
+import { mkdir as mkdir5, mkdtemp as mkdtemp2, readFile as readFile6, readdir as readdir2, rename as rename2, rm as rm5, rmdir, stat as stat5 } from "fs/promises";
 import { createConnection, createServer } from "net";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname2, join as join7, relative as relative2, resolve as resolve4, sep } from "path";
+import { dirname as dirname2, join as join8, relative as relative2, resolve as resolve4, sep } from "path";
 
 // src/constants.ts
 var CLI_NAME = "superslate";
+var LICENSE_KEY_VARIABLE = "SUPERSLATE_LICENSE_KEY";
 
 // src/constants.ts
 var CLI_NAME2 = "superslate";
@@ -18,7 +1694,10 @@ var BUYER_CLI_NAME = "create-app";
 var BUYER_CLI_PACKAGE_NAME = "create-app";
 var DEFAULT_SCOPE = "@app";
 var SOURCE_BRAND_NAME = "superslate";
-var TEMPLATE_REPOSITORY = "superslate-dev/superslate";
+var DELIVERY_BASE_URL = "https://dl.superslate.dev";
+var DELIVERY_URL_VARIABLE = "SUPERSLATE_DELIVERY_URL";
+var LICENSE_KEY_VARIABLE2 = "SUPERSLATE_LICENSE_KEY";
+var LICENSE_KEY_PREFIX = "SUPERSLATE-";
 
 // src/core.ts
 function validateAppName(value) {
@@ -55,8 +1734,532 @@ function validateBrandName(value) {
 }
 var SCOPE_EXTENSIONS = new Set([".json", ".jsonc", ".md", ".ts", ".tsx", ".yaml", ".yml"]);
 
+// src/delivery.ts
+var RELEASE_TAG_PATTERN = /^v\d+\.\d+\.\d+(?:-rc\.\d+)?$/;
+function validateLicenseKey(value) {
+  const key = value.trim();
+  if (!key)
+    return "Enter the licence key from your purchase receipt.";
+  if (/\s/.test(key))
+    return "A licence key does not contain spaces.";
+  if (!key.startsWith(LICENSE_KEY_PREFIX) || key.length === LICENSE_KEY_PREFIX.length) {
+    return `A ${CLI_NAME2} licence key starts with ${LICENSE_KEY_PREFIX}. Copy it from your purchase receipt or the customer portal.`;
+  }
+  return;
+}
+function readLicenseKeyFromEnvironment(environment = process.env) {
+  return environment[LICENSE_KEY_VARIABLE2]?.trim() || undefined;
+}
+function normalizeSourceVersion(value) {
+  const trimmed = value.trim();
+  const releaseTag = trimmed.startsWith("v") ? trimmed : `v${trimmed}`;
+  if (!RELEASE_TAG_PATTERN.test(releaseTag)) {
+    throw new Error(`Source version must be an immutable release such as 1.2.3: ${value}`);
+  }
+  return releaseTag;
+}
+
+// node_modules/@clack/prompts/dist/index.mjs
+import { styleText as styleText3, stripVTControlCharacters as stripVTControlCharacters2 } from "node:util";
+import process$12 from "node:process";
+var import_sisteransi3 = __toESM(require_src(), 1);
+function isUnicodeSupported2() {
+  if (process$12.platform !== "win32") {
+    return process$12.env.TERM !== "linux";
+  }
+  return Boolean(process$12.env.CI) || Boolean(process$12.env.WT_SESSION) || Boolean(process$12.env.TERMINUS_SUBLIME) || process$12.env.ConEmuTask === "{cmd::Cmder}" || process$12.env.TERM_PROGRAM === "Terminus-Sublime" || process$12.env.TERM_PROGRAM === "vscode" || process$12.env.TERM === "xterm-256color" || process$12.env.TERM === "alacritty" || process$12.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var unicode2 = isUnicodeSupported2();
+var isCI2 = () => process.env.CI === "true";
+var unicodeOr2 = (o2, e) => unicode2 ? o2 : e;
+var S_STEP_ACTIVE2 = unicodeOr2("◆", "*");
+var S_STEP_CANCEL2 = unicodeOr2("■", "x");
+var S_STEP_ERROR2 = unicodeOr2("▲", "x");
+var S_STEP_SUBMIT2 = unicodeOr2("◇", "o");
+var S_BAR_START2 = unicodeOr2("┌", "T");
+var S_BAR2 = unicodeOr2("│", "|");
+var S_BAR_END2 = unicodeOr2("└", "—");
+var S_BAR_START_RIGHT2 = unicodeOr2("┐", "T");
+var S_BAR_END_RIGHT2 = unicodeOr2("┘", "—");
+var S_RADIO_ACTIVE2 = unicodeOr2("●", ">");
+var S_RADIO_INACTIVE2 = unicodeOr2("○", " ");
+var S_CHECKBOX_ACTIVE2 = unicodeOr2("◻", "[•]");
+var S_CHECKBOX_SELECTED2 = unicodeOr2("◼", "[+]");
+var S_CHECKBOX_INACTIVE2 = unicodeOr2("◻", "[ ]");
+var S_PASSWORD_MASK2 = unicodeOr2("▪", "•");
+var S_BAR_H2 = unicodeOr2("─", "-");
+var S_CORNER_TOP_RIGHT2 = unicodeOr2("╮", "+");
+var S_CONNECT_LEFT2 = unicodeOr2("├", "+");
+var S_CORNER_BOTTOM_RIGHT2 = unicodeOr2("╯", "+");
+var S_CORNER_BOTTOM_LEFT2 = unicodeOr2("╰", "+");
+var S_CORNER_TOP_LEFT2 = unicodeOr2("╭", "+");
+var S_INFO2 = unicodeOr2("●", "•");
+var S_SUCCESS2 = unicodeOr2("◆", "*");
+var S_WARN2 = unicodeOr2("▲", "!");
+var S_ERROR2 = unicodeOr2("■", "x");
+var symbol2 = (o2) => {
+  switch (o2) {
+    case "initial":
+    case "active":
+      return styleText3("cyan", S_STEP_ACTIVE2);
+    case "cancel":
+      return styleText3("red", S_STEP_CANCEL2);
+    case "error":
+      return styleText3("yellow", S_STEP_ERROR2);
+    case "submit":
+      return styleText3("green", S_STEP_SUBMIT2);
+  }
+};
+var symbolBar = (o2) => {
+  switch (o2) {
+    case "initial":
+    case "active":
+      return styleText3("cyan", S_BAR2);
+    case "cancel":
+      return styleText3("red", S_BAR2);
+    case "error":
+      return styleText3("yellow", S_BAR2);
+    case "submit":
+      return styleText3("green", S_BAR2);
+  }
+};
+function formatInstructionFooter(o2, e) {
+  const r2 = [`${e ? `${styleText3("cyan", S_BAR2)}  ` : ""}${o2.join(" • ")}`];
+  return e && r2.push(styleText3("cyan", S_BAR_END2)), r2;
+}
+var I = (l2, e, w, p2, b2, C2 = false) => {
+  let r2 = e, O = 0;
+  if (C2)
+    for (let i2 = p2 - 1;i2 >= w; i2--) {
+      const m2 = l2[i2];
+      if (m2 && (r2 -= m2.length), O++, r2 <= b2)
+        break;
+    }
+  else
+    for (let i2 = w;i2 < p2; i2++) {
+      const m2 = l2[i2];
+      if (m2 && (r2 -= m2.length), O++, r2 <= b2)
+        break;
+    }
+  return { lineCount: r2, removals: O };
+};
+var limitOptions = ({
+  cursor: l2,
+  options: e,
+  style: w,
+  output: p2 = process.stdout,
+  maxItems: b2 = Number.POSITIVE_INFINITY,
+  columnPadding: C2 = 0,
+  rowPadding: r2 = 4
+}) => {
+  const i2 = getColumns(p2) - C2, m2 = getRows(p2), M2 = styleText3("dim", "..."), v = Math.max(m2 - r2, 0), a2 = Math.max(Math.min(b2, v), 5);
+  let f2 = 0;
+  l2 >= a2 - 3 && (f2 = Math.max(Math.min(l2 - a2 + 3, e.length - a2), 0));
+  let d = a2 < e.length && f2 > 0, c2 = a2 < e.length && f2 + a2 < e.length;
+  const W2 = Math.min(f2 + a2, e.length), s = [];
+  let g2 = 0;
+  d && g2++, c2 && g2++;
+  const T3 = f2 + (d ? 1 : 0), y = W2 - (c2 ? 1 : 0);
+  for (let t2 = T3;t2 < y; t2++) {
+    const n3 = e[t2], o2 = n3 ? w(n3, t2 === l2) : "", h2 = wrapAnsi(o2, i2, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    s.push(h2), g2 += h2.length;
+  }
+  if (g2 > v) {
+    let t2 = 0, n3 = 0, o2 = g2;
+    const h2 = l2 - T3;
+    let u5 = v;
+    const L = () => I(s, o2, 0, h2, u5), E = () => I(s, o2, h2 + 1, s.length, u5, true);
+    d ? ({ lineCount: o2, removals: t2 } = L(), o2 > u5 && (c2 || (u5 -= 1), { lineCount: o2, removals: n3 } = E())) : (c2 || (u5 -= 1), { lineCount: o2, removals: n3 } = E(), o2 > u5 && (u5 -= 1, { lineCount: o2, removals: t2 } = L())), t2 > 0 && (d = true, s.splice(0, t2)), n3 > 0 && (c2 = true, s.splice(s.length - n3, n3));
+  }
+  const x = [];
+  d && x.push(M2);
+  for (const t2 of s)
+    for (const n3 of t2)
+      x.push(n3);
+  return c2 && x.push(M2), x;
+};
+var confirm2 = (i2) => {
+  const a2 = i2.active ?? "Yes", s = i2.inactive ?? "No";
+  return new r({
+    active: a2,
+    inactive: s,
+    signal: i2.signal,
+    input: i2.input,
+    output: i2.output,
+    initialValue: i2.initialValue ?? true,
+    render() {
+      const e = i2.withGuide ?? settings.withGuide, u5 = `${symbol2(this.state)}  `, l2 = e ? `${styleText3("gray", S_BAR2)}  ` : "", f2 = wrapTextWithPrefix(i2.output, i2.message, l2, u5), o2 = `${e ? `${styleText3("gray", S_BAR2)}
+` : ""}${f2}
+`, c2 = this.value ? a2 : s;
+      switch (this.state) {
+        case "submit": {
+          const r2 = e ? `${styleText3("gray", S_BAR2)}  ` : "";
+          return `${o2}${r2}${styleText3("dim", c2)}`;
+        }
+        case "cancel": {
+          const r2 = e ? `${styleText3("gray", S_BAR2)}  ` : "";
+          return `${o2}${r2}${styleText3(["strikethrough", "dim"], c2)}${e ? `
+${styleText3("gray", S_BAR2)}` : ""}`;
+        }
+        default: {
+          const r2 = e ? `${styleText3("cyan", S_BAR2)}  ` : "", g2 = e ? styleText3("cyan", S_BAR_END2) : "";
+          return `${o2}${r2}${this.value ? `${styleText3("green", S_RADIO_ACTIVE2)} ${a2}` : `${styleText3("dim", S_RADIO_INACTIVE2)} ${styleText3("dim", a2)}`}${i2.vertical ? e ? `
+${styleText3("cyan", S_BAR2)}  ` : `
+` : ` ${styleText3("dim", "/")} `}${this.value ? `${styleText3("dim", S_RADIO_INACTIVE2)} ${styleText3("dim", s)}` : `${styleText3("green", S_RADIO_ACTIVE2)} ${s}`}
+${g2}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var MULTISELECT_INSTRUCTIONS2 = [
+  `${styleText3("dim", "↑/↓")} to navigate`,
+  `${styleText3("dim", "Space:")} select`,
+  `${styleText3("dim", "Enter:")} confirm`
+];
+var m2 = (i2, u5) => i2.split(`
+`).map((d) => u5(d)).join(`
+`);
+var multiselect = (i2) => {
+  const u5 = (t2, a2) => {
+    const r2 = t2.label ?? String(t2.value);
+    return a2 === "disabled" ? `${styleText3("gray", S_CHECKBOX_INACTIVE2)} ${m2(r2, (o2) => styleText3(["strikethrough", "gray"], o2))}${t2.hint ? ` ${styleText3("dim", `(${t2.hint ?? "disabled"})`)}` : ""}` : a2 === "active" ? `${styleText3("cyan", S_CHECKBOX_ACTIVE2)} ${r2}${t2.hint ? ` ${styleText3("dim", `(${t2.hint})`)}` : ""}` : a2 === "selected" ? `${styleText3("green", S_CHECKBOX_SELECTED2)} ${m2(r2, (o2) => styleText3("dim", o2))}${t2.hint ? ` ${styleText3("dim", `(${t2.hint})`)}` : ""}` : a2 === "cancelled" ? `${m2(r2, (o2) => styleText3(["strikethrough", "dim"], o2))}` : a2 === "active-selected" ? `${styleText3("green", S_CHECKBOX_SELECTED2)} ${r2}${t2.hint ? ` ${styleText3("dim", `(${t2.hint})`)}` : ""}` : a2 === "submitted" ? `${m2(r2, (o2) => styleText3("dim", o2))}` : `${styleText3("dim", S_CHECKBOX_INACTIVE2)} ${m2(r2, (o2) => styleText3("dim", o2))}`;
+  }, d = i2.required ?? true, v = i2.showInstructions ?? true;
+  return new a({
+    options: i2.options,
+    signal: i2.signal,
+    input: i2.input,
+    output: i2.output,
+    initialValues: i2.initialValues,
+    required: d,
+    cursorAt: i2.cursorAt,
+    validate(t2) {
+      if (d && (t2 === undefined || t2.length === 0))
+        return `Please select at least one option.
+${styleText3("reset", styleText3("dim", `Press ${styleText3(["gray", "bgWhite", "inverse"], " space ")} to select, ${styleText3("gray", styleText3("bgWhite", styleText3("inverse", " enter ")))} to submit`))}`;
+    },
+    render() {
+      const t2 = i2.withGuide ?? settings.withGuide, a2 = wrapTextWithPrefix(i2.output, i2.message, t2 ? `${symbolBar(this.state)}  ` : "", `${symbol2(this.state)}  `), r2 = `${t2 ? `${styleText3("gray", S_BAR2)}
+` : ""}${a2}
+`, o2 = this.value ?? [], p2 = (n3, l2) => {
+        if (n3.disabled)
+          return u5(n3, "disabled");
+        const s = o2.includes(n3.value);
+        return l2 && s ? u5(n3, "active-selected") : s ? u5(n3, "selected") : u5(n3, l2 ? "active" : "inactive");
+      };
+      switch (this.state) {
+        case "submit": {
+          const n3 = this.options.filter(({ value: s }) => o2.includes(s)).map((s) => u5(s, "submitted")).join(styleText3("dim", ", ")) || styleText3("dim", "none"), l2 = wrapTextWithPrefix(i2.output, n3, t2 ? `${styleText3("gray", S_BAR2)}  ` : "");
+          return `${r2}${l2}`;
+        }
+        case "cancel": {
+          const n3 = this.options.filter(({ value: s }) => o2.includes(s)).map((s) => u5(s, "cancelled")).join(styleText3("dim", ", "));
+          if (n3.trim() === "")
+            return `${r2}${styleText3("gray", S_BAR2)}`;
+          const l2 = wrapTextWithPrefix(i2.output, n3, t2 ? `${styleText3("gray", S_BAR2)}  ` : "");
+          return `${r2}${l2}${t2 ? `
+${styleText3("gray", S_BAR2)}` : ""}`;
+        }
+        case "error": {
+          const n3 = t2 ? `${styleText3("yellow", S_BAR2)}  ` : "", l2 = this.error.split(`
+`).map(($, C2) => C2 === 0 ? `${t2 ? `${styleText3("yellow", S_BAR_END2)}  ` : ""}${styleText3("yellow", $)}` : `   ${$}`).join(`
+`), s = r2.split(`
+`).length, h2 = l2.split(`
+`).length + 1;
+          return `${r2}${n3}${limitOptions({
+            output: i2.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: i2.maxItems,
+            columnPadding: n3.length,
+            rowPadding: s + h2,
+            style: p2
+          }).join(`
+${n3}`)}
+${l2}
+`;
+        }
+        default: {
+          const n3 = t2 ? `${styleText3("cyan", S_BAR2)}  ` : "", l2 = r2.split(`
+`).length, s = v ? formatInstructionFooter(MULTISELECT_INSTRUCTIONS2, t2) : t2 ? [styleText3("cyan", S_BAR_END2)] : [], h2 = s.join(`
+`), $ = s.length + 1;
+          return `${r2}${n3}${limitOptions({
+            output: i2.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: i2.maxItems,
+            columnPadding: n3.length,
+            rowPadding: l2 + $,
+            style: p2
+          }).join(`
+${n3}`)}
+${h2}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var log2 = {
+  message: (s = [], {
+    symbol: e = styleText3("gray", S_BAR2),
+    secondarySymbol: r2 = styleText3("gray", S_BAR2),
+    output: m3 = process.stdout,
+    spacing: l2 = 1,
+    withGuide: c2
+  } = {}) => {
+    const t2 = [], o2 = c2 ?? settings.withGuide, f2 = o2 ? r2 : "", O = o2 ? `${e}  ` : "", u5 = o2 ? `${r2}  ` : "";
+    for (let i2 = 0;i2 < l2; i2++)
+      t2.push(f2);
+    const g2 = Array.isArray(s) ? s : s.split(`
+`);
+    if (g2.length > 0) {
+      const [i2, ...y] = g2;
+      i2.length > 0 ? t2.push(`${O}${i2}`) : t2.push(o2 ? e : "");
+      for (const p2 of y)
+        p2.length > 0 ? t2.push(`${u5}${p2}`) : t2.push(o2 ? r2 : "");
+    }
+    m3.write(`${t2.join(`
+`)}
+`);
+  },
+  info: (s, e) => {
+    log2.message(s, { ...e, symbol: styleText3("blue", S_INFO2) });
+  },
+  success: (s, e) => {
+    log2.message(s, { ...e, symbol: styleText3("green", S_SUCCESS2) });
+  },
+  step: (s, e) => {
+    log2.message(s, { ...e, symbol: styleText3("green", S_STEP_SUBMIT2) });
+  },
+  warn: (s, e) => {
+    log2.message(s, { ...e, symbol: styleText3("yellow", S_WARN2) });
+  },
+  warning: (s, e) => {
+    log2.warn(s, e);
+  },
+  error: (s, e) => {
+    log2.message(s, { ...e, symbol: styleText3("red", S_ERROR2) });
+  }
+};
+var cancel2 = (o2 = "", t2) => {
+  const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText3("gray", S_BAR_END2)}  ` : "";
+  i2.write(`${e}${styleText3("red", o2)}
+
+`);
+};
+var intro2 = (o2 = "", t2) => {
+  const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText3("gray", S_BAR_START2)}  ` : "";
+  i2.write(`${e}${o2}
+`);
+};
+var outro2 = (o2 = "", t2) => {
+  const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText3("gray", S_BAR2)}
+${styleText3("gray", S_BAR_END2)}  ` : "";
+  i2.write(`${e}${o2}
+
+`);
+};
+var W2 = (l2) => styleText3("magenta", l2);
+var spinner2 = ({
+  indicator: l2 = "dots",
+  onCancel: h2,
+  output: n3 = process.stdout,
+  cancelMessage: G,
+  errorMessage: O,
+  frames: E = unicode2 ? ["◒", "◐", "◓", "◑"] : ["•", "o", "O", "0"],
+  delay: F = unicode2 ? 80 : 120,
+  signal: m3,
+  ...I2
+} = {}) => {
+  const u5 = isCI2();
+  let M2, T3, d = false, S = false, s = "", p2, w = performance.now();
+  const x = getColumns(n3), k = I2?.styleFrame ?? W2, g2 = (e) => {
+    const r2 = e > 1 ? O ?? settings.messages.error : G ?? settings.messages.cancel;
+    S = e === 1, d && (a2(r2, e), S && typeof h2 == "function" && h2());
+  }, f2 = () => g2(2), i2 = () => g2(1), A = () => {
+    process.on("uncaughtExceptionMonitor", f2), process.on("unhandledRejection", f2), process.on("SIGINT", i2), process.on("SIGTERM", i2), process.on("exit", g2), m3 && m3.addEventListener("abort", i2);
+  }, H = () => {
+    process.removeListener("uncaughtExceptionMonitor", f2), process.removeListener("unhandledRejection", f2), process.removeListener("SIGINT", i2), process.removeListener("SIGTERM", i2), process.removeListener("exit", g2), m3 && m3.removeEventListener("abort", i2);
+  }, y = () => {
+    if (p2 === undefined)
+      return;
+    u5 && n3.write(`
+`);
+    const r2 = wrapAnsi(p2, x, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    r2.length > 1 && n3.write(import_sisteransi3.cursor.up(r2.length - 1)), n3.write(import_sisteransi3.cursor.to(0)), n3.write(import_sisteransi3.erase.down());
+  }, C2 = (e) => e.replace(/\.+$/, ""), _2 = (e) => {
+    const r2 = (performance.now() - e) / 1000, t2 = Math.floor(r2 / 60), o2 = Math.floor(r2 % 60);
+    return t2 > 0 ? `[${t2}m ${o2}s]` : `[${o2}s]`;
+  }, N = I2.withGuide ?? settings.withGuide, P2 = (e = "") => {
+    d = true, M2 = block({ output: n3 }), s = C2(e), w = performance.now(), N && n3.write(`${styleText3("gray", S_BAR2)}
+`);
+    let r2 = 0, t2 = 0;
+    A(), T3 = setInterval(() => {
+      if (u5 && s === p2)
+        return;
+      y(), p2 = s;
+      const o2 = k(E[r2]);
+      let v;
+      if (u5)
+        v = `${o2}  ${s}...`;
+      else if (l2 === "timer")
+        v = `${o2}  ${s} ${_2(w)}`;
+      else {
+        const B = ".".repeat(Math.floor(t2)).slice(0, 3);
+        v = `${o2}  ${s}${B}`;
+      }
+      const j = wrapAnsi(v, x, {
+        hard: true,
+        trim: false
+      });
+      n3.write(j), r2 = r2 + 1 < E.length ? r2 + 1 : 0, t2 = t2 < 4 ? t2 + 0.125 : 0;
+    }, F);
+  }, a2 = (e = "", r2 = 0, t2 = false) => {
+    if (!d)
+      return;
+    d = false, clearInterval(T3), y();
+    const o2 = r2 === 0 ? styleText3("green", S_STEP_SUBMIT2) : r2 === 1 ? styleText3("red", S_STEP_CANCEL2) : styleText3("red", S_STEP_ERROR2);
+    s = e ?? s, t2 || (l2 === "timer" ? n3.write(`${o2}  ${s} ${_2(w)}
+`) : n3.write(`${o2}  ${s}
+`)), H(), M2();
+  };
+  return {
+    start: P2,
+    stop: (e = "") => a2(e, 0),
+    message: (e = "") => {
+      s = C2(e ?? s);
+    },
+    cancel: (e = "") => a2(e, 1),
+    error: (e = "") => a2(e, 2),
+    clear: () => a2("", 0, true),
+    get isCancelled() {
+      return S;
+    }
+  };
+};
+var u5 = {
+  light: unicodeOr2("─", "-"),
+  heavy: unicodeOr2("━", "="),
+  block: unicodeOr2("█", "#")
+};
+var SELECT_INSTRUCTIONS2 = [
+  `${styleText3("dim", "↑/↓")} to navigate`,
+  `${styleText3("dim", "Enter:")} confirm`
+];
+var c2 = (t2, o2) => t2.includes(`
+`) ? t2.split(`
+`).map((d) => o2(d)).join(`
+`) : o2(t2);
+var select = (t2) => {
+  const o2 = (n3, m3) => {
+    if (n3 === undefined)
+      return "";
+    const s = n3.label ?? String(n3.value);
+    switch (m3) {
+      case "disabled":
+        return `${styleText3("gray", S_RADIO_INACTIVE2)} ${c2(s, (i2) => styleText3("gray", i2))}${n3.hint ? ` ${styleText3("dim", `(${n3.hint ?? "disabled"})`)}` : ""}`;
+      case "selected":
+        return `${c2(s, (i2) => styleText3("dim", i2))}`;
+      case "active":
+        return `${styleText3("green", S_RADIO_ACTIVE2)} ${s}${n3.hint ? ` ${styleText3("dim", `(${n3.hint})`)}` : ""}`;
+      case "cancelled":
+        return `${c2(s, (i2) => styleText3(["strikethrough", "dim"], i2))}`;
+      default:
+        return `${styleText3("dim", S_RADIO_INACTIVE2)} ${c2(s, (i2) => styleText3("dim", i2))}`;
+    }
+  }, d = t2.showInstructions ?? true;
+  return new n$1({
+    options: t2.options,
+    signal: t2.signal,
+    input: t2.input,
+    output: t2.output,
+    initialValue: t2.initialValue,
+    render() {
+      const n3 = t2.withGuide ?? settings.withGuide, m3 = `${symbol2(this.state)}  `, s = `${symbolBar(this.state)}  `, i2 = wrapTextWithPrefix(t2.output, t2.message, s, m3), u6 = `${n3 ? `${styleText3("gray", S_BAR2)}
+` : ""}${i2}
+`;
+      switch (this.state) {
+        case "submit": {
+          const r2 = n3 ? `${styleText3("gray", S_BAR2)}  ` : "", a2 = wrapTextWithPrefix(t2.output, o2(this.options[this.cursor], "selected"), r2);
+          return `${u6}${a2}`;
+        }
+        case "cancel": {
+          const r2 = n3 ? `${styleText3("gray", S_BAR2)}  ` : "", a2 = wrapTextWithPrefix(t2.output, o2(this.options[this.cursor], "cancelled"), r2);
+          return `${u6}${a2}${n3 ? `
+${styleText3("gray", S_BAR2)}` : ""}`;
+        }
+        default: {
+          const r2 = n3 ? `${styleText3("cyan", S_BAR2)}  ` : "", a2 = u6.split(`
+`).length, p2 = d ? formatInstructionFooter(SELECT_INSTRUCTIONS2, n3) : n3 ? [styleText3("cyan", S_BAR_END2)] : [], b2 = p2.join(`
+`), f2 = p2.length + 1;
+          return `${u6}${r2}${limitOptions({
+            output: t2.output,
+            cursor: this.cursor,
+            options: this.options,
+            maxItems: t2.maxItems,
+            columnPadding: r2.length,
+            rowPadding: a2 + f2,
+            style: (g2, x) => o2(g2, g2.disabled ? "disabled" : x ? "active" : "inactive")
+          }).join(`
+${r2}`)}
+${b2}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var i2 = `${styleText3("gray", S_BAR2)}  `;
+var text2 = (e) => new n2({
+  validate: e.validate,
+  placeholder: e.placeholder,
+  defaultValue: e.defaultValue,
+  initialValue: e.initialValue,
+  output: e.output,
+  signal: e.signal,
+  input: e.input,
+  render() {
+    const i3 = e?.withGuide ?? settings.withGuide, s = `${`${i3 ? `${styleText3("gray", S_BAR2)}
+` : ""}${symbol2(this.state)}  `}${e.message}
+`, c3 = e.placeholder && e.placeholder.length > 0 ? styleText3("inverse", e.placeholder[0]) + styleText3("dim", e.placeholder.slice(1)) : styleText3(["inverse", "hidden"], "_"), o2 = this.userInput ? this.userInputWithCursor : c3, l2 = this.value ?? "";
+    switch (this.state) {
+      case "error": {
+        const n3 = this.error ? `  ${styleText3("yellow", this.error)}` : "", r2 = i3 ? `${styleText3("yellow", S_BAR2)}  ` : "", d = i3 ? styleText3("yellow", S_BAR_END2) : "";
+        return `${s.trim()}
+${r2}${o2}
+${d}${n3}
+`;
+      }
+      case "submit": {
+        const n3 = l2 ? `  ${styleText3("dim", l2)}` : "", r2 = i3 ? styleText3("gray", S_BAR2) : "";
+        return `${s}${r2}${n3}`;
+      }
+      case "cancel": {
+        const n3 = l2 ? `  ${styleText3(["strikethrough", "dim"], l2)}` : "", r2 = i3 ? styleText3("gray", S_BAR2) : "";
+        return `${s}${r2}${n3}${l2.trim() ? `
+${r2}` : ""}`;
+      }
+      default: {
+        const n3 = i3 ? `${styleText3("cyan", S_BAR2)}  ` : "", r2 = i3 ? styleText3("cyan", S_BAR_END2) : "";
+        return `${s}${n3}${o2}
+${r2}
+`;
+      }
+    }
+  }
+}).prompt();
+
 // src/agent-setup.ts
-import * as prompts from "@clack/prompts";
 import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
 import { dirname, join as join2, resolve } from "node:path";
 
@@ -74,19 +2277,19 @@ function runCaptured(command, options) {
       env: options.env ?? process.env,
       stdio: ["ignore", "pipe", "pipe"]
     });
-    let stdout = "";
+    let stdout2 = "";
     let stderr = "";
     child.stdout.setEncoding("utf8");
     child.stderr.setEncoding("utf8");
     child.stdout.on("data", (chunk) => {
-      stdout += chunk;
+      stdout2 += chunk;
     });
     child.stderr.on("data", (chunk) => {
       stderr += chunk;
     });
     child.on("error", reject);
     child.on("close", (code, signal) => {
-      resolve({ exitCode: code ?? (signal ? 1 : 0), stdout, stderr });
+      resolve({ exitCode: code ?? (signal ? 1 : 0), stdout: stdout2, stderr });
     });
   });
 }
@@ -334,7 +2537,7 @@ async function chooseClients(parsed) {
   if (!process.stdin.isTTY) {
     throw new Error("Interactive setup needs a terminal. Pass --clients and --yes instead.");
   }
-  const selected = await prompts.multiselect({
+  const selected = await multiselect({
     message: "Connect which local coding clients?",
     required: true,
     options: CLIENTS.map((client) => ({
@@ -344,8 +2547,8 @@ async function chooseClients(parsed) {
     })),
     initialValues: detected
   });
-  if (prompts.isCancel(selected)) {
-    prompts.cancel("No agent clients were configured.");
+  if (isCancel(selected)) {
+    cancel2("No agent clients were configured.");
     return;
   }
   return selected;
@@ -379,29 +2582,28 @@ async function runAgentSetup(argv, cliName) {
   const clients = await chooseClients(parsed);
   if (!clients)
     return;
-  prompts.intro("superslate local agent context");
+  intro2("superslate local agent context");
   if (parsed.dryRun) {
     for (const client of clients) {
-      prompts.log.info(`${client}
+      log2.info(`${client}
 ${dryRunDescription(client, root)}`);
     }
-    prompts.outro("Dry run complete. No client configuration was changed.");
+    outro2("Dry run complete. No client configuration was changed.");
     return;
   }
-  const progress = prompts.spinner();
-  progress.start("Testing the local MCP server");
+  const progress2 = spinner2();
+  progress2.start("Testing the local MCP server");
   await smokeServer(root);
-  progress.stop("Local MCP server passed its protocol self-check");
+  progress2.stop("Local MCP server passed its protocol self-check");
   for (const client of clients) {
     const result = client === "codex" ? await configureCodex(root) : client === "cursor" ? await configureCursor(root) : await configureClaude(root);
-    prompts.log.success(`${client}: ${result}`);
+    log2.success(`${client}: ${result}`);
   }
-  prompts.log.info("Restart configured clients, then ask: “Use plan_change for my next feature.”");
-  prompts.outro("superslate agent context is ready.");
+  log2.info("Restart configured clients, then ask: “Use plan_change for my next feature.”");
+  outro2("superslate agent context is ready.");
 }
 
 // src/deployment-cli.ts
-import * as prompts3 from "@clack/prompts";
 import { readFile as readFile3 } from "node:fs/promises";
 import { resolve as resolve2 } from "node:path";
 
@@ -616,12 +2818,11 @@ async function applyDeploymentSelection(repositoryRoot, projectName, selection)
 }
 
 // src/deployment-prompts.ts
-import * as prompts2 from "@clack/prompts";
 class DeploymentPromptCancelled extends Error {
 }
 async function unwrap(value) {
-  if (prompts2.isCancel(value)) {
-    prompts2.cancel("Deployment configuration was not changed.");
+  if (isCancel(value)) {
+    cancel2("Deployment configuration was not changed.");
     throw new DeploymentPromptCancelled;
   }
   return value;
@@ -642,7 +2843,7 @@ async function collectDeploymentSelection(defaults = {}, nonInteractive = false)
       haEnabled: defaults.haEnabled ?? false
     };
   }
-  const cloud = defaults.cloud ?? parseDeploymentCloud(await unwrap(await prompts2.select({
+  const cloud = defaults.cloud ?? parseDeploymentCloud(await unwrap(await select({
     message: "Backend cloud",
     options: [
       { value: "aws", label: "AWS", hint: "ECS Fargate + RDS PostgreSQL" },
@@ -650,7 +2851,7 @@ async function collectDeploymentSelection(defaults = {}, nonInteractive = false)
       { value: "azure", label: "Azure", hint: "Container Apps + Flexible Server" }
     ]
   })));
-  const frontendTarget = defaults.frontendTarget ?? parseFrontendTarget(await unwrap(await prompts2.select({
+  const frontendTarget = defaults.frontendTarget ?? parseFrontendTarget(await unwrap(await select({
     message: "Frontend host",
     options: [
       { value: "native", label: "Cloud native", hint: "Managed with the backend" },
@@ -662,7 +2863,7 @@ async function collectDeploymentSelection(defaults = {}, nonInteractive = false)
       }
     ]
   })));
-  const storageProvider = defaults.storageProvider ?? (storageProvidersByCloud[cloud].length === 1 ? storageProvidersByCloud[cloud][0] ?? defaultStorageProviders[cloud] : parseStorageProvider(await unwrap(await prompts2.select({
+  const storageProvider = defaults.storageProvider ?? (storageProvidersByCloud[cloud].length === 1 ? storageProvidersByCloud[cloud][0] ?? defaultStorageProviders[cloud] : parseStorageProvider(await unwrap(await select({
     message: "Object storage",
     options: storageProvidersByCloud[cloud].map((provider) => ({
       value: provider,
@@ -670,29 +2871,29 @@ async function collectDeploymentSelection(defaults = {}, nonInteractive = false)
       hint: provider === defaultStorageProviders[cloud] ? "Cloud-native default" : ""
     }))
   }))));
-  const environment = defaults.environment ?? await unwrap(await prompts2.text({
+  const environment = defaults.environment ?? await unwrap(await text2({
     message: "Deployment environment",
     placeholder: "production",
     defaultValue: "production",
     validate: (value) => validateDeploymentEnvironment(value || "production")
   }));
-  const region = defaults.region ?? await unwrap(await prompts2.text({
+  const region = defaults.region ?? await unwrap(await text2({
     message: `${cloud.toUpperCase()} region`,
     placeholder: defaultRegions[cloud],
     defaultValue: defaultRegions[cloud],
     validate: (value) => validateRegion(value || defaultRegions[cloud])
   }));
-  const apiDomain = defaults.apiDomain ?? await unwrap(await prompts2.text({
+  const apiDomain = defaults.apiDomain ?? await unwrap(await text2({
     message: "Production API domain",
     placeholder: "api.example.com",
     validate: (value) => validateDomain(value ?? "")
   }));
-  const frontendDomain = defaults.frontendDomain ?? await unwrap(await prompts2.text({
+  const frontendDomain = defaults.frontendDomain ?? await unwrap(await text2({
     message: "Production frontend domain",
     placeholder: "app.example.com",
     validate: (value) => validateDomain(value ?? "")
   }));
-  const haEnabled = defaults.haEnabled ?? await unwrap(await prompts2.confirm({
+  const haEnabled = defaults.haEnabled ?? await unwrap(await confirm2({
     message: "Enable the higher-availability profile?",
     initialValue: false
   }));
@@ -750,17 +2951,17 @@ async function runDeploymentConfigure(argv, productName, repositoryRoot = proces
   const rootPackage = JSON.parse(await readFile3(`${root}/package.json`, "utf8"));
   if (!rootPackage.name)
     throw new Error("Root package name is required for deployment setup.");
-  prompts3.intro(`${productName} deployment setup`);
+  intro2(`${productName} deployment setup`);
   try {
     const selection = await collectDeploymentSelection(parsed, parsed.yes);
     const removed = await applyDeploymentSelection(root, rootPackage.name, selection);
-    prompts3.log.success(`${selection.cloud.toUpperCase()} + ${selection.storageProvider} + ${selection.frontendTarget} is locked for ${selection.environment}.`);
-    prompts3.log.info(`${removed.length} unused deployment paths removed.`);
-    prompts3.log.step("Next");
-    prompts3.log.message(`Review deployment/config.json
+    log2.success(`${selection.cloud.toUpperCase()} + ${selection.storageProvider} + ${selection.frontendTarget} is locked for ${selection.environment}.`);
+    log2.info(`${removed.length} unused deployment paths removed.`);
+    log2.step("Next");
+    log2.message(`Review deployment/config.json
 Configure the protected GitHub environment
 Dispatch .github/workflows/deploy-cloud.yml`);
-    prompts3.outro("Deployment configuration is ready to commit.");
+    outro2("Deployment configuration is ready to commit.");
   } catch (error) {
     if (error instanceof DeploymentPromptCancelled)
       return;
@@ -783,19 +2984,19 @@ function runCaptured2(command, options) {
       env: options.env ?? process.env,
       stdio: ["ignore", "pipe", "pipe"]
     });
-    let stdout = "";
+    let stdout2 = "";
     let stderr = "";
     child.stdout.setEncoding("utf8");
     child.stderr.setEncoding("utf8");
     child.stdout.on("data", (chunk) => {
-      stdout += chunk;
+      stdout2 += chunk;
     });
     child.stderr.on("data", (chunk) => {
       stderr += chunk;
     });
     child.on("error", reject);
     child.on("close", (code, signal) => {
-      resolve3({ exitCode: code ?? (signal ? 1 : 0), stdout, stderr });
+      resolve3({ exitCode: code ?? (signal ? 1 : 0), stdout: stdout2, stderr });
     });
   });
 }
@@ -834,12 +3035,11 @@ function isEntrypoint(moduleUrl) {
 }
 
 // src/deployment-prompts.ts
-import * as prompts4 from "@clack/prompts";
 class DeploymentPromptCancelled2 extends Error {
 }
 async function unwrap2(value) {
-  if (prompts4.isCancel(value)) {
-    prompts4.cancel("Deployment configuration was not changed.");
+  if (isCancel(value)) {
+    cancel2("Deployment configuration was not changed.");
     throw new DeploymentPromptCancelled2;
   }
   return value;
@@ -860,7 +3060,7 @@ async function collectDeploymentSelection2(defaults = {}, nonInteractive = false
       haEnabled: defaults.haEnabled ?? false
     };
   }
-  const cloud = defaults.cloud ?? parseDeploymentCloud(await unwrap2(await prompts4.select({
+  const cloud = defaults.cloud ?? parseDeploymentCloud(await unwrap2(await select({
     message: "Backend cloud",
     options: [
       { value: "aws", label: "AWS", hint: "ECS Fargate + RDS PostgreSQL" },
@@ -868,7 +3068,7 @@ async function collectDeploymentSelection2(defaults = {}, nonInteractive = false
       { value: "azure", label: "Azure", hint: "Container Apps + Flexible Server" }
     ]
   })));
-  const frontendTarget = defaults.frontendTarget ?? parseFrontendTarget(await unwrap2(await prompts4.select({
+  const frontendTarget = defaults.frontendTarget ?? parseFrontendTarget(await unwrap2(await select({
     message: "Frontend host",
     options: [
       { value: "native", label: "Cloud native", hint: "Managed with the backend" },
@@ -880,7 +3080,7 @@ async function collectDeploymentSelection2(defaults = {}, nonInteractive = false
       }
     ]
   })));
-  const storageProvider = defaults.storageProvider ?? (storageProvidersByCloud[cloud].length === 1 ? storageProvidersByCloud[cloud][0] ?? defaultStorageProviders[cloud] : parseStorageProvider(await unwrap2(await prompts4.select({
+  const storageProvider = defaults.storageProvider ?? (storageProvidersByCloud[cloud].length === 1 ? storageProvidersByCloud[cloud][0] ?? defaultStorageProviders[cloud] : parseStorageProvider(await unwrap2(await select({
     message: "Object storage",
     options: storageProvidersByCloud[cloud].map((provider) => ({
       value: provider,
@@ -888,29 +3088,29 @@ async function collectDeploymentSelection2(defaults = {}, nonInteractive = false
       hint: provider === defaultStorageProviders[cloud] ? "Cloud-native default" : ""
     }))
   }))));
-  const environment = defaults.environment ?? await unwrap2(await prompts4.text({
+  const environment = defaults.environment ?? await unwrap2(await text2({
     message: "Deployment environment",
     placeholder: "production",
     defaultValue: "production",
     validate: (value) => validateDeploymentEnvironment(value || "production")
   }));
-  const region = defaults.region ?? await unwrap2(await prompts4.text({
+  const region = defaults.region ?? await unwrap2(await text2({
     message: `${cloud.toUpperCase()} region`,
     placeholder: defaultRegions[cloud],
     defaultValue: defaultRegions[cloud],
     validate: (value) => validateRegion(value || defaultRegions[cloud])
   }));
-  const apiDomain = defaults.apiDomain ?? await unwrap2(await prompts4.text({
+  const apiDomain = defaults.apiDomain ?? await unwrap2(await text2({
     message: "Production API domain",
     placeholder: "api.example.com",
     validate: (value) => validateDomain(value ?? "")
   }));
-  const frontendDomain = defaults.frontendDomain ?? await unwrap2(await prompts4.text({
+  const frontendDomain = defaults.frontendDomain ?? await unwrap2(await text2({
     message: "Production frontend domain",
     placeholder: "app.example.com",
     validate: (value) => validateDomain(value ?? "")
   }));
-  const haEnabled = defaults.haEnabled ?? await unwrap2(await prompts4.confirm({
+  const haEnabled = defaults.haEnabled ?? await unwrap2(await confirm2({
     message: "Enable the higher-availability profile?",
     initialValue: false
   }));
@@ -1129,11 +3329,114 @@ async function applyDeploymentSelection2(repositoryRoot, projectName, selection)
 // src/scaffold.ts
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
-import { cp, lstat, mkdir as mkdir4, mkdtemp, readFile as readFile5, readdir, rm as rm3, stat as stat4, writeFile as writeFile4 } from "node:fs/promises";
+import { cp, lstat, mkdir as mkdir4, mkdtemp, readFile as readFile5, readdir, rm as rm4, stat as stat4, writeFile as writeFile4 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { basename, join as join6, relative, resolve as resolve3 } from "node:path";
+import { basename, join as join7, relative, resolve as resolve3 } from "node:path";
 import { promisify } from "node:util";
 
+// src/delivery.ts
+import { createWriteStream } from "node:fs";
+import { rm as rm3 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+var RELEASE_TAG_PATTERN2 = /^v\d+\.\d+\.\d+(?:-rc\.\d+)?$/;
+var INDEX_TIMEOUT_MS = 15000;
+var DOWNLOAD_TIMEOUT_MS = 300000;
+function deliveryBaseUrl(environment = process.env) {
+  const configured = environment[DELIVERY_URL_VARIABLE]?.trim();
+  return (configured || DELIVERY_BASE_URL).replace(/\/+$/, "");
+}
+function releaseAssetNames(releaseTag) {
+  const artifact = `foundation-source-${releaseTag}.tar.gz`;
+  return {
+    artifact,
+    checksum: `${artifact}.sha256`,
+    manifest: `foundation-source-${releaseTag}.manifest.json`
+  };
+}
+function describeFailure(status, subject) {
+  if (status === 401) {
+    return "That licence key was not accepted. Copy it exactly from your purchase receipt or the customer portal (polar.sh).";
+  }
+  if (status === 429) {
+    return "Too many download requests for this licence key. Wait a minute and try again.";
+  }
+  if (status === 404)
+    return `${subject} is not available for download.`;
+  if (status >= 500) {
+    return "Source delivery is temporarily unavailable. Wait a few minutes and try again.";
+  }
+  return `Source delivery refused the request (HTTP ${status}).`;
+}
+async function requestDelivery(url, init, subject) {
+  let response;
+  try {
+    response = await fetch(url, init);
+  } catch {
+    throw new Error("Could not reach source delivery. Check your network connection and try again.");
+  }
+  if (!response.ok)
+    throw new Error(describeFailure(response.status, subject));
+  return response;
+}
+async function resolveRelease(licenseKey, baseUrl = deliveryBaseUrl()) {
+  const response = await requestDelivery(`${baseUrl}/v1/releases`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ key: licenseKey }),
+    signal: AbortSignal.timeout(INDEX_TIMEOUT_MS)
+  }, "The release index");
+  let index;
+  try {
+    index = await response.json();
+  } catch {
+    index = undefined;
+  }
+  if (!index || !RELEASE_TAG_PATTERN2.test(index.latest) || !Array.isArray(index.versions)) {
+    throw new Error(`Source delivery returned an unreadable release index.`);
+  }
+  return index;
+}
+function readContentLength(response) {
+  const header = response.headers.get("content-length");
+  if (!header)
+    return;
+  const total = Number(header);
+  return Number.isSafeInteger(total) && total > 0 ? total : undefined;
+}
+function countBytes(total, onBytes) {
+  let received = 0;
+  return new Transform({
+    transform(chunk, _encoding, done) {
+      received += chunk.length;
+      onBytes(received, total);
+      done(null, chunk);
+    }
+  });
+}
+async function downloadAsset(licenseKey, releaseTag, assetName, directory, baseUrl = deliveryBaseUrl(), onBytes) {
+  const response = await requestDelivery(`${baseUrl}/v1/source/${encodeURIComponent(releaseTag)}/${encodeURIComponent(assetName)}`, {
+    headers: { authorization: `Bearer ${licenseKey}` },
+    signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS)
+  }, releaseTag);
+  if (!response.body)
+    throw new Error(`Source delivery returned an empty ${assetName}.`);
+  const path = join6(directory, assetName);
+  const source = Readable.fromWeb(response.body);
+  try {
+    if (onBytes) {
+      await pipeline(source, countBytes(readContentLength(response), onBytes), createWriteStream(path));
+    } else {
+      await pipeline(source, createWriteStream(path));
+    }
+  } catch {
+    await rm3(path, { force: true });
+    throw new Error(`Downloading ${assetName} was interrupted. Try again in a few minutes.`);
+  }
+  return path;
+}
+
 // src/core.ts
 import { randomBytes } from "node:crypto";
 import { extname } from "node:path";
@@ -1364,7 +3667,49 @@ into this repository.
   }
   return rewritten;
 }
-var SELLER_ONLY_ROOT_SCRIPTS = ["release:distribute"];
+var REQUIRED_BUYER_CLI_CONSTANTS = ["CLI_NAME", "CLI_PACKAGE_NAME", "DEFAULT_SCOPE"];
+function rewriteBuyerCliConstants(content, scope, brandName) {
+  const buyerVariablePrefix = BUYER_CLI_NAME.toUpperCase().replaceAll("-", "_");
+  const buyerConstants = [
+    ["CLI_NAME", BUYER_CLI_NAME],
+    ["CLI_PACKAGE_NAME", BUYER_CLI_PACKAGE_NAME],
+    ["DEFAULT_SCOPE", normalizeScope2(scope)],
+    ["SOURCE_BRAND_NAME", brandName],
+    ["TEMPLATE_REPOSITORY", "OWNER/REPOSITORY"],
+    ["DELIVERY_BASE_URL", "https://releases.example.com"],
+    ["DELIVERY_URL_VARIABLE", `${buyerVariablePrefix}_DELIVERY_URL`],
+    ["LICENSE_KEY_VARIABLE", `${buyerVariablePrefix}_LICENSE_KEY`],
+    ["LICENSE_KEY_PREFIX", "LICENSE-"]
+  ];
+  let rewritten = content;
+  for (const [name, value] of buyerConstants) {
+    const declaration = new RegExp(`^export const ${name} = '[^']*'$`, "m");
+    if (!declaration.test(rewritten)) {
+      if (REQUIRED_BUYER_CLI_CONSTANTS.includes(name)) {
+        throw new Error(`Source CLI constants are missing ${name}.`);
+      }
+      continue;
+    }
+    rewritten = rewritten.replace(declaration, `export const ${name} = '${value}'`);
+  }
+  const leaked = [
+    CLI_PACKAGE_NAME,
+    SOURCE_BRAND_NAME,
+    DELIVERY_BASE_URL,
+    DELIVERY_URL_VARIABLE,
+    LICENSE_KEY_VARIABLE2,
+    LICENSE_KEY_PREFIX
+  ].filter((identity) => rewritten.includes(identity));
+  if (leaked.length > 0) {
+    throw new Error(`Buyer CLI constants still name the source product: ${leaked.join(", ")}`);
+  }
+  return rewritten;
+}
+var SELLER_ONLY_ROOT_SCRIPTS = [
+  "release:distribute",
+  "release:publish-cli",
+  "release:upload"
+];
 function stripSellerOnlyRootScripts(content) {
   const manifest = JSON.parse(content);
   for (const script of SELLER_ONLY_ROOT_SCRIPTS)
@@ -1434,14 +3779,14 @@ function isTemplatePathExcluded(relativePath) {
     return true;
   if (normalized === "internal" || normalized.startsWith("internal/"))
     return true;
-  if (normalized === ".github/workflows/publish-npm.yml")
-    return true;
   if (normalized === ".github/workflows/internal-commercial.yml")
     return true;
   if (normalized === "apps/worker" || normalized.startsWith("apps/worker/"))
     return true;
   if (parts.includes("dist") || parts.includes("out"))
     return true;
+  if (parts.includes(".next") || parts.includes(".source") || parts.includes(".turbo"))
+    return true;
   if (normalized === "bun.lock")
     return true;
   if (normalized === ".vercelignore")
@@ -1503,7 +3848,7 @@ async function copyLocalTemplate(source, target) {
 async function assertNoSymbolicLinks(directory, root = directory, skipExcludedPaths = false) {
   const entries = await readdir(directory, { withFileTypes: true });
   for (const entry of entries) {
-    const path = join6(directory, entry.name);
+    const path = join7(directory, entry.name);
     const relativePath = relative(root, path);
     if (skipExcludedPaths && isTemplatePathExcluded(relativePath))
       continue;
@@ -1526,57 +3871,33 @@ function verifyReleaseMetadata(checksum, manifest, artifactName, digest, templat
     throw new Error(`${CLI_NAME2} release manifest does not match the downloaded source artifact.`);
   }
 }
-async function downloadReleaseAsset(templateRef, fileName, directory) {
+async function downloadLicensedTemplate(target, licenseKey, sourceVersion, onDownloadProgress) {
+  const baseUrl = deliveryBaseUrl();
+  const releaseTag = sourceVersion ?? (await resolveRelease(licenseKey, baseUrl)).latest;
+  const { artifact, checksum: checksumName, manifest: manifestName } = releaseAssetNames(releaseTag);
+  const temporaryDirectory = await mkdtemp(join7(tmpdir(), `${CLI_NAME2}-`));
+  const extractedPath = join7(temporaryDirectory, "template");
   try {
-    await execFileAsync("gh", [
-      "release",
-      "download",
-      templateRef,
-      "--repo",
-      TEMPLATE_REPOSITORY,
-      "--pattern",
-      fileName,
-      "--dir",
-      directory
-    ]);
-  } catch {
-    throw new Error(`Unable to download ${templateRef}. Confirm that GitHub CLI is installed, run ` + `\`gh auth login\`, and accept your ${CLI_NAME2} repository invitation.`);
-  }
-}
-async function downloadGitHubTemplate(target, templateRef) {
-  if (!/^v\d+\.\d+\.\d+(?:-rc\.\d+)?$/.test(templateRef)) {
-    throw new Error(`${CLI_NAME2} template reference must be an immutable release tag: ${templateRef}`);
-  }
-  const temporaryDirectory = await mkdtemp(join6(tmpdir(), `${CLI_NAME2}-`));
-  const artifactName = `foundation-source-${templateRef}.tar.gz`;
-  const checksumName = `${artifactName}.sha256`;
-  const manifestName = `foundation-source-${templateRef}.manifest.json`;
-  const archivePath = join6(temporaryDirectory, artifactName);
-  const extractedPath = join6(temporaryDirectory, "template");
-  try {
-    await execFileAsync("gh", ["auth", "status", "--hostname", "github.com"]).catch(() => {
-      throw new Error(`${CLI_NAME2} source access requires GitHub CLI authentication. Run \`gh auth login\` first.`);
-    });
-    await downloadReleaseAsset(templateRef, artifactName, temporaryDirectory);
-    await downloadReleaseAsset(templateRef, checksumName, temporaryDirectory);
-    await downloadReleaseAsset(templateRef, manifestName, temporaryDirectory);
+    const archivePath = await downloadAsset(licenseKey, releaseTag, artifact, temporaryDirectory, baseUrl, onDownloadProgress);
+    await downloadAsset(licenseKey, releaseTag, checksumName, temporaryDirectory, baseUrl);
+    await downloadAsset(licenseKey, releaseTag, manifestName, temporaryDirectory, baseUrl);
     const archive = await readFile5(archivePath);
     const digest = createHash("sha256").update(archive).digest("hex");
-    const checksum = await readFile5(join6(temporaryDirectory, checksumName), "utf8");
-    const manifest = JSON.parse(await readFile5(join6(temporaryDirectory, manifestName), "utf8"));
-    verifyReleaseMetadata(checksum, manifest, artifactName, digest, templateRef);
+    const checksum = await readFile5(join7(temporaryDirectory, checksumName), "utf8");
+    const manifest = JSON.parse(await readFile5(join7(temporaryDirectory, manifestName), "utf8"));
+    verifyReleaseMetadata(checksum, manifest, artifact, digest, releaseTag);
     await mkdir4(extractedPath);
     await execFileAsync("tar", ["-xzf", archivePath, "-C", extractedPath, "--strip-components=1"]);
     await copyLocalTemplate(extractedPath, target);
   } finally {
-    await rm3(temporaryDirectory, { recursive: true, force: true });
+    await rm4(temporaryDirectory, { recursive: true, force: true });
   }
 }
 async function walk(directory) {
   const entries = await readdir(directory, { withFileTypes: true });
   const paths = [];
   for (const entry of entries) {
-    const path = join6(directory, entry.name);
+    const path = join7(directory, entry.name);
     if (entry.isSymbolicLink()) {
       throw new Error(`Generated template contains a symbolic link: ${path}`);
     }
@@ -1618,7 +3939,7 @@ async function applyScopeRewrite(target, scope) {
 async function applyBrandRewrite(target, brandName) {
   const report = { files: 0, replacements: 0 };
   for (const entry of BRAND_MANIFEST) {
-    const path = join6(target, entry.path);
+    const path = join7(target, entry.path);
     const replacements = await rewriteFile(path, (content) => {
       const result = rewriteBrandContent(content, brandName);
       if (result.replacements > 0 && path.endsWith(".tsx")) {
@@ -1633,27 +3954,27 @@ async function applyBrandRewrite(target, brandName) {
   return report;
 }
 async function generateEnvironmentFiles(target, databasePort = 5432) {
-  const serverExample = await readFile5(join6(target, "apps/server/.env.example"), "utf8");
-  await writeFile4(join6(target, "apps/server/.env"), generateServerEnv(serverExample, undefined, databasePort));
-  const webExample = await readFile5(join6(target, "apps/web/.env.example"), "utf8");
-  await writeFile4(join6(target, "apps/web/.env"), webExample);
-  const docsExample = await readFile5(join6(target, "apps/docs/.env.example"), "utf8");
-  await writeFile4(join6(target, "apps/docs/.env"), docsExample);
-  await writeFile4(join6(target, ".env"), `POSTGRES_PORT=${databasePort}
+  const serverExample = await readFile5(join7(target, "apps/server/.env.example"), "utf8");
+  await writeFile4(join7(target, "apps/server/.env"), generateServerEnv(serverExample, undefined, databasePort));
+  const webExample = await readFile5(join7(target, "apps/web/.env.example"), "utf8");
+  await writeFile4(join7(target, "apps/web/.env"), webExample);
+  const docsExample = await readFile5(join7(target, "apps/docs/.env.example"), "utf8");
+  await writeFile4(join7(target, "apps/docs/.env"), docsExample);
+  await writeFile4(join7(target, ".env"), `POSTGRES_PORT=${databasePort}
 `);
 }
 async function neutralizeAgentInstructions(target) {
-  const agentPath = join6(target, "AGENTS.md");
-  const claudePath = join6(target, "CLAUDE.md");
+  const agentPath = join7(target, "AGENTS.md");
+  const claudePath = join7(target, "CLAUDE.md");
   await writeFile4(agentPath, rewriteBuyerAgentInstructions(await readFile5(agentPath, "utf8")));
   await writeFile4(claudePath, rewriteBuyerClaudeInstructions(await readFile5(claudePath, "utf8")));
-  const rootPackagePath = join6(target, "package.json");
+  const rootPackagePath = join7(target, "package.json");
   await writeFile4(rootPackagePath, stripSellerOnlyRootScripts(await readFile5(rootPackagePath, "utf8")));
 }
 async function neutralizeSourceCli(target, scope, brandName) {
   if (String(CLI_NAME2) === BUYER_CLI_NAME && String(CLI_PACKAGE_NAME) === BUYER_CLI_PACKAGE_NAME)
     return;
-  const rootPackagePath = join6(target, "package.json");
+  const rootPackagePath = join7(target, "package.json");
   const rootPackage = JSON.parse(await readFile5(rootPackagePath, "utf8"));
   const sourceScript = rootPackage.scripts?.[CLI_NAME2];
   if (!sourceScript)
@@ -1662,7 +3983,7 @@ async function neutralizeSourceCli(target, scope, brandName) {
   delete rootPackage.scripts[CLI_NAME2];
   await writeFile4(rootPackagePath, `${JSON.stringify(rootPackage, null, 2)}
 `);
-  const cliPackagePath = join6(target, "packages/create-app/package.json");
+  const cliPackagePath = join7(target, "packages/create-app/package.json");
   const cliPackage = JSON.parse(await readFile5(cliPackagePath, "utf8"));
   if (cliPackage.name !== CLI_PACKAGE_NAME || !cliPackage.bin?.[CLI_NAME2]) {
     throw new Error(`Source CLI package must expose ${CLI_PACKAGE_NAME} as ${CLI_NAME2}.`);
@@ -1670,6 +3991,8 @@ async function neutralizeSourceCli(target, scope, brandName) {
   cliPackage.bin = { [BUYER_CLI_NAME]: "./src/cli.ts" };
   delete cliPackage.description;
   delete cliPackage.homepage;
+  delete cliPackage.bugs;
+  delete cliPackage.author;
   delete cliPackage.repository;
   delete cliPackage.keywords;
   delete cliPackage.files;
@@ -1677,23 +4000,14 @@ async function neutralizeSourceCli(target, scope, brandName) {
   const { name: _sourceName, version: cliVersion, ...cliPackageRemainder } = cliPackage;
   await writeFile4(cliPackagePath, `${JSON.stringify({ name: BUYER_CLI_PACKAGE_NAME, version: cliVersion, private: true, ...cliPackageRemainder }, null, 2)}
 `);
-  const constantsPath = join6(target, "packages/create-app/src/constants.ts");
-  const constants3 = await readFile5(constantsPath, "utf8");
-  const cliDeclaration = `export const CLI_NAME = '${CLI_NAME2}'`;
-  const packageDeclaration = `export const CLI_PACKAGE_NAME = '${CLI_PACKAGE_NAME}'`;
-  const scopeDeclaration = `export const DEFAULT_SCOPE = '@app'`;
-  const repositoryDeclaration = `export const TEMPLATE_REPOSITORY = '${TEMPLATE_REPOSITORY}'`;
-  const brandDeclaration = `export const SOURCE_BRAND_NAME = '${SOURCE_BRAND_NAME}'`;
-  if (!constants3.includes(cliDeclaration) || !constants3.includes(packageDeclaration) || !constants3.includes(scopeDeclaration) || !constants3.includes(repositoryDeclaration) || !constants3.includes(brandDeclaration)) {
-    throw new Error("Source CLI constants do not match the package identity.");
-  }
-  await writeFile4(constantsPath, constants3.replace(cliDeclaration, `export const CLI_NAME = '${BUYER_CLI_NAME}'`).replace(packageDeclaration, `export const CLI_PACKAGE_NAME = '${BUYER_CLI_PACKAGE_NAME}'`).replace(scopeDeclaration, `export const DEFAULT_SCOPE = '${normalizeScope2(scope)}'`).replace(repositoryDeclaration, "export const TEMPLATE_REPOSITORY = 'OWNER/REPOSITORY'").replace(brandDeclaration, `export const SOURCE_BRAND_NAME = '${brandName}'`));
-  const brandingPath = join6(target, "docs/golden-paths/customize-branding-design-tokens.md");
+  const constantsPath = join7(target, "packages/create-app/src/constants.ts");
+  await writeFile4(constantsPath, rewriteBuyerCliConstants(await readFile5(constantsPath, "utf8"), scope, brandName));
+  const brandingPath = join7(target, "docs/golden-paths/customize-branding-design-tokens.md");
   const branding = await readFile5(brandingPath, "utf8");
   await writeFile4(brandingPath, branding.replaceAll(`pnpm ${CLI_NAME2}`, `pnpm ${BUYER_CLI_NAME}`));
-  const setupPath = join6(target, "docs/setup.md");
+  const setupPath = join7(target, "docs/setup.md");
   await writeFile4(setupPath, rewriteBuyerSetupInstructions(await readFile5(setupPath, "utf8")));
-  const releasesPath = join6(target, "docs/releases.md");
+  const releasesPath = join7(target, "docs/releases.md");
   await writeFile4(releasesPath, rewriteBuyerReleaseInstructions(await readFile5(releasesPath, "utf8")));
 }
 async function initializeRepository(target) {
@@ -1715,12 +4029,12 @@ async function scaffold(options) {
   try {
     if (options.from)
       await copyLocalTemplate(options.from, target);
-    else if (options.templateRef)
-      await downloadGitHubTemplate(target, options.templateRef);
-    else {
-      throw new Error(`A local source path or immutable ${CLI_NAME2} release is required.`);
+    else if (options.licenseKey) {
+      await downloadLicensedTemplate(target, options.licenseKey, options.sourceVersion, options.onDownloadProgress);
+    } else {
+      throw new Error(`A local source path or a ${CLI_NAME2} licence key is required.`);
     }
-    const packagePath = join6(target, "package.json");
+    const packagePath = join7(target, "package.json");
     const packageReplacements = await rewriteFile(packagePath, (content) => rewriteRootPackageName(content, options.appName));
     const scope = await applyScopeRewrite(target, options.scope);
     await neutralizeAgentInstructions(target);
@@ -1741,7 +4055,7 @@ async function scaffold(options) {
     }))?.isDirectory()) {
       const entries = await readdir(target);
       if (entries.length === 0)
-        await rm3(target, { recursive: true, force: true });
+        await rm4(target, { recursive: true, force: true });
     }
     throw error;
   }
@@ -1758,6 +4072,8 @@ function usage() {
 Create a buyer-owned SaaS application from your licensed ${suggestBrandName(CLI_NAME)} release.
 
 Options:
+  --license-key <key> Licence key from your purchase (or set ${LICENSE_KEY_VARIABLE})
+  --source-version <version> Pin an immutable release (default: the latest you are entitled to)
   --from <path>       Use a local source checkout (maintainer/testing)
   --scope <namespace> Advanced workspace namespace override (default: derived from brand)
   --brand <name>      Display name (default: derived from app name)
@@ -1802,7 +4118,11 @@ function parseArguments(argv) {
     const argument = argv[index];
     if (argument === "--from")
       parsed.from = takeValue3(argv, index++, argument);
-    else if (argument === "--scope")
+    else if (argument === "--license-key")
+      parsed.licenseKey = takeValue3(argv, index++, argument);
+    else if (argument === "--source-version") {
+      parsed.sourceVersion = normalizeSourceVersion(takeValue3(argv, index++, argument));
+    } else if (argument === "--scope")
       parsed.scope = takeValue3(argv, index++, argument);
     else if (argument === "--brand")
       parsed.brandName = takeValue3(argv, index++, argument);
@@ -1870,28 +4190,60 @@ function suggestScope(brandName, fallbackAppName) {
   return namespace || fallbackAppName;
 }
 async function unwrapPrompt(value) {
-  if (prompts5.isCancel(value)) {
-    prompts5.cancel("No project was created.");
+  if (isCancel(value)) {
+    cancel("No project was created.");
     throw new CliCancelled;
   }
   return value;
 }
+function describeTargetConflict(appName) {
+  const target = resolve4(process.cwd(), appName);
+  if (!existsSync(target))
+    return;
+  if (!statSync(target).isDirectory())
+    return `./${appName} already exists as a file.`;
+  if (readdirSync(target).length > 0) {
+    return `./${appName} already exists and is not empty. Pick another name, or remove it first.`;
+  }
+  return;
+}
+async function collectLicenseKey(parsed) {
+  const supplied = parsed.licenseKey?.trim() ?? readLicenseKeyFromEnvironment();
+  if (supplied) {
+    const error = validateLicenseKey(supplied);
+    if (error)
+      throw new Error(error);
+    return supplied.trim();
+  }
+  if (parsed.yes || !process.stdin.isTTY) {
+    throw new Error(`A licence key is required. Pass --license-key or set ${LICENSE_KEY_VARIABLE}.`);
+  }
+  const entered = await unwrapPrompt(await password({
+    message: "Licence key",
+    validate: (value) => validateLicenseKey(value ?? "")
+  }));
+  return entered.trim();
+}
 async function collectOptions(parsed) {
   if (parsed.yes && !parsed.appName)
     throw new Error("Pass an app name when using --yes.");
   if (!parsed.yes && !process.stdin.isTTY && !parsed.appName) {
     throw new Error("Interactive prompts need a terminal. Pass an app name and --yes instead.");
   }
-  const appName = parsed.appName ?? await unwrapPrompt(await prompts5.text({
+  const appName = parsed.appName ?? await unwrapPrompt(await text({
     message: "App name",
     placeholder: "my-saas",
-    validate: (value) => validateAppName(value ?? "")
+    validate: (value) => validateAppName(value ?? "") ?? describeTargetConflict(value ?? "")
   }));
   const appNameError = validateAppName(appName);
   if (appNameError)
     throw new Error(appNameError);
+  const targetConflict = describeTargetConflict(appName);
+  if (targetConflict)
+    throw new Error(targetConflict);
+  const licenseKey = parsed.from ? undefined : await collectLicenseKey(parsed);
   const suggestedBrand = suggestBrandName(appName);
-  const brandName = parsed.brandName ?? (parsed.yes ? suggestedBrand : await unwrapPrompt(await prompts5.text({
+  const brandName = parsed.brandName ?? (parsed.yes ? suggestedBrand : await unwrapPrompt(await text({
     message: "Brand name",
     placeholder: suggestedBrand,
     defaultValue: suggestedBrand,
@@ -1901,22 +4253,22 @@ async function collectOptions(parsed) {
   if (brandError)
     throw new Error(brandError);
   const scope = normalizeScope(parsed.scope ?? suggestScope(brandName, appName));
-  const initializeGit = parsed.initializeGit ?? (parsed.yes ? true : await unwrapPrompt(await prompts5.confirm({
+  const initializeGit = parsed.initializeGit ?? (parsed.yes ? true : await unwrapPrompt(await confirm({
     message: "Initialize a Git repository?",
     initialValue: true
   })));
-  const installDependencies = parsed.installDependencies ?? (parsed.yes ? true : await unwrapPrompt(await prompts5.confirm({
+  const installDependencies = parsed.installDependencies ?? (parsed.yes ? true : await unwrapPrompt(await confirm({
     message: "Install dependencies with pnpm?",
     initialValue: true
   })));
   if (parsed.startDevelopment && !installDependencies) {
     throw new Error("--start requires dependency installation. Remove --no-install.");
   }
-  const startDevelopment = parsed.startDevelopment ?? (parsed.yes || !installDependencies ? false : await unwrapPrompt(await prompts5.confirm({
+  const startDevelopment = parsed.startDevelopment ?? (parsed.yes || !installDependencies ? false : await unwrapPrompt(await confirm({
     message: "Start local development now?",
     initialValue: true
   })));
-  const setupDeployment = parsed.setupDeployment ?? (parsed.yes ? false : await unwrapPrompt(await prompts5.confirm({
+  const setupDeployment = parsed.setupDeployment ?? (parsed.yes ? false : await unwrapPrompt(await confirm({
     message: "Set up cloud deployment now?",
     initialValue: false
   })));
@@ -1924,6 +4276,8 @@ async function collectOptions(parsed) {
   return {
     appName,
     from: parsed.from ? resolve4(parsed.from) : undefined,
+    licenseKey,
+    sourceVersion: parsed.sourceVersion,
     scope,
     brandName,
     initializeGit,
@@ -1938,15 +4292,6 @@ async function readCliVersion() {
     throw new Error(`${CLI_NAME} package version is missing.`);
   return packageJson.version;
 }
-function templateRefForVersion(version) {
-  if (!/^\d+\.\d+\.\d+(?:-rc\.\d+)?$/.test(version)) {
-    throw new Error(`${CLI_NAME} package version is not release-compatible: ${version}`);
-  }
-  if (version === "0.0.0") {
-    throw new Error(`This pre-release ${CLI_NAME} checkout requires --from <local-source-path>.`);
-  }
-  return `v${version}`;
-}
 async function assertTargetAvailable(target) {
   const targetStat = await stat5(target).catch(() => {
     return;
@@ -2008,8 +4353,8 @@ function assertSiblingTarget(source, target) {
     throw new Error(`Create the new app beside the ${CLI_NAME} source checkout, not inside it.`);
   }
 }
-function commandFailureOutput(stdout, stderr) {
-  const output = (stderr.trim() || stdout.trim()).split(`
+function commandFailureOutput(stdout2, stderr) {
+  const output = (stderr.trim() || stdout2.trim()).split(`
 `).slice(-12).join(`
 `);
   return output ? `
@@ -2017,73 +4362,109 @@ function commandFailureOutput(stdout, stderr) {
 ${output}` : "";
 }
 async function installDependencies(target) {
-  const { stdout, stderr, exitCode } = await runCaptured2(["pnpm", "install", "--frozen-lockfile"], {
+  const { stdout: stdout2, stderr, exitCode } = await runCaptured2(["pnpm", "install", "--frozen-lockfile"], {
     cwd: target,
     env: { ...process.env, CI: "1" }
   });
   if (exitCode !== 0) {
-    throw new Error(`Dependency installation failed.${commandFailureOutput(stdout, stderr)}`);
+    throw new Error(`Dependency installation failed.${commandFailureOutput(stdout2, stderr)}`);
   }
 }
-async function runCapturedCommand(command, target) {
-  const { stdout, stderr, exitCode } = await runCaptured2(command, { cwd: target });
-  if (exitCode !== 0) {
-    throw new Error(`${command.join(" ")} failed.${commandFailureOutput(stdout, stderr)}`);
-  }
+async function occupiedDevelopmentPorts() {
+  const results = await Promise.all([5173, 8000].map(async (port) => ({ port, available: await isPortAvailable(port) })));
+  return results.filter((result) => !result.available).map((result) => result.port);
 }
 async function startDevelopment(target) {
-  const occupiedPorts = (await Promise.all([5173, 8000].map(async (port) => ({
-    port,
-    available: await isPortAvailable(port)
-  })))).filter((result) => !result.available).map((result) => result.port);
-  if (occupiedPorts.length > 0) {
-    throw new Error(`Cannot start development because port ${occupiedPorts.join(", ")} is in use.`);
-  }
-  await runStep("Starting local Postgres", "Local Postgres is ready", () => runCapturedCommand(["docker", "compose", "up", "-d", "--wait", "postgres"], target));
-  prompts5.log.info(`Web  http://localhost:5173
+  log.info(`Web  http://localhost:5173
 API  http://localhost:8000`);
-  prompts5.outro("Development servers are starting. Ctrl+C stops app servers; Postgres stays running.");
-  const exitCode = await runInherited(["vp", "run", "-r", "--parallel", "dev"], { cwd: target });
+  outro("Development servers are starting. Ctrl+C stops app servers; Postgres stays running.");
+  const exitCode = await runInherited(["pnpm", "run", "dev"], { cwd: target });
   if (exitCode !== 0 && exitCode !== 130) {
     throw new Error(`Development servers exited with code ${exitCode}.`);
   }
 }
-async function runStep(pending, complete, action, indicator = "dots") {
-  const progress = prompts5.spinner({ indicator });
-  progress.start(pending);
+var BYTE_UNITS = ["B", "KB", "MB", "GB"];
+var BYTE_SCALE = 1024;
+var PROGRESS_MAX = 100;
+var PROGRESS_BAR_WIDTH = 40;
+var PROGRESS_MIN_INTERVAL_MS = 80;
+var PROGRESS_MIN_DELTA = 0.5;
+function formatBytes(bytes) {
+  let value = bytes;
+  let unit = 0;
+  while (value >= BYTE_SCALE && unit < BYTE_UNITS.length - 1) {
+    value /= BYTE_SCALE;
+    unit += 1;
+  }
+  return `${unit === 0 ? value : value.toFixed(1)} ${BYTE_UNITS[unit]}`;
+}
+function supportsAnimation() {
+  return isTTY(process.stdout) && !isCI();
+}
+function createScaffoldReporter(pending, expectsDownload) {
+  if (!expectsDownload || !supportsAnimation())
+    return { handle: spinner() };
+  const bar = progress({
+    style: "heavy",
+    size: PROGRESS_BAR_WIDTH,
+    max: PROGRESS_MAX
+  });
+  let shown = 0;
+  let emittedAt = 0;
+  return {
+    handle: bar,
+    onDownloadProgress: (received, total) => {
+      const percent = total ? Math.min(PROGRESS_MAX, received / total * PROGRESS_MAX) : shown;
+      const finished = total !== undefined && received >= total;
+      const now = performance.now();
+      if (!finished && now - emittedAt < PROGRESS_MIN_INTERVAL_MS && percent - shown < PROGRESS_MIN_DELTA) {
+        return;
+      }
+      emittedAt = now;
+      const label = finished ? pending : total === undefined ? `Downloading source  ${formatBytes(received)}` : `Downloading source  ${formatBytes(received)} / ${formatBytes(total)}`;
+      bar.advance(percent - shown, label);
+      shown = percent;
+    }
+  };
+}
+async function runStep(pending, complete, action, handle) {
+  handle.start(pending);
   try {
     const result = await action();
-    progress.stop(complete);
+    handle.stop(complete);
     return result;
   } catch (error) {
-    progress.error(`${pending} failed`);
+    handle.error(`${pending} failed`);
     throw error;
   }
 }
-async function createApplication(options, version) {
+async function createApplication(options) {
   const target = resolve4(process.cwd(), options.appName);
   await assertTargetAvailable(target);
   assertSiblingTarget(options.from, target);
   const databasePort = await findAvailablePort();
   await mkdir5(dirname2(target), { recursive: true });
-  const staging = await mkdtemp2(join7(dirname2(target), `.${options.appName}-${CLI_NAME}-`));
+  const staging = await mkdtemp2(join8(dirname2(target), `.${options.appName}-${CLI_NAME}-`));
+  const preparing = "Preparing your application";
+  const reporter = createScaffoldReporter(preparing, Boolean(options.licenseKey));
   try {
-    const templateRef = options.from ? undefined : templateRefForVersion(version);
-    await runStep("Preparing your application", "Application source prepared", () => scaffold({
+    await runStep(preparing, "Application source prepared", () => scaffold({
       appName: options.appName,
       scope: options.scope,
       brandName: options.brandName,
       targetDirectory: staging,
       from: options.from,
-      templateRef,
+      licenseKey: options.licenseKey,
+      sourceVersion: options.sourceVersion,
       initializeGit: options.initializeGit,
-      databasePort
-    }));
+      databasePort,
+      onDownloadProgress: reporter.onDownloadProgress
+    }), reporter.handle);
     if (options.deployment) {
-      await runStep("Configuring deployment", "Deployment target locked", () => applyDeploymentSelection2(staging, options.appName, options.deployment));
+      await runStep("Configuring deployment", "Deployment target locked", () => applyDeploymentSelection2(staging, options.appName, options.deployment), spinner());
     }
     if (options.installDependencies) {
-      await runStep("Installing dependencies with pnpm", "Dependencies installed with pnpm", () => installDependencies(staging), "timer");
+      await runStep("Installing dependencies with pnpm", "Dependencies installed with pnpm", () => installDependencies(staging), spinner({ indicator: "timer" }));
     }
     if (await stat5(target).catch(() => {
       return;
@@ -2092,7 +4473,7 @@ async function createApplication(options, version) {
     await rename2(staging, target);
     return { target, databasePort };
   } catch (error) {
-    await rm4(staging, { recursive: true, force: true });
+    await rm5(staging, { recursive: true, force: true });
     throw error;
   }
 }
@@ -2101,16 +4482,16 @@ function completionDetails(target, options, databasePort) {
   const install = options.installDependencies ? [] : ["vp install --frozen-lockfile"];
   return {
     directory: `./${targetName}`,
-    commands: [
-      `cd ${targetName}`,
-      ...install,
-      "docker compose up -d postgres",
-      "vp run -r --parallel dev"
-    ].join(`
+    commands: [`cd ${targetName}`, ...install, "pnpm dev"].join(`
 `),
     database: `Postgres  localhost:${databasePort}`
   };
 }
+function printRunnableCommands(commands) {
+  console.log(`
+${commands}
+`);
+}
 async function main() {
   const argv = process.argv.slice(2);
   if (argv[0] === "agent") {
@@ -2135,32 +4516,40 @@ async function main() {
     console.log(version);
     return;
   }
-  prompts5.intro(`${suggestBrandName(CLI_NAME)} ${version} \xB7 production SaaS foundation`);
+  intro(`${suggestBrandName(CLI_NAME)} ${version} \xB7 production SaaS foundation`);
   const options = await collectOptions(parsed);
-  const { target, databasePort } = await createApplication(options, version);
+  const { target, databasePort } = await createApplication(options);
   const completion = completionDetails(target, options, databasePort);
-  prompts5.log.success(`Created ${completion.directory}`);
+  log.success(`Created ${completion.directory}`);
   if (!options.startDevelopment) {
-    prompts5.log.step("Run locally");
-    prompts5.log.message(completion.commands);
-    prompts5.log.info(`Web       http://localhost:5173
+    log.step("Run locally");
+    log.info(`Web       http://localhost:5173
 API       http://localhost:8000
 ${completion.database}`);
     if (options.deployment) {
-      prompts5.log.info(`Deployment ${options.deployment.cloud.toUpperCase()} + ${options.deployment.storageProvider} + ${options.deployment.frontendTarget} locked. Review deployment/README.md.`);
+      log.info(`Deployment ${options.deployment.cloud.toUpperCase()} + ${options.deployment.storageProvider} + ${options.deployment.frontendTarget} locked. Review deployment/README.md.`);
     } else {
-      prompts5.log.info("Deployment deferred. Run `pnpm deploy:configure` when you are ready.");
+      log.info("Deployment deferred. Run `pnpm deploy:configure` when you are ready.");
     }
-    prompts5.outro(`${options.brandName} is ready.`);
+    outro(`${options.brandName} is ready.`);
+    printRunnableCommands(completion.commands);
+    return;
+  }
+  const occupiedPorts = await occupiedDevelopmentPorts();
+  if (occupiedPorts.length > 0) {
+    log.warn(`Port ${occupiedPorts.join(" and ")} already in use, so the development servers were not started.`);
+    log.step("Free the port, then run");
+    outro(`${options.brandName} is ready at ${completion.directory}.`);
+    printRunnableCommands(completion.commands);
     return;
   }
   try {
     await startDevelopment(target);
   } catch (error) {
-    prompts5.log.error(error instanceof Error ? error.message : String(error));
-    prompts5.log.info(`The application was created at ${completion.directory}.`);
-    prompts5.log.step("Start it manually");
-    prompts5.log.message(completion.commands);
+    log.error(error instanceof Error ? error.message : String(error));
+    log.step("Start it manually");
+    outro(`${options.brandName} is ready at ${completion.directory}.`);
+    printRunnableCommands(completion.commands);
     process.exitCode = 1;
   }
 }
@@ -2168,16 +4557,20 @@ if (isEntrypoint(import.meta.url)) {
   main().catch((error) => {
     if (error instanceof CliCancelled)
       return;
-    prompts5.log.error(error instanceof Error ? error.message : String(error));
-    prompts5.outro("No project was created.");
+    log.error(error instanceof Error ? error.message : String(error));
+    outro("No project was created.");
     process.exitCode = 1;
   });
 }
 export {
   usage,
-  templateRefForVersion,
   suggestScope,
   suggestBrandName,
+  printRunnableCommands,
   parseArguments,
-  findAvailablePort
+  occupiedDevelopmentPorts,
+  formatBytes,
+  findAvailablePort,
+  describeTargetConflict,
+  collectLicenseKey
 };