create-soda 0.1.1 → 0.2.1

package/dist/index.js

@@ -1,122 +1,1440 @@
 #!/usr/bin/env node
-/**
- * @module
- * `create-soda`: creates a Soda project.
- *
- * ```bash
- * bun create soda my-app
- * npm create soda@latest my-app
- * ```
- *
- * Interactive in a terminal, flag-driven otherwise (CI, scripts). Uses only
- * Node built-ins, so it runs the same under `npm create` (Node) and `bun create`.
- */
-import { existsSync, readFileSync } from 'node:fs';
-import { basename, relative, resolve } from 'node:path';
-import { stdin, stdout } from 'node:process';
-import { createInterface } from 'node:readline/promises';
-import { fileURLToPath } from 'node:url';
-import { createProject, detectPackageManager, emptyDir, formatTargetDir, isEmptyDir, isValidPackageName, toValidPackageName, } from './project.js';
-const DEFAULT_DIR = 'soda-app';
-const HELP = `Usage: create-soda [directory] [options]
-
-Creates a Soda project. Interactive in a terminal.
 
-Options:
-  --overwrite                   empty the directory if it is not empty
-  --interactive, --no-interactive
-                                force or disable questions
-  --core-version <range>        version of @getsoda/core to depend on
-  -h, --help                    show this help
-`;
-const parseArguments = (args) => {
-    let dir;
-    let overwrite = false;
-    let interactive;
-    let coreVersion;
-    let help = false;
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === '--overwrite') {
-            overwrite = true;
+// ../../node_modules/.bun/@clack+core@1.6.0/node_modules/@clack/core/dist/index.mjs
+import { styleText } from "node:util";
+import { stdout, stdin } from "node:process";
+import * as f$1 from "node:readline";
+import f__default from "node:readline";
+
+// ../../node_modules/.bun/fast-string-truncated-width@3.0.3/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/.bun/fast-string-truncated-width@3.0.3/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;
         }
-        else if (arg === '--interactive' || arg === '--no-interactive') {
-            interactive = arg === '--interactive';
+        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;
         }
-        else if (arg === '--core-version') {
-            coreVersion = args[++i];
+      }
+      index += 1;
+    }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+};
+var dist_default = getStringTruncatedWidth;
+
+// ../../node_modules/.bun/fast-string-width@3.0.2/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/.bun/fast-wrap-ansi@0.2.2/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 (arg === '-h' || arg === '--help') {
-            help = true;
+      } 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/.bun/sisteransi@2.0.0/node_modules/sisteransi/dist/index.js
+var ESC2 = "\x1B";
+var CSI2 = `${ESC2}[`;
+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 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;
+  }
+};
+var clear = {
+  screen: `${ESC2}c`
+};
+
+// ../../node_modules/.bun/@clack+core@1.6.0/node_modules/@clack/core/dist/index.mjs
+import { ReadStream } from "node:tty";
+function findCursor(o, s, l) {
+  if (!l.some((r) => !r.disabled))
+    return o;
+  const t = o + s, n = Math.max(l.length - 1, 0), e = t < 0 ? n : t > n ? 0 : t;
+  return l[e]?.disabled ? findCursor(e, s < 0 ? -1 : 1, l) : 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,
+  accessible: undefined,
+  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 isAccessible(n) {
+  if (n !== undefined)
+    return n;
+  if (settings.accessible !== undefined)
+    return settings.accessible;
+  const e = process.env.ACCESSIBLE;
+  return e !== undefined && e !== "" && e !== "0" && e !== "false";
+}
+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(`
+`), t = s.split(`
+`), r = Math.max(e.length, t.length), f = [];
+  for (let n = 0;n < r; n++)
+    e[n] !== t[n] && f.push(n);
+  return {
+    lines: f,
+    numLinesBefore: e.length,
+    numLinesAfter: t.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: n = true
+} = {}) {
+  const s = f$1.createInterface({
+    input: e,
+    output: r,
+    prompt: "",
+    tabSize: 1
+  });
+  f$1.emitKeypressEvents(e, s), e instanceof ReadStream && e.isTTY && e.setRawMode(true);
+  const t = (l, { name: i, sequence: p }) => {
+    const w = String(l);
+    if (isActionKey([w, i, p], "cancel")) {
+      n && r.write(cursor.show), process.exit(0);
+      return;
+    }
+    if (!o)
+      return;
+    const c = i === "return" ? 0 : -1, a = i === "return" ? -1 : 0;
+    f$1.moveCursor(r, c, a, () => {
+      f$1.clearLine(r, 1, () => {
+        e.once("keypress", t);
+      });
+    });
+  };
+  return n && r.write(cursor.hide), e.once("keypress", t), () => {
+    e.off("keypress", t), n && r.write(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, n = o, s = o, t) {
+  const l = getColumns(e ?? stdout), i = dist_default2(o);
+  return wrapAnsi(r, l - i, {
+    hard: true,
+    trim: false
+  }).split(`
+`).map((c, a, g) => {
+    const m = t ? t(c, a) : c;
+    return a === 0 ? `${n}${m}` : a === g.length - 1 ? `${s}${m}` : `${o}${m}`;
+  }).join(`
+`);
+}
+function runValidation(e, a) {
+  if ("~standard" in e) {
+    const n = e["~standard"].validate(a);
+    return n instanceof Promise ? n.then((r) => r.issues?.at(0)?.message) : n.issues?.at(0)?.message;
+  }
+  return e(a);
+}
+var C$1 = class C {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map;
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  get accessible() {
+    return isAccessible(this.opts.accessible);
+  }
+  constructor(t, e = true) {
+    const { input: i = stdin, output: s = stdout, render: r, signal: n, ...o } = t;
+    this.opts = o, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = r.bind(this), this._track = e, this._abortSignal = n, this.input = i, this.output = s;
+  }
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  setSubscriber(t, e) {
+    const i = this._subscribers.get(t) ?? [];
+    i.push(e), this._subscribers.set(t, i);
+  }
+  on(t, e) {
+    this.setSubscriber(t, { cb: e });
+  }
+  once(t, e) {
+    this.setSubscriber(t, { cb: e, once: true });
+  }
+  emit(t, ...e) {
+    const i = this._subscribers.get(t) ?? [], s = [];
+    for (const r of i)
+      r.cb(...e), r.once && s.push(() => i.splice(i.indexOf(r), 1));
+    for (const r of s)
+      r();
+  }
+  prompt() {
+    return new Promise((t) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted)
+          return this.state = "cancel", this.close(), t(CANCEL_SYMBOL);
+        this._abortSignal.addEventListener("abort", () => {
+          this.state = "cancel", this.close();
+        }, { once: true });
+      }
+      this.rl = f__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(cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t(this.value);
+      }), this.once("cancel", () => {
+        this.output.write(cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t(CANCEL_SYMBOL);
+      });
+    });
+  }
+  _isActionKey(t, e) {
+    return t === "\t";
+  }
+  _shouldSubmit(t, e) {
+    return true;
+  }
+  _setValue(t) {
+    this.value = t, this.emit("value", this.value);
+  }
+  _setUserInput(t, e) {
+    this.userInput = t ?? "", 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("");
+  }
+  async onKeypress(t, e) {
+    if (this.state !== "validating") {
+      if (this._track && e.name !== "return" && (e.name && this._isActionKey(t, 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)), t && (t.toLowerCase() === "y" || t.toLowerCase() === "n") && this.emit("confirm", t.toLowerCase() === "y"), this.emit("key", t, e), e?.name === "return" && this._shouldSubmit(t, e)) {
+        if (this.opts.validate) {
+          const i = runValidation(this.opts.validate, this.value);
+          let s;
+          i instanceof Promise ? (this.state = "validating", this.render(), s = await i) : s = i, s && (this.error = s instanceof Error ? s.message : s, this.state = "error", this.rl?.write(this.userInput));
         }
-        else if (arg.startsWith('-')) {
-            throw new Error(`Unknown option ${arg}\n\n${HELP}`);
+        this.state !== "error" && (this.state = "submit");
+      }
+      isActionKey([t, 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 t = wrapAnsi(this._prevFrame, getColumns(this.output), { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(cursor.move(-999, t * -1));
+  }
+  render() {
+    const t = wrapAnsi(this._render(this) ?? "", getColumns(this.output), {
+      hard: true,
+      trim: false
+    });
+    if (t !== this._prevFrame) {
+      if (this.state === "initial")
+        this.output.write(cursor.hide);
+      else {
+        const e = diffLines(this._prevFrame, t), i = getRows(this.output);
+        if (this.restoreCursor(), e) {
+          const s = Math.max(0, e.numLinesAfter - i), r = Math.max(0, e.numLinesBefore - i);
+          let n = e.lines.find((o) => o >= s);
+          if (n === undefined) {
+            this._prevFrame = t;
+            return;
+          }
+          if (e.lines.length === 1) {
+            this.output.write(cursor.move(0, n - r)), this.output.write(erase.lines(1));
+            const o = t.split(`
+`);
+            this.output.write(o[n]), this._prevFrame = t, this.output.write(cursor.move(0, o.length - n - 1));
+            return;
+          } else if (e.lines.length > 1) {
+            if (s < r)
+              n = s;
+            else {
+              const h = n - r;
+              h > 0 && this.output.write(cursor.move(0, h));
+            }
+            this.output.write(erase.down());
+            const m = t.split(`
+`).slice(n);
+            this.output.write(m.join(`
+`)), this._prevFrame = t;
+            return;
+          }
         }
-        else {
-            dir ??= arg;
+        this.output.write(erase.down());
+      }
+      this.output.write(t), this.state === "initial" && (this.state = "active"), this._prevFrame = t;
+    }
+  }
+};
+class r extends C$1 {
+  get cursor() {
+    return this.value ? 0 : 1;
+  }
+  get _value() {
+    return this.cursor === 0;
+  }
+  constructor(t) {
+    super(t, false), this.value = !!t.initialValue, this.on("userInput", () => {
+      this.value = this._value;
+    }), this.on("confirm", (i) => {
+      this.output.write(cursor.move(0, -1)), this.value = i, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+}
+var n$1 = class n extends C$1 {
+  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 o = this.options.findIndex(({ value: s }) => s === e.initialValue), t = o === -1 ? 0 : o;
+    this.cursor = this.options[t]?.disabled ? findCursor(t, 1, this.options) : t, 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 n extends C$1 {
+  get userInputWithCursor() {
+    if (this.state === "submit")
+      return this.userInput;
+    const t = this.userInput;
+    if (this.cursor >= t.length)
+      return `${this.userInput}█`;
+    const r = t.slice(0, this.cursor), s = t.slice(this.cursor, this.cursor + 1), e = t.slice(this.cursor + 1);
+    return `${r}${styleText("inverse", s)}${e}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  constructor(t) {
+    super({
+      ...t,
+      initialUserInput: t.initialUserInput ?? t.initialValue
+    }), this.on("userInput", (r) => {
+      this._setValue(r);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t.defaultValue), this.value === undefined && (this.value = "");
+    });
+  }
+}
+
+// ../../node_modules/.bun/@clack+prompts@1.9.0/node_modules/@clack/prompts/dist/index.mjs
+import { styleText as styleText2, stripVTControlCharacters } from "node:util";
+import process$1 from "node:process";
+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 unicodeOr = (e, o) => unicode ? e : o;
+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 = (e) => {
+  switch (e) {
+    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);
+    case "validating":
+      return styleText2("dim", S_STEP_ACTIVE);
+  }
+};
+var symbolBar = (e) => {
+  switch (e) {
+    case "initial":
+    case "active":
+      return styleText2("cyan", S_BAR);
+    case "cancel":
+      return styleText2("red", S_BAR);
+    case "error":
+      return styleText2("yellow", S_BAR);
+    case "submit":
+      return styleText2("green", S_BAR);
+  }
+};
+function formatInstructionFooter(e, o, r) {
+  const s = r ? `${styleText2("cyan", S_BAR)}  ` : "", n = wrapTextWithPrefix(e, o.join(" • "), s).split(`
+`);
+  return r && n.push(styleText2("cyan", S_BAR_END)), n;
+}
+var E$1 = (l, e, w, p, b, C = false) => {
+  let r = e, O = 0;
+  if (C)
+    for (let i = p - 1;i >= w; i--) {
+      const m = l[i];
+      if (m && (r -= m.length), O++, r <= b)
+        break;
+    }
+  else
+    for (let i = w;i < p; i++) {
+      const m = l[i];
+      if (m && (r -= m.length), O++, r <= b)
+        break;
+    }
+  return { lineCount: r, removals: O };
+};
+var limitOptions = ({
+  cursor: l,
+  options: e,
+  style: w,
+  output: p = process.stdout,
+  maxItems: b = Number.POSITIVE_INFINITY,
+  columnPadding: C = 0,
+  rowPadding: r = 4
+}) => {
+  const i = getColumns(p) - C, m = getRows(p), M = styleText2("dim", "..."), v = Math.max(m - r, 0), a = Math.max(Math.min(b, v), 5);
+  let f = 0;
+  l >= a - 3 && (f = Math.max(Math.min(l - a + 3, e.length - a), 0));
+  let d = a < e.length && f > 0, c = a < e.length && f + a < e.length;
+  const I = Math.min(f + a, e.length), s = [];
+  let g = 0;
+  d && g++, c && g++;
+  const T = f + (d ? 1 : 0), W = I - (c ? 1 : 0);
+  for (let t = T;t < W; t++) {
+    const n = e[t], o = n !== undefined ? w(n, t === l) : "", h = wrapAnsi(o, i, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    s.push(h), g += h.length;
+  }
+  if (g > v) {
+    let t = 0, n = 0, o = g;
+    const h = l - T;
+    let u = v;
+    const L = () => E$1(s, o, 0, h, u), y = () => E$1(s, o, h + 1, s.length, u, true);
+    d ? ({ lineCount: o, removals: t } = L(), o > u && (c || (u -= 1), { lineCount: o, removals: n } = y())) : (c || (u -= 1), { lineCount: o, removals: n } = y(), o > u && (u -= 1, { lineCount: o, removals: t } = L())), t > 0 && (d = true, s.splice(0, t)), n > 0 && (c = true, s.splice(s.length - n, n));
+  }
+  const x = [];
+  d && x.push(M);
+  for (const t of s)
+    for (const n of t)
+      x.push(n);
+  return c && x.push(M), x;
+};
+var confirm = (e) => {
+  const a = e.active ?? "Yes", o = e.inactive ?? "No";
+  return new r({
+    active: a,
+    inactive: o,
+    signal: e.signal,
+    input: e.input,
+    output: e.output,
+    initialValue: e.initialValue ?? true,
+    render() {
+      const i = e.withGuide ?? settings.withGuide, u = `${symbol(this.state)}  `, l = i ? `${styleText2("gray", S_BAR)}  ` : "", f = wrapTextWithPrefix(e.output, e.message, l, u), s = `${i ? `${styleText2("gray", S_BAR)}
+` : ""}${f}
+`, c = this.value ? a : o;
+      switch (this.state) {
+        case "submit": {
+          const r = i ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${s}${r}${styleText2("dim", c)}`;
+        }
+        case "cancel": {
+          const r = i ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${s}${r}${styleText2(["strikethrough", "dim"], c)}${i ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r = i ? `${styleText2("cyan", S_BAR)}  ` : "", g = i ? styleText2("cyan", S_BAR_END) : "";
+          return `${s}${r}${this.value ? `${styleText2("green", S_RADIO_ACTIVE)} ${a}` : `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", a)}`}${e.vertical ? i ? `
+${styleText2("cyan", S_BAR)}  ` : `
+` : ` ${styleText2("dim", "/")} `}${this.value ? `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", o)}` : `${styleText2("green", S_RADIO_ACTIVE)} ${o}`}
+${g}
+`;
         }
+      }
     }
-    return { dir, overwrite, interactive, coreVersion, help };
+  }).prompt();
 };
-/** Version range of `@getsoda/core`: written next to the build, or read from the monorepo when run from sources. */
-const readCoreVersion = () => {
-    const built = fileURLToPath(new URL('../core-version.json', import.meta.url));
-    if (existsSync(built)) {
-        return `^${JSON.parse(readFileSync(built, 'utf8')).version}`;
+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: r = styleText2("gray", S_BAR),
+    output: m = process.stdout,
+    spacing: l = 1,
+    withGuide: c
+  } = {}) => {
+    const t = [], o = c ?? settings.withGuide, f = o ? r : "", O = o ? `${e}  ` : "", u = o ? `${r}  ` : "";
+    for (let i = 0;i < l; i++)
+      t.push(f);
+    const g = Array.isArray(s) ? s : s.split(`
+`);
+    if (g.length > 0) {
+      const [i, ...y] = g;
+      i.length > 0 ? t.push(`${O}${i}`) : t.push(o ? e : "");
+      for (const p of y)
+        p.length > 0 ? t.push(`${u}${p}`) : t.push(o ? r : "");
     }
-    const workspace = fileURLToPath(new URL('../../core/package.json', import.meta.url));
-    return `^${JSON.parse(readFileSync(workspace, 'utf8')).version}`;
+    m.write(`${t.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) });
+  }
 };
-const main = async () => {
-    const args = parseArguments(process.argv.slice(2));
-    if (args.help) {
-        stdout.write(HELP);
-        return;
+var cancel = (o = "", t) => {
+  const i = t?.output ?? process.stdout, e = t?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_END)}  ` : "";
+  i.write(`${e}${styleText2("red", o)}
+
+`);
+};
+var intro = (o = "", t) => {
+  const i = t?.output ?? process.stdout, e = t?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_START)}  ` : "";
+  i.write(`${e}${o}
+`);
+};
+var outro = (o = "", t) => {
+  const i = t?.output ?? process.stdout, e = t?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR)}
+${styleText2("gray", S_BAR_END)}  ` : "";
+  i.write(`${e}${o}
+
+`);
+};
+var W = (o) => o;
+var C = (o, e, s) => {
+  const a = {
+    hard: true,
+    trim: false
+  }, i = wrapAnsi(o, e, a).split(`
+`), c = i.reduce((n, t) => Math.max(dist_default2(t), n), 0), u = i.map(s).reduce((n, t) => Math.max(dist_default2(t), n), 0), g = e - (u - c);
+  return wrapAnsi(o, g, a);
+};
+var note = (o = "", e = "", s) => {
+  const a = s?.output ?? process$1.stdout, i = s?.withGuide ?? settings.withGuide, c = s?.format ?? W, g = ["", ...C(o, getColumns(a) - 6, c).split(`
+`).map(c), ""], n = dist_default2(e), t = Math.max(g.reduce((m, F) => {
+    const O = dist_default2(F);
+    return O > m ? O : m;
+  }, 0), n) + 2, h = g.map((m) => `${styleText2("gray", S_BAR)}  ${m}${" ".repeat(t - dist_default2(m))}${styleText2("gray", S_BAR)}`).join(`
+`), T = i ? `${styleText2("gray", S_BAR)}
+` : "", l$1 = i ? S_CONNECT_LEFT : S_CORNER_BOTTOM_LEFT;
+  a.write(`${T}${styleText2("green", S_STEP_SUBMIT)}  ${styleText2("reset", e)} ${styleText2("gray", S_BAR_H.repeat(Math.max(t - n - 1, 1)) + S_CORNER_TOP_RIGHT)}
+${h}
+${styleText2("gray", l$1 + S_BAR_H.repeat(t + 2) + S_CORNER_BOTTOM_RIGHT)}
+`);
+};
+var Y = 30000;
+var Z = (c) => styleText2("magenta", c);
+var spinner = ({
+  indicator: c = "dots",
+  onCancel: b,
+  output: n = process.stdout,
+  cancelMessage: _,
+  errorMessage: C,
+  frames: M = unicode ? ["◒", "◐", "◓", "◑"] : ["•", "o", "O", "0"],
+  delay: O = unicode ? 80 : 120,
+  signal: g,
+  ...E
+} = {}) => {
+  const u = isCI(), h = isAccessible(E.accessible);
+  let x, I, p = false, l = false, r = "", v, w = performance.now();
+  const y = getColumns(n), F = E?.styleFrame ?? Z, S = (e) => {
+    const s = e > 1 ? C ?? settings.messages.error : _ ?? settings.messages.cancel;
+    l = e === 1, p && (m(s, e), l && typeof b == "function" && b());
+  }, $ = () => S(2), a = () => S(1), H = () => {
+    process.on("uncaughtExceptionMonitor", $), process.on("unhandledRejection", $), process.on("SIGINT", a), process.on("SIGTERM", a), process.on("exit", S), g && g.addEventListener("abort", a);
+  }, B = () => {
+    process.removeListener("uncaughtExceptionMonitor", $), process.removeListener("unhandledRejection", $), process.removeListener("SIGINT", a), process.removeListener("SIGTERM", a), process.removeListener("exit", S), g && g.removeEventListener("abort", a);
+  }, R = () => {
+    if (v === undefined)
+      return;
+    u && n.write(`
+`);
+    const s = wrapAnsi(v, y, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    s.length > 1 && n.write(cursor.up(s.length - 1)), n.write(cursor.to(0)), n.write(erase.down());
+  }, L = (e) => e.replace(/\.+$/, ""), T = (e) => {
+    const s = (performance.now() - e) / 1000, i = Math.floor(s / 60), t = Math.floor(s % 60);
+    return i > 0 ? `[${i}m ${t}s]` : `[${t}s]`;
+  }, N = E.withGuide ?? settings.withGuide, P = (e = "") => {
+    if (p = true, l = false, r = L(e), w = performance.now(), H(), h) {
+      r !== "" && n.write(`${r}
+`), I = setInterval(() => {
+        n.write(r === "" ? `still working
+` : `still working: ${r}
+`);
+      }, Y);
+      return;
     }
-    const interactive = args.interactive ?? stdin.isTTY === true;
-    const prompt = interactive ? createInterface({ input: stdin, output: stdout }) : undefined;
-    try {
-        let dir = args.dir === undefined ? '' : formatTargetDir(args.dir);
-        if (dir === '' && prompt !== undefined) {
-            dir = formatTargetDir((await prompt.question(`Project directory (${DEFAULT_DIR}): `)) || DEFAULT_DIR);
+    x = block({ output: n }), N && n.write(`${styleText2("gray", S_BAR)}
+`);
+    let s = 0, i = 0;
+    I = setInterval(() => {
+      if (u && r === v)
+        return;
+      R(), v = r;
+      const t = F(M[s]);
+      let o;
+      if (u)
+        o = `${t}  ${r}...`;
+      else if (c === "timer")
+        o = `${t}  ${r} ${T(w)}`;
+      else {
+        const j = ".".repeat(Math.floor(i)).slice(0, 3);
+        o = `${t}  ${r}${j}`;
+      }
+      const D = wrapAnsi(o, y, {
+        hard: true,
+        trim: false
+      });
+      n.write(D), s = s + 1 < M.length ? s + 1 : 0, i = i < 4 ? i + 0.125 : 0;
+    }, O);
+  }, m = (e = "", s = 0, i = false) => {
+    if (p) {
+      if (p = false, l = s === 1, clearInterval(I), h || R(), r = e ?? r, !i)
+        if (h) {
+          const t = s === 1 ? _ ?? settings.messages.cancel : s === 2 ? C ?? settings.messages.error : "Done", o = r || t;
+          c === "timer" ? n.write(`${o} ${T(w)}
+`) : n.write(`${o}
+`);
+        } else {
+          const t = s === 0 ? styleText2("green", S_STEP_SUBMIT) : s === 1 ? styleText2("red", S_STEP_CANCEL) : styleText2("red", S_STEP_ERROR);
+          c === "timer" ? n.write(`${t}  ${r} ${T(w)}
+`) : n.write(`${t}  ${r}
+`);
         }
-        dir ||= DEFAULT_DIR;
-        if (!(await isEmptyDir(dir))) {
-            const overwrite = args.overwrite ||
-                (prompt !== undefined &&
-                    /^y(?:es)?$/i.test(await prompt.question(`${dir} is not empty. Remove its files and continue? (y/N) `)));
-            if (!overwrite) {
-                throw new Error(`${dir} is not empty; choose another directory or pass --overwrite`);
-            }
-            await emptyDir(dir);
+      B(), x?.();
+    }
+  };
+  return {
+    start: P,
+    stop: (e = "") => m(e, 0),
+    message: (e = "") => {
+      r = L(e ?? r);
+    },
+    cancel: (e = "") => m(e, 1),
+    error: (e = "") => m(e, 2),
+    clear: () => m("", 0, true),
+    get isCancelled() {
+      return l;
+    }
+  };
+};
+var u2 = {
+  light: unicodeOr("─", "-"),
+  heavy: unicodeOr("━", "="),
+  block: unicodeOr("█", "#")
+};
+var SELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "↑/↓")} to navigate`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var c2 = (t, o) => t.includes(`
+`) ? t.split(`
+`).map((d) => o(d)).join(`
+`) : o(t);
+var select = (t) => {
+  const o = (n, m) => {
+    if (n === undefined)
+      return "";
+    const s = n.label ?? String(n.value);
+    switch (m) {
+      case "disabled":
+        return `${styleText2("gray", S_RADIO_INACTIVE)} ${c2(s, (i) => styleText2("gray", i))}${n.hint ? ` ${styleText2("dim", `(${n.hint ?? "disabled"})`)}` : ""}`;
+      case "selected":
+        return `${c2(s, (i) => styleText2("dim", i))}`;
+      case "active":
+        return `${styleText2("green", S_RADIO_ACTIVE)} ${s}${n.hint ? ` ${styleText2("dim", `(${n.hint})`)}` : ""}`;
+      case "cancelled":
+        return `${c2(s, (i) => styleText2(["strikethrough", "dim"], i))}`;
+      default:
+        return `${styleText2("dim", S_RADIO_INACTIVE)} ${c2(s, (i) => styleText2("dim", i))}`;
+    }
+  }, d = t.showInstructions ?? true;
+  return new n$1({
+    options: t.options,
+    signal: t.signal,
+    input: t.input,
+    output: t.output,
+    initialValue: t.initialValue,
+    render() {
+      const n = t.withGuide ?? settings.withGuide, m = `${symbol(this.state)}  `, s = `${symbolBar(this.state)}  `, i = wrapTextWithPrefix(t.output, t.message, s, m), u = `${n ? `${styleText2("gray", S_BAR)}
+` : ""}${i}
+`;
+      switch (this.state) {
+        case "submit": {
+          const r = n ? `${styleText2("gray", S_BAR)}  ` : "", a = wrapTextWithPrefix(t.output, o(this.options[this.cursor], "selected"), r);
+          return `${u}${a}`;
         }
-        let name = toValidPackageName(basename(resolve(dir)));
-        if (prompt !== undefined) {
-            const answer = (await prompt.question(`Package name (${name}): `)).trim();
-            if (answer !== '' && !isValidPackageName(answer)) {
-                throw new Error(`"${answer}" is not a valid npm package name`);
-            }
-            name = answer || name;
+        case "cancel": {
+          const r = n ? `${styleText2("gray", S_BAR)}  ` : "", a = wrapTextWithPrefix(t.output, o(this.options[this.cursor], "cancelled"), r);
+          return `${u}${a}${n ? `
+${styleText2("gray", S_BAR)}` : ""}`;
         }
-        await createProject({
-            dir,
-            name,
-            coreVersion: args.coreVersion ?? readCoreVersion(),
-            template: fileURLToPath(new URL('../template', import.meta.url)),
-        });
-        const manager = detectPackageManager(process.env.npm_config_user_agent);
-        const cd = relative(process.cwd(), resolve(dir));
-        stdout.write(`\nCreated ${name} in ${resolve(dir)}\n\nNext steps:\n`);
-        if (cd !== '') {
-            stdout.write(`  cd ${cd.includes(' ') ? JSON.stringify(cd) : cd}\n`);
+        default: {
+          const r = n ? `${styleText2("cyan", S_BAR)}  ` : "", a = u.split(`
+`).length, p = d ? formatInstructionFooter(t.output, SELECT_INSTRUCTIONS, n) : n ? [styleText2("cyan", S_BAR_END)] : [], f = p.join(`
+`), b = p.length + 1;
+          return `${u}${r}${limitOptions({
+            output: t.output,
+            cursor: this.cursor,
+            options: this.options,
+            maxItems: t.maxItems,
+            columnPadding: r.length,
+            rowPadding: a + b,
+            style: (g, x) => o(g, g.disabled ? "disabled" : x ? "active" : "inactive")
+          }).join(`
+${r}`)}
+${f}
+`;
         }
-        stdout.write(`  ${manager} install\n  ${manager === 'npm' ? 'npm run' : manager} dev\n`);
+      }
     }
-    finally {
-        prompt?.close();
+  }).prompt();
+};
+var i = `${styleText2("gray", S_BAR)}  `;
+var text = (t) => new n({
+  validate: t.validate,
+  placeholder: t.placeholder,
+  defaultValue: t.defaultValue,
+  initialValue: t.initialValue,
+  output: t.output,
+  signal: t.signal,
+  input: t.input,
+  render() {
+    const r = t?.withGuide ?? settings.withGuide, l = `${`${r ? `${styleText2("gray", S_BAR)}
+` : ""}${symbol(this.state)}  `}${t.message}
+`, d = t.placeholder && t.placeholder.length > 0 ? styleText2("inverse", t.placeholder[0]) + styleText2("dim", t.placeholder.slice(1)) : styleText2(["inverse", "hidden"], "_"), o = this.userInput ? this.userInputWithCursor : d, s = this.value ?? "";
+    switch (this.state) {
+      case "validating": {
+        const n = r ? `${styleText2("cyan", S_BAR)}  ` : "", i = r ? styleText2("cyan", S_BAR_END) : "", c = styleText2("dim", o), $ = styleText2("dim", "Validating...");
+        return `${l}${n}${c}
+${i}  ${$}
+`;
+      }
+      case "error": {
+        const n = this.error ? `  ${styleText2("yellow", this.error)}` : "", i = r ? `${styleText2("yellow", S_BAR)}  ` : "", c = r ? styleText2("yellow", S_BAR_END) : "";
+        return `${l.trim()}
+${i}${o}
+${c}${n}
+`;
+      }
+      case "submit": {
+        const n = s ? `${r ? "  " : ""}${styleText2("dim", s)}` : "", i = r ? styleText2("gray", S_BAR) : "";
+        return `${l}${i}${n}`;
+      }
+      case "cancel": {
+        const n = s ? `  ${styleText2(["strikethrough", "dim"], s)}` : "", i = r ? styleText2("gray", S_BAR) : "";
+        return `${l}${i}${n}${s.trim() ? `
+${i}` : ""}`;
+      }
+      default: {
+        const n = r ? `${styleText2("cyan", S_BAR)}  ` : "", i = r ? styleText2("cyan", S_BAR_END) : "";
+        return `${l}${n}${o}
+${i}
+`;
+      }
+    }
+  }
+}).prompt();
+
+// src/index.ts
+import { spawn } from "node:child_process";
+import { basename as basename2, relative, resolve as resolve2 } from "node:path";
+import { stdin as stdin2, stdout as stdout2 } from "node:process";
+import { fileURLToPath } from "node:url";
+import { styleText as styleText3 } from "node:util";
+// ../core/package.json
+var version = "0.2.1";
+// package.json
+var version2 = "0.2.1";
+
+// src/project.ts
+import { existsSync } from "node:fs";
+import { cp, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+var TEMPLATES = [
+  { name: "minimal", label: "Minimal", hint: "a module, a controller, a service and a test" },
+  { name: "demo", label: "Demo", hint: "users with validation, a guard, logging and CORS" }
+];
+var RENAMED = { _gitignore: ".gitignore", "_oxlintrc.json": ".oxlintrc.json" };
+var formatTargetDir = (dir) => dir.trim().replace(/[<>:"\\|?*]/g, "").replace(/\/+$/, "");
+var isValidPackageName = (name) => /^(?:@[a-z\d\-*~][a-z\d\-*._~]*\/)?[a-z\d\-~][a-z\d\-._~]*$/.test(name);
+var toValidPackageName = (name) => name.trim().toLowerCase().replace(/\s+/g, "-").replace(/^[._]/, "").replace(/[^a-z\d\-~]+/g, "-");
+var isEmptyDir = async (dir) => {
+  if (!existsSync(dir)) {
+    return true;
+  }
+  const entries = await readdir(dir);
+  return entries.length === 0 || entries.length === 1 && entries[0] === ".git";
+};
+var emptyDir = async (dir) => {
+  for (const entry of await readdir(dir)) {
+    if (entry !== ".git") {
+      await rm(join(dir, entry), { recursive: true, force: true });
     }
+  }
+};
+var createProject = async (options) => {
+  const root = resolve(options.dir);
+  await cp(options.template, root, { recursive: true });
+  for (const [from, to] of Object.entries(RENAMED)) {
+    if (existsSync(join(root, from))) {
+      await rename(join(root, from), join(root, to));
+    }
+  }
+  const manifestPath = join(root, "package.json");
+  const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+  manifest.name = options.name ?? toValidPackageName(basename(root));
+  manifest.dependencies["@getsoda/core"] = options.coreVersion;
+  await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+};
+var detectPackageManager = (userAgent) => {
+  const name = userAgent?.split(" ")[0]?.split("/")[0];
+  return name === undefined || name === "" ? "bun" : name;
+};
+var runScriptCommand = (manager, script) => manager === "npm" ? `npm run ${script}` : `${manager} ${script}`;
+
+// src/index.ts
+var DEFAULT_DIR = "soda-app";
+var HELP = `Usage: create-soda [directory] [options]
+
+Creates a Soda project. Asks questions in a terminal.
+
+Options:
+  -t, --template <name>              template to use (default: ${TEMPLATES[0].name})
+  --install, --no-install            install dependencies
+  --overwrite                        empty the directory if it is not empty
+  --interactive, --no-interactive    force or disable questions
+  --core-version <range>             version of @getsoda/core to depend on
+  -h, --help                         show this help
+
+Templates:
+${TEMPLATES.map((template) => `  ${template.name.padEnd(10)} ${template.hint}`).join(`
+`)}
+`;
+var parseArguments = (args) => {
+  let dir;
+  let template;
+  let install;
+  let overwrite = false;
+  let interactive;
+  let coreVersion;
+  let help = false;
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-t" || arg === "--template") {
+      template = args[++i];
+    } else if (arg === "--install" || arg === "--no-install") {
+      install = arg === "--install";
+    } else if (arg === "--overwrite") {
+      overwrite = true;
+    } else if (arg === "--interactive" || arg === "--no-interactive") {
+      interactive = arg === "--interactive";
+    } else if (arg === "--core-version") {
+      coreVersion = args[++i];
+    } else if (arg === "-h" || arg === "--help") {
+      help = true;
+    } else if (arg.startsWith("-")) {
+      throw new Error(`Unknown option ${arg}
+
+${HELP}`);
+    } else {
+      dir ??= arg;
+    }
+  }
+  return { dir, template, install, overwrite, interactive, coreVersion, help };
+};
+
+class Cancelled extends Error {
+}
+var answer = async (question) => {
+  const value = await question;
+  if (isCancel(value)) {
+    throw new Cancelled;
+  }
+  return value;
+};
+var run = (command, args, cwd) => new Promise((done, fail) => {
+  const child = spawn(command, args, { cwd, shell: process.platform === "win32" });
+  let output = "";
+  child.stdout.on("data", (chunk) => output += chunk);
+  child.stderr.on("data", (chunk) => output += chunk);
+  child.on("error", fail);
+  child.on("close", (code) => done({ code: code ?? 1, output }));
+});
+var installDependencies = async (root, manager) => {
+  const spinner2 = spinner();
+  spinner2.start(`Installing dependencies with ${manager}`);
+  const { code, output } = await run(manager, ["install"], root);
+  if (code !== 0) {
+    spinner2.error(`${manager} install failed`);
+    process.stderr.write(output);
+    throw new Error(`${manager} install exited with code ${code}`);
+  }
+  spinner2.stop("Installed dependencies");
+};
+var main = async () => {
+  const args = parseArguments(process.argv.slice(2));
+  if (args.help) {
+    stdout2.write(HELP);
+    return;
+  }
+  if (args.template !== undefined && !TEMPLATES.some((template) => template.name === args.template)) {
+    throw new Error(`Unknown template "${args.template}"; use ${TEMPLATES.map((template) => template.name).join(" or ")}`);
+  }
+  const interactive = args.interactive ?? stdin2.isTTY === true;
+  intro(`${styleText3(["bgCyan", "black"], " create-soda ")} ${styleText3("dim", `v${version2}`)}`);
+  let dir = formatTargetDir(args.dir ?? "");
+  if (dir === "" && interactive) {
+    const input = await answer(text({
+      message: "Project directory",
+      placeholder: DEFAULT_DIR,
+      defaultValue: DEFAULT_DIR,
+      validate: (value) => value === undefined || value === "" || formatTargetDir(value) !== "" ? undefined : "Invalid directory name"
+    }));
+    dir = formatTargetDir(input);
+  }
+  dir ||= DEFAULT_DIR;
+  const empty = await isEmptyDir(dir);
+  const overwrite = !empty && (args.overwrite || interactive && await answer(confirm({
+    message: `${dir === "." ? "The current directory" : dir} is not empty. Remove its files and continue?`,
+    initialValue: false
+  })));
+  if (!empty && !overwrite) {
+    throw new Error(`${dir} is not empty; choose another directory or pass --overwrite`);
+  }
+  const root = resolve2(dir);
+  let name = basename2(root);
+  if (!isValidPackageName(name)) {
+    const suggested = toValidPackageName(name);
+    name = interactive ? await answer(text({
+      message: "Package name",
+      placeholder: suggested,
+      defaultValue: suggested,
+      validate: (value) => value === undefined || value === "" || isValidPackageName(value) ? undefined : "Invalid package name"
+    })) : suggested;
+  }
+  const template = args.template ?? (interactive ? await answer(select({
+    message: "Template",
+    options: TEMPLATES.map((option) => ({ value: option.name, label: option.label, hint: option.hint }))
+  })) : TEMPLATES[0].name);
+  const manager = detectPackageManager(process.env.npm_config_user_agent);
+  const install = args.install ?? (interactive && await answer(confirm({ message: `Install dependencies with ${manager}?` })));
+  if (overwrite) {
+    await emptyDir(dir);
+  }
+  await createProject({
+    dir,
+    name,
+    coreVersion: args.coreVersion ?? `^${version}`,
+    template: fileURLToPath(new URL(`../templates/${template}`, import.meta.url))
+  });
+  log.success(`Created ${name} in ${root}`);
+  if (install) {
+    await installDependencies(root, manager);
+  }
+  const cd = relative(process.cwd(), root);
+  const steps = [
+    ...cd === "" ? [] : [`cd ${cd.includes(" ") ? JSON.stringify(cd) : cd}`],
+    ...install ? [] : [`${manager} install`],
+    runScriptCommand(manager, "dev")
+  ];
+  note(steps.join(`
+`), "Next steps");
+  outro(`Docs: ${styleText3("underline", "https://github.com/getsodajs/soda")}`);
 };
 main().catch((error) => {
-    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-    process.exit(1);
+  if (error instanceof Cancelled) {
+    cancel("Cancelled");
+  } else {
+    cancel(error instanceof Error ? error.message : String(error), { output: process.stderr });
+  }
+  process.exit(1);
 });