toiljs 0.0.14 → 0.0.16

package/build/cli/index.js

@@ -1,203 +1,2938 @@
 #!/usr/bin/env node
-import { build, dev, start } from 'toiljs/compiler';
-import { runConfigure } from './configure.js';
-import { runCreate } from './create.js';
-import { runDoctor } from './doctor.js';
-import { runUpdate } from './update.js';
-import { PREPROCESSORS } from './features.js';
-import { accent, banner, bold, danger, dim, success, version } from './ui.js';
-function parseArgs(argv) {
-    const flags = {};
-    for (let i = 0; i < argv.length; i++) {
-        const arg = argv[i];
-        switch (arg) {
-            case '--root':
-                flags.root = argv[++i];
-                break;
-            case '--port': {
-                const port = Number(argv[++i]);
-                if (!Number.isNaN(port))
-                    flags.port = port;
-                break;
-            }
-            case '--template':
-            case '-t': {
-                const t = argv[++i];
-                if (t === 'app' || t === 'minimal')
-                    flags.template = t;
-                break;
-            }
-            case '--pm':
-                flags.pm = argv[++i];
-                break;
-            case '--style': {
-                const s = argv[++i];
-                if (PREPROCESSORS.includes(s))
-                    flags.preprocessor = s;
-                break;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/sisteransi/src/index.js
+var require_src = __commonJS({
+  "node_modules/sisteransi/src/index.js"(exports, module) {
+    "use strict";
+    var ESC2 = "\x1B";
+    var CSI2 = `${ESC2}[`;
+    var beep = "\x07";
+    var cursor = {
+      to(x3, y) {
+        if (!y) return `${CSI2}${x3 + 1}G`;
+        return `${CSI2}${y + 1};${x3 + 1}H`;
+      },
+      move(x3, y) {
+        let ret = "";
+        if (x3 < 0) ret += `${CSI2}${-x3}D`;
+        else if (x3 > 0) ret += `${CSI2}${x3}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/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "node_modules/picocolors/picocolors.js"(exports, module) {
+    var p2 = process || {};
+    var argv = p2.argv || [];
+    var env = p2.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p2.platform === "win32" || (p2.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f2 = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f2("\x1B[0m", "\x1B[0m"),
+        bold: f2("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f2("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f2("\x1B[3m", "\x1B[23m"),
+        underline: f2("\x1B[4m", "\x1B[24m"),
+        inverse: f2("\x1B[7m", "\x1B[27m"),
+        hidden: f2("\x1B[8m", "\x1B[28m"),
+        strikethrough: f2("\x1B[9m", "\x1B[29m"),
+        black: f2("\x1B[30m", "\x1B[39m"),
+        red: f2("\x1B[31m", "\x1B[39m"),
+        green: f2("\x1B[32m", "\x1B[39m"),
+        yellow: f2("\x1B[33m", "\x1B[39m"),
+        blue: f2("\x1B[34m", "\x1B[39m"),
+        magenta: f2("\x1B[35m", "\x1B[39m"),
+        cyan: f2("\x1B[36m", "\x1B[39m"),
+        white: f2("\x1B[37m", "\x1B[39m"),
+        gray: f2("\x1B[90m", "\x1B[39m"),
+        bgBlack: f2("\x1B[40m", "\x1B[49m"),
+        bgRed: f2("\x1B[41m", "\x1B[49m"),
+        bgGreen: f2("\x1B[42m", "\x1B[49m"),
+        bgYellow: f2("\x1B[43m", "\x1B[49m"),
+        bgBlue: f2("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f2("\x1B[45m", "\x1B[49m"),
+        bgCyan: f2("\x1B[46m", "\x1B[49m"),
+        bgWhite: f2("\x1B[47m", "\x1B[49m"),
+        blackBright: f2("\x1B[90m", "\x1B[39m"),
+        redBright: f2("\x1B[91m", "\x1B[39m"),
+        greenBright: f2("\x1B[92m", "\x1B[39m"),
+        yellowBright: f2("\x1B[93m", "\x1B[39m"),
+        blueBright: f2("\x1B[94m", "\x1B[39m"),
+        magentaBright: f2("\x1B[95m", "\x1B[39m"),
+        cyanBright: f2("\x1B[96m", "\x1B[39m"),
+        whiteBright: f2("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f2("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f2("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f2("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f2("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f2("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f2("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f2("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f2("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
+// src/cli/index.ts
+import { build, dev, start } from "toiljs/compiler";
+
+// src/cli/configure.ts
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+
+// node_modules/@clack/core/dist/index.mjs
+import { styleText as v } from "node:util";
+import { stdout as x, stdin as D } from "node:process";
+import * as b from "node:readline";
+import G from "node:readline";
+
+// node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = /* @__PURE__ */ (() => {
+  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 = (x3) => {
+  return x3 === 12288 || x3 >= 65281 && x3 <= 65376 || x3 >= 65504 && x3 <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x3) => {
+  return x3 === 8987 || x3 === 9001 || x3 >= 12272 && x3 <= 12287 || x3 >= 12289 && x3 <= 12350 || x3 >= 12441 && x3 <= 12543 || x3 >= 12549 && x3 <= 12591 || x3 >= 12593 && x3 <= 12686 || x3 >= 12688 && x3 <= 12771 || x3 >= 12783 && x3 <= 12830 || x3 >= 12832 && x3 <= 12871 || x3 >= 12880 && x3 <= 19903 || x3 >= 65040 && x3 <= 65049 || x3 >= 65072 && x3 <= 65106 || x3 >= 65108 && x3 <= 65126 || x3 >= 65128 && x3 <= 65131 || x3 >= 127488 && x3 <= 127490 || x3 >= 127504 && x3 <= 127547 || x3 >= 127552 && x3 <= 127560 || x3 >= 131072 && x3 <= 196605 || x3 >= 196608 && x3 <= 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 = "\x9B";
+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 void 0;
+};
+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 === void 0 ? 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 !== void 0 && 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("\n");
+  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 !== void 0) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? void 0 : code;
+      } else if (groups?.uri !== void 0) {
+        escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+      }
+    }
+    if (preString[i + 1] === "\n") {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : void 0;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === "\n") {
+      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("\n");
+}
+
+// node_modules/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+import { ReadStream as O } from "node:tty";
+function f(r, t, s) {
+  if (!s.some((o) => !o.disabled)) return r;
+  const e2 = r + t, i = Math.max(s.length - 1, 0), n = e2 < 0 ? i : e2 > i ? 0 : e2;
+  return s[n].disabled ? f(n, t < 0 ? -1 : 1, s) : n;
+}
+var K = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var j = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+var h = { actions: new Set(K), aliases: /* @__PURE__ */ new Map([["k", "up"], ["j", "down"], ["h", "left"], ["l", "right"], ["", "cancel"], ["escape", "cancel"]]), messages: { cancel: "Canceled", error: "Something went wrong" }, withGuide: true, date: { monthNames: [...j], messages: { required: "Please enter a valid date", invalidMonth: "There are only 12 months in a year", invalidDay: (r, t) => `There are only ${r} days in ${t}`, afterMin: (r) => `Date must be on or after ${r.toISOString().slice(0, 10)}`, beforeMax: (r) => `Date must be on or before ${r.toISOString().slice(0, 10)}` } } };
+function C(r, t) {
+  if (typeof r == "string") return h.aliases.get(r) === t;
+  for (const s of r) if (s !== void 0 && C(s, t)) return true;
+  return false;
+}
+function Y(r, t) {
+  if (r === t) return;
+  const s = r.split(`
+`), e2 = t.split(`
+`), i = Math.max(s.length, e2.length), n = [];
+  for (let o = 0; o < i; o++) s[o] !== e2[o] && n.push(o);
+  return { lines: n, numLinesBefore: s.length, numLinesAfter: e2.length, numLines: i };
+}
+var q = globalThis.process.platform.startsWith("win");
+var k = /* @__PURE__ */ Symbol("clack:cancel");
+function R(r) {
+  return r === k;
+}
+function w(r, t) {
+  const s = r;
+  s.isTTY && s.setRawMode(t);
+}
+function W({ input: r = D, output: t = x, overwrite: s = true, hideCursor: e2 = true } = {}) {
+  const i = b.createInterface({ input: r, output: t, prompt: "", tabSize: 1 });
+  b.emitKeypressEvents(r, i), r instanceof O && r.isTTY && r.setRawMode(true);
+  const n = (o, { name: u, sequence: a }) => {
+    const l = String(o);
+    if (C([l, u, a], "cancel")) {
+      e2 && t.write(import_sisteransi.cursor.show), process.exit(0);
+      return;
+    }
+    if (!s) return;
+    const c = u === "return" ? 0 : -1, y = u === "return" ? -1 : 0;
+    b.moveCursor(t, c, y, () => {
+      b.clearLine(t, 1, () => {
+        r.once("keypress", n);
+      });
+    });
+  };
+  return e2 && t.write(import_sisteransi.cursor.hide), r.once("keypress", n), () => {
+    r.off("keypress", n), e2 && t.write(import_sisteransi.cursor.show), r instanceof O && r.isTTY && !q && r.setRawMode(false), i.terminal = false, i.close();
+  };
+}
+var A = (r) => "columns" in r && typeof r.columns == "number" ? r.columns : 80;
+var L = (r) => "rows" in r && typeof r.rows == "number" ? r.rows : 20;
+function B(r, t, s, e2 = s, i = s, n) {
+  const o = A(r ?? x);
+  return wrapAnsi(t, o - s.length, { hard: true, trim: false }).split(`
+`).map((u, a, l) => {
+    const c = n ? n(u, a) : u;
+    return a === 0 ? `${e2}${c}` : a === l.length - 1 ? `${i}${c}` : `${s}${c}`;
+  }).join(`
+`);
+}
+function P(r, t) {
+  if ("~standard" in r) {
+    const s = r["~standard"].validate(t);
+    if (s instanceof Promise) throw new TypeError("Schema validation must be synchronous. Update `validate()` and remove any asynchronous logic.");
+    return s.issues?.at(0)?.message;
+  }
+  return r(t);
+}
+var m = class {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map();
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  constructor(t, s = true) {
+    const { input: e2 = D, output: i = x, render: n, signal: o, ...u } = t;
+    this.opts = u, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = n.bind(this), this._track = s, this._abortSignal = o, this.input = e2, this.output = i;
+  }
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  setSubscriber(t, s) {
+    const e2 = this._subscribers.get(t) ?? [];
+    e2.push(s), this._subscribers.set(t, e2);
+  }
+  on(t, s) {
+    this.setSubscriber(t, { cb: s });
+  }
+  once(t, s) {
+    this.setSubscriber(t, { cb: s, once: true });
+  }
+  emit(t, ...s) {
+    const e2 = this._subscribers.get(t) ?? [], i = [];
+    for (const n of e2) n.cb(...s), n.once && i.push(() => e2.splice(e2.indexOf(n), 1));
+    for (const n of i) n();
+  }
+  prompt() {
+    return new Promise((t) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted) return this.state = "cancel", this.close(), t(k);
+        this._abortSignal.addEventListener("abort", () => {
+          this.state = "cancel", this.close();
+        }, { once: true });
+      }
+      this.rl = G.createInterface({ input: this.input, tabSize: 2, prompt: "", escapeCodeTimeout: 50, terminal: true }), this.rl.prompt(), this.opts.initialUserInput !== void 0 && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), w(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), w(this.input, false), t(this.value);
+      }), this.once("cancel", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), w(this.input, false), t(k);
+      });
+    });
+  }
+  _isActionKey(t, s) {
+    return t === "	";
+  }
+  _shouldSubmit(t, s) {
+    return true;
+  }
+  _setValue(t) {
+    this.value = t, this.emit("value", this.value);
+  }
+  _setUserInput(t, s) {
+    this.userInput = t ?? "", this.emit("userInput", this.userInput), s && 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(t, s) {
+    if (this._track && s.name !== "return" && (s.name && this._isActionKey(t, s) && 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"), s?.name && (!this._track && h.aliases.has(s.name) && this.emit("cursor", h.aliases.get(s.name)), h.actions.has(s.name) && this.emit("cursor", s.name)), t && (t.toLowerCase() === "y" || t.toLowerCase() === "n") && this.emit("confirm", t.toLowerCase() === "y"), this.emit("key", t, s), s?.name === "return" && this._shouldSubmit(t, s)) {
+      if (this.opts.validate) {
+        const e2 = P(this.opts.validate, this.value);
+        e2 && (this.error = e2 instanceof Error ? e2.message : e2, this.state = "error", this.rl?.write(this.userInput));
+      }
+      this.state !== "error" && (this.state = "submit");
+    }
+    C([t, s?.name, s?.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(`
+`), w(this.input, false), this.rl?.close(), this.rl = void 0, this.emit(`${this.state}`, this.value), this.unsubscribe();
+  }
+  restoreCursor() {
+    const t = wrapAnsi(this._prevFrame, process.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(import_sisteransi.cursor.move(-999, t * -1));
+  }
+  render() {
+    const t = wrapAnsi(this._render(this) ?? "", process.stdout.columns, { hard: true, trim: false });
+    if (t !== this._prevFrame) {
+      if (this.state === "initial") this.output.write(import_sisteransi.cursor.hide);
+      else {
+        const s = Y(this._prevFrame, t), e2 = L(this.output);
+        if (this.restoreCursor(), s) {
+          const i = Math.max(0, s.numLinesAfter - e2), n = Math.max(0, s.numLinesBefore - e2);
+          let o = s.lines.find((u) => u >= i);
+          if (o === void 0) {
+            this._prevFrame = t;
+            return;
+          }
+          if (s.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, o - n)), this.output.write(import_sisteransi.erase.lines(1));
+            const u = t.split(`
+`);
+            this.output.write(u[o]), this._prevFrame = t, this.output.write(import_sisteransi.cursor.move(0, u.length - o - 1));
+            return;
+          } else if (s.lines.length > 1) {
+            if (i < n) o = i;
+            else {
+              const a = o - n;
+              a > 0 && this.output.write(import_sisteransi.cursor.move(0, a));
             }
-            case '--tailwind':
-                flags.tailwind = true;
-                break;
-            case '--no-tailwind':
-                flags.tailwind = false;
-                break;
-            case '--ai':
-                flags.ai = true;
-                break;
-            case '--no-ai':
-                flags.ai = false;
-                break;
-            case '--images':
-                flags.images = true;
-                break;
-            case '--no-images':
-                flags.images = false;
-                break;
-            case '--install':
-                flags.install = true;
-                break;
-            case '--no-install':
-                flags.install = false;
-                break;
-            case '--git':
-                flags.git = true;
-                break;
-            case '--no-git':
-                flags.git = false;
-                break;
-            case '-y':
-            case '--yes':
-                flags.yes = true;
-                break;
-            case '--json':
-                flags.json = true;
-                break;
-            case '--target':
-                flags.target = argv[++i];
-                break;
-            default:
-                if (!arg.startsWith('-') && flags.name === undefined)
-                    flags.name = arg;
+            this.output.write(import_sisteransi.erase.down());
+            const u = t.split(`
+`).slice(o);
+            this.output.write(u.join(`
+`)), this._prevFrame = t;
+            return;
+          }
         }
+        this.output.write(import_sisteransi.erase.down());
+      }
+      this.output.write(t), this.state === "initial" && (this.state = "active"), this._prevFrame = t;
+    }
+  }
+};
+var Z = class extends m {
+  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", (s) => {
+      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = s, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+};
+var ut = class extends m {
+  options;
+  cursor = 0;
+  get _value() {
+    return this.options[this.cursor].value;
+  }
+  get _enabledOptions() {
+    return this.options.filter((t) => t.disabled !== true);
+  }
+  toggleAll() {
+    const t = this._enabledOptions, s = this.value !== void 0 && this.value.length === t.length;
+    this.value = s ? [] : t.map((e2) => e2.value);
+  }
+  toggleInvert() {
+    const t = this.value;
+    if (!t) return;
+    const s = this._enabledOptions.filter((e2) => !t.includes(e2.value));
+    this.value = s.map((e2) => e2.value);
+  }
+  toggleValue() {
+    this.value === void 0 && (this.value = []);
+    const t = this.value.includes(this._value);
+    this.value = t ? this.value.filter((s) => s !== this._value) : [...this.value, this._value];
+  }
+  constructor(t) {
+    super(t, false), this.options = t.options, this.value = [...t.initialValues ?? []];
+    const s = Math.max(this.options.findIndex(({ value: e2 }) => e2 === t.cursorAt), 0);
+    this.cursor = this.options[s].disabled ? f(s, 1, this.options) : s, this.on("key", (e2, i) => {
+      i.name === "a" && this.toggleAll(), i.name === "i" && this.toggleInvert();
+    }), this.on("cursor", (e2) => {
+      switch (e2) {
+        case "left":
+        case "up":
+          this.cursor = f(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = f(this.cursor, 1, this.options);
+          break;
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+};
+var ht = class extends m {
+  options;
+  cursor = 0;
+  get _selectedValue() {
+    return this.options[this.cursor];
+  }
+  changeValue() {
+    this.value = this._selectedValue.value;
+  }
+  constructor(t) {
+    super(t, false), this.options = t.options;
+    const s = this.options.findIndex(({ value: i }) => i === t.initialValue), e2 = s === -1 ? 0 : s;
+    this.cursor = this.options[e2].disabled ? f(e2, 1, this.options) : e2, this.changeValue(), this.on("cursor", (i) => {
+      switch (i) {
+        case "left":
+        case "up":
+          this.cursor = f(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = f(this.cursor, 1, this.options);
+          break;
+      }
+      this.changeValue();
+    });
+  }
+};
+var ct = class extends m {
+  get userInputWithCursor() {
+    if (this.state === "submit") return this.userInput;
+    const t = this.userInput;
+    if (this.cursor >= t.length) return `${this.userInput}\u2588`;
+    const s = t.slice(0, this.cursor), [e2, ...i] = t.slice(this.cursor);
+    return `${s}${v("inverse", e2)}${i.join("")}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  constructor(t) {
+    super({ ...t, initialUserInput: t.initialUserInput ?? t.initialValue }), this.on("userInput", (s) => {
+      this._setValue(s);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t.defaultValue), this.value === void 0 && (this.value = "");
+    });
+  }
+};
+
+// node_modules/@clack/prompts/dist/index.mjs
+import { styleText as e, stripVTControlCharacters as ot2 } from "node:util";
+import V2 from "node:process";
+var import_sisteransi2 = __toESM(require_src(), 1);
+function se() {
+  return V2.platform !== "win32" ? V2.env.TERM !== "linux" : !!V2.env.CI || !!V2.env.WT_SESSION || !!V2.env.TERMINUS_SUBLIME || V2.env.ConEmuTask === "{cmd::Cmder}" || V2.env.TERM_PROGRAM === "Terminus-Sublime" || V2.env.TERM_PROGRAM === "vscode" || V2.env.TERM === "xterm-256color" || V2.env.TERM === "alacritty" || V2.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var tt = se();
+var at2 = () => process.env.CI === "true";
+var w2 = (t, i) => tt ? t : i;
+var _t = w2("\u25C6", "*");
+var ut2 = w2("\u25A0", "x");
+var lt2 = w2("\u25B2", "x");
+var H = w2("\u25C7", "o");
+var ct2 = w2("\u250C", "T");
+var $ = w2("\u2502", "|");
+var x2 = w2("\u2514", "\u2014");
+var xt = w2("\u2510", "T");
+var Et = w2("\u2518", "\u2014");
+var z2 = w2("\u25CF", ">");
+var U = w2("\u25CB", " ");
+var et = w2("\u25FB", "[\u2022]");
+var K2 = w2("\u25FC", "[+]");
+var Y2 = w2("\u25FB", "[ ]");
+var Gt = w2("\u25AA", "\u2022");
+var st = w2("\u2500", "-");
+var $t = w2("\u256E", "+");
+var Mt = w2("\u251C", "+");
+var dt = w2("\u256F", "+");
+var ht2 = w2("\u2570", "+");
+var Ot = w2("\u256D", "+");
+var pt = w2("\u25CF", "\u2022");
+var mt = w2("\u25C6", "*");
+var gt = w2("\u25B2", "!");
+var yt = w2("\u25A0", "x");
+var P2 = (t) => {
+  switch (t) {
+    case "initial":
+    case "active":
+      return e("cyan", _t);
+    case "cancel":
+      return e("red", ut2);
+    case "error":
+      return e("yellow", lt2);
+    case "submit":
+      return e("green", H);
+  }
+};
+var ft = (t) => {
+  switch (t) {
+    case "initial":
+    case "active":
+      return e("cyan", $);
+    case "cancel":
+      return e("red", $);
+    case "error":
+      return e("yellow", $);
+    case "submit":
+      return e("green", $);
+  }
+};
+var Pt = (t, i, s, r, u, n = false) => {
+  let a = i, c = 0;
+  if (n) for (let o = r - 1; o >= s && (a -= t[o].length, c++, !(a <= u)); o--) ;
+  else for (let o = s; o < r && (a -= t[o].length, c++, !(a <= u)); o++) ;
+  return { lineCount: a, removals: c };
+};
+var F = ({ cursor: t, options: i, style: s, output: r = process.stdout, maxItems: u = Number.POSITIVE_INFINITY, columnPadding: n = 0, rowPadding: a = 4 }) => {
+  const c = A(r) - n, o = L(r), l = e("dim", "..."), d = Math.max(o - a, 0), g = Math.max(Math.min(u, d), 5);
+  let p2 = 0;
+  t >= g - 3 && (p2 = Math.max(Math.min(t - g + 3, i.length - g), 0));
+  let f2 = g < i.length && p2 > 0, h2 = g < i.length && p2 + g < i.length;
+  const I = Math.min(p2 + g, i.length), m2 = [];
+  let y = 0;
+  f2 && y++, h2 && y++;
+  const v2 = p2 + (f2 ? 1 : 0), C2 = I - (h2 ? 1 : 0);
+  for (let b2 = v2; b2 < C2; b2++) {
+    const G2 = wrapAnsi(s(i[b2], b2 === t), c, { hard: true, trim: false }).split(`
+`);
+    m2.push(G2), y += G2.length;
+  }
+  if (y > d) {
+    let b2 = 0, G2 = 0, M = y;
+    const N = t - v2;
+    let O2 = d;
+    const j2 = () => Pt(m2, M, 0, N, O2), k2 = () => Pt(m2, M, N + 1, m2.length, O2, true);
+    f2 ? ({ lineCount: M, removals: b2 } = j2(), M > O2 && (h2 || (O2 -= 1), { lineCount: M, removals: G2 } = k2())) : (h2 || (O2 -= 1), { lineCount: M, removals: G2 } = k2(), M > O2 && (O2 -= 1, { lineCount: M, removals: b2 } = j2())), b2 > 0 && (f2 = true, m2.splice(0, b2)), G2 > 0 && (h2 = true, m2.splice(m2.length - G2, G2));
+  }
+  const S = [];
+  f2 && S.push(l);
+  for (const b2 of m2) for (const G2 of b2) S.push(G2);
+  return h2 && S.push(l), S;
+};
+var le = (t) => {
+  const i = t.active ?? "Yes", s = t.inactive ?? "No";
+  return new Z({ active: i, inactive: s, signal: t.signal, input: t.input, output: t.output, initialValue: t.initialValue ?? true, render() {
+    const r = t.withGuide ?? h.withGuide, u = `${P2(this.state)}  `, n = r ? `${e("gray", $)}  ` : "", a = B(t.output, t.message, n, u), c = `${r ? `${e("gray", $)}
+` : ""}${a}
+`, o = this.value ? i : s;
+    switch (this.state) {
+      case "submit": {
+        const l = r ? `${e("gray", $)}  ` : "";
+        return `${c}${l}${e("dim", o)}`;
+      }
+      case "cancel": {
+        const l = r ? `${e("gray", $)}  ` : "";
+        return `${c}${l}${e(["strikethrough", "dim"], o)}${r ? `
+${e("gray", $)}` : ""}`;
+      }
+      default: {
+        const l = r ? `${e("cyan", $)}  ` : "", d = r ? e("cyan", x2) : "";
+        return `${c}${l}${this.value ? `${e("green", z2)} ${i}` : `${e("dim", U)} ${e("dim", i)}`}${t.vertical ? r ? `
+${e("cyan", $)}  ` : `
+` : ` ${e("dim", "/")} `}${this.value ? `${e("dim", U)} ${e("dim", s)}` : `${e("green", z2)} ${s}`}
+${d}
+`;
+      }
+    }
+  } }).prompt();
+};
+var ge = (t = "", i) => {
+  const s = i?.output ?? process.stdout, r = i?.withGuide ?? h.withGuide ? `${e("gray", x2)}  ` : "";
+  s.write(`${r}${e("red", t)}
+
+`);
+};
+var ye = (t = "", i) => {
+  const s = i?.output ?? process.stdout, r = i?.withGuide ?? h.withGuide ? `${e("gray", ct2)}  ` : "";
+  s.write(`${r}${t}
+`);
+};
+var fe = (t = "", i) => {
+  const s = i?.output ?? process.stdout, r = i?.withGuide ?? h.withGuide ? `${e("gray", $)}
+${e("gray", x2)}  ` : "";
+  s.write(`${r}${t}
+
+`);
+};
+var Q = (t, i) => t.split(`
+`).map((s) => i(s)).join(`
+`);
+var we = (t) => {
+  const i = (r, u) => {
+    const n = r.label ?? String(r.value);
+    return u === "disabled" ? `${e("gray", Y2)} ${Q(n, (a) => e(["strikethrough", "gray"], a))}${r.hint ? ` ${e("dim", `(${r.hint ?? "disabled"})`)}` : ""}` : u === "active" ? `${e("cyan", et)} ${n}${r.hint ? ` ${e("dim", `(${r.hint})`)}` : ""}` : u === "selected" ? `${e("green", K2)} ${Q(n, (a) => e("dim", a))}${r.hint ? ` ${e("dim", `(${r.hint})`)}` : ""}` : u === "cancelled" ? `${Q(n, (a) => e(["strikethrough", "dim"], a))}` : u === "active-selected" ? `${e("green", K2)} ${n}${r.hint ? ` ${e("dim", `(${r.hint})`)}` : ""}` : u === "submitted" ? `${Q(n, (a) => e("dim", a))}` : `${e("dim", Y2)} ${Q(n, (a) => e("dim", a))}`;
+  }, s = t.required ?? true;
+  return new ut({ options: t.options, signal: t.signal, input: t.input, output: t.output, initialValues: t.initialValues, required: s, cursorAt: t.cursorAt, validate(r) {
+    if (s && (r === void 0 || r.length === 0)) return `Please select at least one option.
+${e("reset", e("dim", `Press ${e(["gray", "bgWhite", "inverse"], " space ")} to select, ${e("gray", e("bgWhite", e("inverse", " enter ")))} to submit`))}`;
+  }, render() {
+    const r = t.withGuide ?? h.withGuide, u = B(t.output, t.message, r ? `${ft(this.state)}  ` : "", `${P2(this.state)}  `), n = `${r ? `${e("gray", $)}
+` : ""}${u}
+`, a = this.value ?? [], c = (o, l) => {
+      if (o.disabled) return i(o, "disabled");
+      const d = a.includes(o.value);
+      return l && d ? i(o, "active-selected") : d ? i(o, "selected") : i(o, l ? "active" : "inactive");
+    };
+    switch (this.state) {
+      case "submit": {
+        const o = this.options.filter(({ value: d }) => a.includes(d)).map((d) => i(d, "submitted")).join(e("dim", ", ")) || e("dim", "none"), l = B(t.output, o, r ? `${e("gray", $)}  ` : "");
+        return `${n}${l}`;
+      }
+      case "cancel": {
+        const o = this.options.filter(({ value: d }) => a.includes(d)).map((d) => i(d, "cancelled")).join(e("dim", ", "));
+        if (o.trim() === "") return `${n}${e("gray", $)}`;
+        const l = B(t.output, o, r ? `${e("gray", $)}  ` : "");
+        return `${n}${l}${r ? `
+${e("gray", $)}` : ""}`;
+      }
+      case "error": {
+        const o = r ? `${e("yellow", $)}  ` : "", l = this.error.split(`
+`).map((p2, f2) => f2 === 0 ? `${r ? `${e("yellow", x2)}  ` : ""}${e("yellow", p2)}` : `   ${p2}`).join(`
+`), d = n.split(`
+`).length, g = l.split(`
+`).length + 1;
+        return `${n}${o}${F({ output: t.output, options: this.options, cursor: this.cursor, maxItems: t.maxItems, columnPadding: o.length, rowPadding: d + g, style: c }).join(`
+${o}`)}
+${l}
+`;
+      }
+      default: {
+        const o = r ? `${e("cyan", $)}  ` : "", l = n.split(`
+`).length, d = r ? 2 : 1;
+        return `${n}${o}${F({ output: t.output, options: this.options, cursor: this.cursor, maxItems: t.maxItems, columnPadding: o.length, rowPadding: l + d, style: c }).join(`
+${o}`)}
+${r ? e("cyan", x2) : ""}
+`;
+      }
+    }
+  } }).prompt();
+};
+var be = (t) => e("dim", t);
+var Se = (t, i, s) => {
+  const r = { hard: true, trim: false }, u = wrapAnsi(t, i, r).split(`
+`), n = u.reduce((o, l) => Math.max(dist_default2(l), o), 0), a = u.map(s).reduce((o, l) => Math.max(dist_default2(l), o), 0), c = i - (a - n);
+  return wrapAnsi(t, c, r);
+};
+var Ce = (t = "", i = "", s) => {
+  const r = s?.output ?? V2.stdout, u = s?.withGuide ?? h.withGuide, n = s?.format ?? be, a = ["", ...Se(t, A(r) - 6, n).split(`
+`).map(n), ""], c = dist_default2(i), o = Math.max(a.reduce((p2, f2) => {
+    const h2 = dist_default2(f2);
+    return h2 > p2 ? h2 : p2;
+  }, 0), c) + 2, l = a.map((p2) => `${e("gray", $)}  ${p2}${" ".repeat(o - dist_default2(p2))}${e("gray", $)}`).join(`
+`), d = u ? `${e("gray", $)}
+` : "", g = u ? Mt : ht2;
+  r.write(`${d}${e("green", H)}  ${e("reset", i)} ${e("gray", st.repeat(Math.max(o - c - 1, 1)) + $t)}
+${l}
+${e("gray", g + st.repeat(o + 2) + dt)}
+`);
+};
+var _e = (t) => e("magenta", t);
+var vt = ({ indicator: t = "dots", onCancel: i, output: s = process.stdout, cancelMessage: r, errorMessage: u, frames: n = tt ? ["\u25D2", "\u25D0", "\u25D3", "\u25D1"] : ["\u2022", "o", "O", "0"], delay: a = tt ? 80 : 120, signal: c, ...o } = {}) => {
+  const l = at2();
+  let d, g, p2 = false, f2 = false, h2 = "", I, m2 = performance.now();
+  const y = A(s), v2 = o?.styleFrame ?? _e, C2 = (_) => {
+    const A2 = _ > 1 ? u ?? h.messages.error : r ?? h.messages.cancel;
+    f2 = _ === 1, p2 && (W2(A2, _), f2 && typeof i == "function" && i());
+  }, S = () => C2(2), b2 = () => C2(1), G2 = () => {
+    process.on("uncaughtExceptionMonitor", S), process.on("unhandledRejection", S), process.on("SIGINT", b2), process.on("SIGTERM", b2), process.on("exit", C2), c && c.addEventListener("abort", b2);
+  }, M = () => {
+    process.removeListener("uncaughtExceptionMonitor", S), process.removeListener("unhandledRejection", S), process.removeListener("SIGINT", b2), process.removeListener("SIGTERM", b2), process.removeListener("exit", C2), c && c.removeEventListener("abort", b2);
+  }, N = () => {
+    if (I === void 0) return;
+    l && s.write(`
+`);
+    const _ = wrapAnsi(I, y, { hard: true, trim: false }).split(`
+`);
+    _.length > 1 && s.write(import_sisteransi2.cursor.up(_.length - 1)), s.write(import_sisteransi2.cursor.to(0)), s.write(import_sisteransi2.erase.down());
+  }, O2 = (_) => _.replace(/\.+$/, ""), j2 = (_) => {
+    const A2 = (performance.now() - _) / 1e3, L2 = Math.floor(A2 / 60), D2 = Math.floor(A2 % 60);
+    return L2 > 0 ? `[${L2}m ${D2}s]` : `[${D2}s]`;
+  }, k2 = o.withGuide ?? h.withGuide, rt2 = (_ = "") => {
+    p2 = true, d = W({ output: s }), h2 = O2(_), m2 = performance.now(), k2 && s.write(`${e("gray", $)}
+`);
+    let A2 = 0, L2 = 0;
+    G2(), g = setInterval(() => {
+      if (l && h2 === I) return;
+      N(), I = h2;
+      const D2 = v2(n[A2]);
+      let Z2;
+      if (l) Z2 = `${D2}  ${h2}...`;
+      else if (t === "timer") Z2 = `${D2}  ${h2} ${j2(m2)}`;
+      else {
+        const Lt = ".".repeat(Math.floor(L2)).slice(0, 3);
+        Z2 = `${D2}  ${h2}${Lt}`;
+      }
+      const kt = wrapAnsi(Z2, y, { hard: true, trim: false });
+      s.write(kt), A2 = A2 + 1 < n.length ? A2 + 1 : 0, L2 = L2 < 4 ? L2 + 0.125 : 0;
+    }, a);
+  }, W2 = (_ = "", A2 = 0, L2 = false) => {
+    if (!p2) return;
+    p2 = false, clearInterval(g), N();
+    const D2 = A2 === 0 ? e("green", H) : A2 === 1 ? e("red", ut2) : e("red", lt2);
+    h2 = _ ?? h2, L2 || (t === "timer" ? s.write(`${D2}  ${h2} ${j2(m2)}
+`) : s.write(`${D2}  ${h2}
+`)), M(), d();
+  };
+  return { start: rt2, stop: (_ = "") => W2(_, 0), message: (_ = "") => {
+    h2 = O2(_ ?? h2);
+  }, cancel: (_ = "") => W2(_, 1), error: (_ = "") => W2(_, 2), clear: () => W2("", 0, true), get isCancelled() {
+    return f2;
+  } };
+};
+var Nt = { light: w2("\u2500", "-"), heavy: w2("\u2501", "="), block: w2("\u2588", "#") };
+var it2 = (t, i) => t.includes(`
+`) ? t.split(`
+`).map((s) => i(s)).join(`
+`) : i(t);
+var Ee = (t) => {
+  const i = (s, r) => {
+    const u = s.label ?? String(s.value);
+    switch (r) {
+      case "disabled":
+        return `${e("gray", U)} ${it2(u, (n) => e("gray", n))}${s.hint ? ` ${e("dim", `(${s.hint ?? "disabled"})`)}` : ""}`;
+      case "selected":
+        return `${it2(u, (n) => e("dim", n))}`;
+      case "active":
+        return `${e("green", z2)} ${u}${s.hint ? ` ${e("dim", `(${s.hint})`)}` : ""}`;
+      case "cancelled":
+        return `${it2(u, (n) => e(["strikethrough", "dim"], n))}`;
+      default:
+        return `${e("dim", U)} ${it2(u, (n) => e("dim", n))}`;
+    }
+  };
+  return new ht({ options: t.options, signal: t.signal, input: t.input, output: t.output, initialValue: t.initialValue, render() {
+    const s = t.withGuide ?? h.withGuide, r = `${P2(this.state)}  `, u = `${ft(this.state)}  `, n = B(t.output, t.message, u, r), a = `${s ? `${e("gray", $)}
+` : ""}${n}
+`;
+    switch (this.state) {
+      case "submit": {
+        const c = s ? `${e("gray", $)}  ` : "", o = B(t.output, i(this.options[this.cursor], "selected"), c);
+        return `${a}${o}`;
+      }
+      case "cancel": {
+        const c = s ? `${e("gray", $)}  ` : "", o = B(t.output, i(this.options[this.cursor], "cancelled"), c);
+        return `${a}${o}${s ? `
+${e("gray", $)}` : ""}`;
+      }
+      default: {
+        const c = s ? `${e("cyan", $)}  ` : "", o = s ? e("cyan", x2) : "", l = a.split(`
+`).length, d = s ? 2 : 1;
+        return `${a}${c}${F({ output: t.output, cursor: this.cursor, options: this.options, maxItems: t.maxItems, columnPadding: c.length, rowPadding: l + d, style: (g, p2) => i(g, g.disabled ? "disabled" : p2 ? "active" : "inactive") }).join(`
+${c}`)}
+${o}
+`;
+      }
     }
-    return flags;
+  } }).prompt();
+};
+var Bt = `${e("gray", $)}  `;
+var Re = (t) => new ct({ validate: t.validate, placeholder: t.placeholder, defaultValue: t.defaultValue, initialValue: t.initialValue, output: t.output, signal: t.signal, input: t.input, render() {
+  const i = t?.withGuide ?? h.withGuide, s = `${`${i ? `${e("gray", $)}
+` : ""}${P2(this.state)}  `}${t.message}
+`, r = t.placeholder ? e("inverse", t.placeholder[0]) + e("dim", t.placeholder.slice(1)) : e(["inverse", "hidden"], "_"), u = this.userInput ? this.userInputWithCursor : r, n = this.value ?? "";
+  switch (this.state) {
+    case "error": {
+      const a = this.error ? `  ${e("yellow", this.error)}` : "", c = i ? `${e("yellow", $)}  ` : "", o = i ? e("yellow", x2) : "";
+      return `${s.trim()}
+${c}${u}
+${o}${a}
+`;
+    }
+    case "submit": {
+      const a = n ? `  ${e("dim", n)}` : "", c = i ? e("gray", $) : "";
+      return `${s}${c}${a}`;
+    }
+    case "cancel": {
+      const a = n ? `  ${e(["strikethrough", "dim"], n)}` : "", c = i ? e("gray", $) : "";
+      return `${s}${c}${a}${n.trim() ? `
+${c}` : ""}`;
+    }
+    default: {
+      const a = i ? `${e("cyan", $)}  ` : "", c = i ? e("cyan", x2) : "";
+      return `${s}${a}${u}
+${c}
+`;
+    }
+  }
+} }).prompt();
+
+// src/cli/configure.ts
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+import { loadConfig } from "toiljs/compiler";
+
+// src/cli/features.ts
+var PREPROCESSORS = ["css", "sass", "less", "stylus"];
+var STYLE_EXT = {
+  css: "css",
+  sass: "scss",
+  less: "less",
+  stylus: "styl"
+};
+var PREPROCESSOR_PKG = {
+  css: null,
+  sass: "sass",
+  less: "less",
+  stylus: "stylus"
+};
+var TAILWIND_PKGS = ["tailwindcss", "@tailwindcss/vite"];
+var PKG_VERSION = {
+  sass: "^1.83.0",
+  less: "^4.2.1",
+  stylus: "^0.64.0",
+  tailwindcss: "^4.0.0",
+  "@tailwindcss/vite": "^4.0.0"
+};
+var TAILWIND_ENTRY = "styles/tailwind.css";
+var TAILWIND_CSS = `@import 'tailwindcss';
+`;
+function styleEntry(p2) {
+  return `styles/main.${STYLE_EXT[p2]}`;
+}
+function preprocessorForExt(ext) {
+  const e2 = ext.replace(/^\./, "");
+  if (e2 === "sass") return "sass";
+  return PREPROCESSORS.find((p2) => STYLE_EXT[p2] === e2) ?? null;
+}
+function requiredPackages(f2) {
+  const pkgs = [];
+  const pp = PREPROCESSOR_PKG[f2.preprocessor];
+  if (pp) pkgs.push(pp);
+  if (f2.tailwind) pkgs.push(...TAILWIND_PKGS);
+  return pkgs;
+}
+function packageDiff(from, to) {
+  const want = new Set(requiredPackages(to));
+  const had = new Set(requiredPackages(from));
+  return {
+    add: [...want].filter((p2) => !had.has(p2)),
+    remove: [...had].filter((p2) => !want.has(p2))
+  };
+}
+function styleImportLines(f2) {
+  const lines = [];
+  if (f2.tailwind) lines.push(`import './${TAILWIND_ENTRY}';`);
+  lines.push(`import './${styleEntry(f2.preprocessor)}';`);
+  return lines;
+}
+function setStyleImports(source, f2) {
+  const stripped = source.replace(
+    /^[ \t]*import\s+['"]\.\/styles\/[^'"]+['"];?[ \t]*\r?\n/gm,
+    ""
+  );
+  const block = styleImportLines(f2).join("\n") + "\n";
+  const lines = stripped.split("\n");
+  const routesIdx = lines.findIndex((l) => /from\s+['"]toiljs\/routes['"]/.test(l));
+  let insertAt;
+  if (routesIdx !== -1) {
+    insertAt = routesIdx + 1;
+  } else {
+    const lastImport = lines.reduce((acc, l, i) => /^\s*import\s/.test(l) ? i : acc, -1);
+    insertAt = lastImport + 1;
+  }
+  const head = lines.slice(0, insertAt).join("\n");
+  const tail = lines.slice(insertAt).join("\n");
+  return `${head}
+
+${block}
+${tail}`.replace(/\n{3,}/g, "\n\n");
+}
+function defaultConfigSource(images) {
+  return `import { defineConfig } from 'toiljs/compiler';
+
+export default defineConfig({
+    client: {
+        // Optimize images at build time (resize/compress imported images).
+        images: ${String(images)},
+    },
+});
+`;
+}
+function setConfigImages(source, enabled) {
+  const value = String(enabled);
+  if (/\bimages\s*:\s*(?:true|false)/.test(source)) {
+    return source.replace(/\bimages\s*:\s*(?:true|false)/, `images: ${value}`);
+  }
+  if (/\bclient\s*:\s*\{/.test(source)) {
+    return source.replace(/\bclient\s*:\s*\{/, `client: {
+        images: ${value},`);
+  }
+  if (/defineConfig\(\s*\{/.test(source)) {
+    return source.replace(
+      /defineConfig\(\s*\{/,
+      `defineConfig({
+    client: { images: ${value} },`
+    );
+  }
+  return null;
+}
+function detectPreprocessor(deps) {
+  if ("sass" in deps) return "sass";
+  if ("less" in deps) return "less";
+  if ("stylus" in deps) return "stylus";
+  return "css";
+}
+function detectTailwind(deps) {
+  return "@tailwindcss/vite" in deps || "tailwindcss" in deps;
+}
+
+// src/cli/proc.ts
+import { spawn } from "node:child_process";
+function run(cmd, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const onWindows = process.platform === "win32";
+    const child = onWindows ? spawn([cmd, ...args].join(" "), { cwd, stdio: "ignore", shell: true }) : spawn(cmd, args, { cwd, stdio: "ignore" });
+    child.on("error", reject);
+    child.on(
+      "close",
+      (code) => code === 0 ? resolve() : reject(new Error(`${cmd} exited with code ${String(code)}`))
+    );
+  });
+}
+function capture(cmd, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const onWindows = process.platform === "win32";
+    const child = onWindows ? spawn([cmd, ...args].join(" "), { cwd, shell: true }) : spawn(cmd, args, { cwd });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      resolve({ stdout, stderr, code: code ?? 1 });
+    });
+  });
+}
+
+// src/cli/ui.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var PRIMARY = [37, 99, 255];
+var SECONDARY = [124, 58, 237];
+var ACCENT = [34, 227, 171];
+var GRADIENT = [PRIMARY, SECONDARY, ACCENT];
+var ART = [
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2557 \u2588\u2588\u2557     ",
+  "\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2551 \u2588\u2588\u2551     ",
+  "   \u2588\u2588\u2551    \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2551 \u2588\u2588\u2551     ",
+  "   \u2588\u2588\u2551    \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2551 \u2588\u2588\u2551     ",
+  "   \u2588\u2588\u2551    \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557",
+  "   \u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D"
+];
+var dim = import_picocolors.default.dim;
+var bold = import_picocolors.default.bold;
+function colorEnabled() {
+  if (process.env.NO_COLOR) return false;
+  if (process.env.FORCE_COLOR) return true;
+  return process.stdout.isTTY;
+}
+function rgb(color, s) {
+  return colorEnabled() ? `\x1B[38;2;${color[0]};${color[1]};${color[2]}m${s}\x1B[39m` : s;
+}
+function brand(s) {
+  return rgb(PRIMARY, s);
+}
+var accent = brand;
+function success(s) {
+  return rgb(ACCENT, s);
+}
+var danger = import_picocolors.default.red;
+var warn = import_picocolors.default.yellow;
+function lerp(a, b2, t) {
+  return Math.round(a + (b2 - a) * t);
+}
+function gradientAt(t) {
+  const segments = GRADIENT.length - 1;
+  const scaled = t * segments;
+  const i = Math.min(Math.floor(scaled), segments - 1);
+  const a = GRADIENT[i];
+  const b2 = GRADIENT[i + 1];
+  const localT = scaled - i;
+  return [lerp(a[0], b2[0], localT), lerp(a[1], b2[1], localT), lerp(a[2], b2[2], localT)];
+}
+function gradientLine(line) {
+  const n = line.length;
+  let out = "";
+  for (let i = 0; i < n; i++) {
+    const [r, g, b2] = gradientAt(n > 1 ? i / (n - 1) : 0);
+    out += `\x1B[38;2;${r};${g};${b2}m${line[i]}`;
+  }
+  return out + "\x1B[39m";
+}
+function version() {
+  try {
+    const pkgPath = path.resolve(
+      path.dirname(fileURLToPath(import.meta.url)),
+      "..",
+      "..",
+      "package.json"
+    );
+    const raw = fs.readFileSync(pkgPath, "utf8");
+    const match = /"version"\s*:\s*"([^"]+)"/.exec(raw);
+    if (match && match[1]) return match[1];
+  } catch {
+  }
+  return "0.0.0";
+}
+function banner() {
+  const lines = colorEnabled() ? ART.map(gradientLine) : ART.slice();
+  const tagline = `  the most performant ${brand("react")} framework`;
+  const ver = `${dim("  v")}${brand(version())}`;
+  process.stdout.write("\n" + lines.join("\n") + "\n\n" + tagline + "   " + ver + "\n\n");
+}
+
+// src/cli/configure.ts
+var CONFIG_FILES = [
+  "toil.config.ts",
+  "toil.config.mts",
+  "toil.config.js",
+  "toil.config.mjs",
+  "toiljs.config.ts",
+  "toiljs.config.mts",
+  "toiljs.config.js",
+  "toiljs.config.mjs"
+];
+async function readConfigFile(root) {
+  for (const name of CONFIG_FILES) {
+    const p2 = path2.join(root, name);
+    try {
+      return { path: p2, source: await fs2.readFile(p2, "utf8") };
+    } catch {
+    }
+  }
+  return null;
+}
+async function writeImagesFlag(root, enabled) {
+  const existing = await readConfigFile(root);
+  if (!existing) {
+    await fs2.writeFile(path2.join(root, "toil.config.ts"), defaultConfigSource(enabled), "utf8");
+    return true;
+  }
+  const next = setConfigImages(existing.source, enabled);
+  if (next === null) return false;
+  await fs2.writeFile(existing.path, next, "utf8");
+  return true;
+}
+async function resolveImages(root) {
+  try {
+    return (await loadConfig({ root })).images;
+  } catch {
+    return true;
+  }
+}
+async function resolveClientDir(root) {
+  try {
+    const cfg = await loadConfig({ root });
+    return cfg.clientAbsDir;
+  } catch {
+    return path2.join(root, "client");
+  }
+}
+var PREPROCESSOR_LABEL = {
+  css: "Plain CSS",
+  sass: "Sass (SCSS)",
+  less: "Less",
+  stylus: "Stylus"
+};
+function bail(value) {
+  if (R(value)) {
+    ge("Configuration cancelled.");
+    process.exit(0);
+  }
+}
+async function detectStylesheet(clientDir) {
+  for (const p2 of PREPROCESSORS) {
+    try {
+      await fs2.access(path2.join(clientDir, styleEntry(p2)));
+      return p2;
+    } catch {
+    }
+  }
+  try {
+    await fs2.access(path2.join(clientDir, "styles/main.sass"));
+    return preprocessorForExt("sass");
+  } catch {
+    return null;
+  }
+}
+async function findMainStylesheet(clientDir) {
+  for (const ext of ["css", "scss", "sass", "less", "styl"]) {
+    const p2 = path2.join(clientDir, "styles", `main.${ext}`);
+    try {
+      await fs2.access(p2);
+      return p2;
+    } catch {
+    }
+  }
+  return null;
+}
+async function detectPackageManager(root) {
+  const lock = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lockb", "bun"]
+  ];
+  for (const [file, pm] of lock) {
+    try {
+      await fs2.access(path2.join(root, file));
+      return pm;
+    } catch {
+    }
+  }
+  return "npm";
+}
+async function applyStyleFiles(clientDir, from, to) {
+  if (from.preprocessor !== to.preprocessor) {
+    const newPath = path2.join(clientDir, styleEntry(to.preprocessor));
+    await fs2.mkdir(path2.dirname(newPath), { recursive: true });
+    const existing = await findMainStylesheet(clientDir);
+    if (existing && path2.resolve(existing) !== path2.resolve(newPath)) {
+      await fs2.rename(existing, newPath);
+    } else if (!existing) {
+      await fs2.writeFile(newPath, "", "utf8");
+    }
+  }
+  const tailwindPath = path2.join(clientDir, TAILWIND_ENTRY);
+  if (to.tailwind && !from.tailwind) {
+    await fs2.mkdir(path2.dirname(tailwindPath), { recursive: true });
+    await fs2.writeFile(tailwindPath, TAILWIND_CSS, "utf8");
+  } else if (!to.tailwind && from.tailwind) {
+    await fs2.rm(tailwindPath, { force: true });
+  }
+  for (const entry of ["toil.tsx", "toil.jsx"]) {
+    const entryPath = path2.join(clientDir, entry);
+    try {
+      const source = await fs2.readFile(entryPath, "utf8");
+      await fs2.writeFile(entryPath, setStyleImports(source, to), "utf8");
+      return;
+    } catch {
+    }
+  }
+}
+async function applyConfigure(clientDir, pkgPath, pkg, from, to) {
+  await applyStyleFiles(clientDir, from, to);
+  await applyPackages(pkgPath, pkg, from, to);
+}
+async function applyPackages(pkgPath, pkg, from, to) {
+  const { add, remove } = packageDiff(from, to);
+  const dev2 = { ...pkg.devDependencies };
+  const deps = { ...pkg.dependencies };
+  for (const name of add) dev2[name] = PKG_VERSION[name] ?? "latest";
+  for (const name of remove) {
+    delete dev2[name];
+    delete deps[name];
+  }
+  const sortedDev = Object.fromEntries(
+    Object.entries(dev2).sort(([a], [b2]) => a.localeCompare(b2))
+  );
+  const next = { ...pkg, devDependencies: sortedDev };
+  if (Object.keys(deps).length) next.dependencies = deps;
+  else delete next.dependencies;
+  await fs2.writeFile(pkgPath, JSON.stringify(next, null, 4) + "\n", "utf8");
+}
+function describe(from, to) {
+  const lines = [];
+  if (from.preprocessor !== to.preprocessor) {
+    lines.push(
+      `preprocessor: ${PREPROCESSOR_LABEL[from.preprocessor]} \u2192 ${PREPROCESSOR_LABEL[to.preprocessor]}`
+    );
+  }
+  if (from.tailwind !== to.tailwind) {
+    lines.push(`Tailwind: ${from.tailwind ? "on" : "off"} \u2192 ${to.tailwind ? "on" : "off"}`);
+  }
+  const { add, remove } = packageDiff(from, to);
+  if (add.length) lines.push(`+ ${add.join(", ")}`);
+  if (remove.length) lines.push(`- ${remove.join(", ")}`);
+  return lines.map((l) => dim("  ") + l).join("\n");
+}
+async function runConfigure(opts) {
+  ye(accent(" toiljs configure "));
+  const root = path2.resolve(opts.root ?? opts.cwd);
+  const pkgPath = path2.join(root, "package.json");
+  let pkg;
+  try {
+    pkg = JSON.parse(await fs2.readFile(pkgPath, "utf8"));
+  } catch {
+    ge(`No package.json in ${import_picocolors2.default.cyan(root)}, run this inside a toiljs project.`);
+    process.exit(1);
+  }
+  const clientAbsDir = await resolveClientDir(root);
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const current = {
+    preprocessor: await detectStylesheet(clientAbsDir) ?? detectPreprocessor(deps),
+    tailwind: detectTailwind(deps)
+  };
+  const currentImages = await resolveImages(root);
+  const nonInteractive = opts.preprocessor !== void 0 || opts.tailwind !== void 0 || opts.images !== void 0;
+  let target;
+  let targetImages;
+  if (nonInteractive) {
+    target = {
+      preprocessor: opts.preprocessor ?? current.preprocessor,
+      tailwind: opts.tailwind ?? current.tailwind
+    };
+    targetImages = opts.images ?? currentImages;
+  } else {
+    const ppChoice = await Ee({
+      message: "CSS preprocessor",
+      options: PREPROCESSORS.map((value) => ({ value, label: PREPROCESSOR_LABEL[value] })),
+      initialValue: current.preprocessor
+    });
+    bail(ppChoice);
+    const twChoice = await le({
+      message: "Use Tailwind CSS?",
+      initialValue: current.tailwind
+    });
+    bail(twChoice);
+    const imChoice = await le({
+      message: "Optimize images at build time?",
+      initialValue: currentImages
+    });
+    bail(imChoice);
+    target = { preprocessor: ppChoice, tailwind: twChoice };
+    targetImages = imChoice;
+  }
+  const styleChanged = target.preprocessor !== current.preprocessor || target.tailwind !== current.tailwind;
+  const imagesChanged = targetImages !== currentImages;
+  if (!styleChanged && !imagesChanged) {
+    fe("No changes, your setup is already up to date.");
+    return;
+  }
+  const s = vt();
+  s.start("Updating project files");
+  if (styleChanged) await applyConfigure(clientAbsDir, pkgPath, pkg, current, target);
+  let imagesWarning = "";
+  if (imagesChanged && !await writeImagesFlag(root, targetImages)) {
+    imagesWarning = import_picocolors2.default.yellow(
+      " Could not edit toil.config automatically, set `client.images` by hand."
+    );
+  }
+  s.stop("Updated project files");
+  if (styleChanged) {
+    const pm = await detectPackageManager(root);
+    if (opts.install === false) {
+      Ce(`${import_picocolors2.default.cyan(`${pm} install`)} to sync the dependency changes.`, "Next step");
+    } else {
+      const i = vt();
+      i.start(`Syncing dependencies with ${pm}`);
+      try {
+        await run(pm, ["install"], root);
+        i.stop("Dependencies synced");
+      } catch {
+        i.stop(import_picocolors2.default.yellow(`Could not run \`${pm} install\`, run it yourself to finish`));
+      }
+    }
+  }
+  const summary = [
+    styleChanged ? describe(current, target) : "",
+    imagesChanged ? dim("  ") + `image optimization: ${currentImages ? "on" : "off"} \u2192 ${targetImages ? "on" : "off"}` : "",
+    imagesWarning
+  ].filter(Boolean).join("\n");
+  Ce(summary, "Updated");
+  fe(`Reconfigured, restart \`${accent("toiljs dev")}\` to pick up the changes.`);
+}
+
+// src/cli/create.ts
+import fs3 from "node:fs/promises";
+import path4 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var import_picocolors3 = __toESM(require_picocolors(), 1);
+import { AI_HELPER_IDS, AI_HELPERS, aiHelperFiles, TOIL_DOCS, TOIL_ENV_DTS } from "toiljs/compiler";
+
+// src/cli/validate.ts
+import path3 from "node:path";
+var PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
+function isValidName(name) {
+  if (!name.trim()) return "Please enter a project name.";
+  if (!/^[a-z0-9._@/-]+$/i.test(name)) return "Use letters, numbers, dashes, dots or slashes.";
+  return true;
+}
+function resolveProjectDir(cwd, name) {
+  const target = path3.resolve(cwd, name);
+  const rel = path3.relative(cwd, target);
+  if (rel.startsWith("..") || path3.isAbsolute(rel)) return null;
+  return target;
+}
+function isPackageManager(pm) {
+  return PACKAGE_MANAGERS.includes(pm);
+}
+
+// src/cli/create.ts
+var PREPROCESSOR_LABEL2 = {
+  css: "Plain CSS",
+  sass: "Sass (SCSS)",
+  less: "Less",
+  stylus: "Stylus"
+};
+var DEFAULT_STYLE_CONTENT = ":root {\n    color-scheme: dark;\n}\n\nbody {\n    margin: 0;\n    background: #080d11;\n    color: #f5f6fa;\n    font-family: system-ui, -apple-system, sans-serif;\n    line-height: 1.6;\n}\n\na {\n    color: #2563ff;\n    text-decoration: none;\n}\n\na:hover {\n    color: #22e3ab;\n}\n\ncode {\n    background: #11161f;\n    color: #22e3ab;\n    padding: 0.1rem 0.4rem;\n    border-radius: 4px;\n    font-size: 0.9em;\n}\n\nh1 {\n    background: linear-gradient(90deg, #2563ff, #7c3aed, #22e3ab);\n    -webkit-background-clip: text;\n    background-clip: text;\n    color: transparent;\n}\n";
+function bail2(value) {
+  if (R(value)) {
+    ge("Scaffolding cancelled.");
+    process.exit(0);
+  }
+}
+async function isEmptyDir(dir) {
+  try {
+    const entries = await fs3.readdir(dir);
+    return entries.length === 0;
+  } catch {
+    return true;
+  }
+}
+function scaffold(name, template, features, aiTools, images) {
+  const toilVersion = version();
+  const devDependencies = {
+    "@types/react": "^19.2.15",
+    "@types/react-dom": "^19.2.3",
+    eslint: "^10.2.0",
+    prettier: "^3.8.1",
+    toilscript: "^0.1.2",
+    typescript: "^6.0.3"
+  };
+  for (const dep of requiredPackages(features).sort()) {
+    devDependencies[dep] = PKG_VERSION[dep] ?? "latest";
+  }
+  const pkg = {
+    name: path4.basename(name),
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "toiljs dev",
+      build: "toiljs build && toilscript --target release",
+      "build:client": "toiljs build",
+      "build:server": "toilscript --target release",
+      lint: "eslint client",
+      typecheck: "tsc --noEmit",
+      format: 'prettier --write "client/**/*.{ts,tsx,css,scss,less}" "client/public/**/*.html"'
+    },
+    dependencies: {
+      toiljs: `^${toilVersion}`,
+      react: "^19.2.6",
+      "react-dom": "^19.2.6"
+    },
+    devDependencies
+  };
+  const files = {
+    "package.json": JSON.stringify(pkg, null, 4) + "\n",
+    "toil.config.ts": `import { defineConfig } from 'toiljs/compiler';
+
+export default defineConfig({
+    client: {
+        // Optimize images at build time (resize/compress imported images).
+        images: ${String(images)},
+    },
+});
+`,
+    "tsconfig.json": '{\n    "extends": "toiljs/tsconfig",\n    "include": ["client", "toil-env.d.ts", "toil-routes.d.ts"]\n}\n',
+    "eslint.config.js": "import toiljs from 'toiljs/eslint';\n\nexport default toiljs;\n",
+    ".prettierrc": '"toiljs/prettier"\n',
+    ".gitignore": "node_modules\nbuild\n.toil\ntoil-env.d.ts\ntoil-routes.d.ts\n",
+    // Use the project's pinned TypeScript (node_modules) instead of VS Code's bundled version.
+    ".vscode/settings.json": JSON.stringify({ "typescript.tsdk": "node_modules/typescript/lib" }, null, 4) + "\n",
+    "toil-env.d.ts": TOIL_ENV_DTS,
+    // Stub typed-routes augmentation (RoutePath = string until the first dev/build regenerates it).
+    "toil-routes.d.ts": "// AUTO-GENERATED by toil, do not edit.\nexport {};\n",
+    "toilconfig.json": JSON.stringify(
+      {
+        entries: ["server/main.ts"],
+        targets: {
+          release: {
+            outFile: "build/server/release.wasm",
+            textFile: "build/server/release.wat"
+          }
+        },
+        options: {
+          sourceMap: false,
+          optimizeLevel: 3,
+          shrinkLevel: 1,
+          converge: true,
+          noAssert: false,
+          enable: [
+            "sign-extension",
+            "mutable-globals",
+            "nontrapping-f2i",
+            "bulk-memory",
+            "simd",
+            "reference-types",
+            "multi-value"
+          ],
+          runtime: "stub",
+          memoryBase: 0,
+          initialMemory: 1,
+          debug: false,
+          trapMode: "allow"
+        }
+      },
+      null,
+      4
+    ) + "\n",
+    "server/tsconfig.json": JSON.stringify(
+      {
+        extends: "toilscript/std/assembly.json",
+        include: ["./**/*.ts"]
+      },
+      null,
+      4
+    ) + "\n",
+    "server/index.ts": "export function add(a: i32, b: i32): i32 {\n    return a + b;\n}\n",
+    "server/main.ts": "import { add } from './index';\n\n@main\nfunction run(): i32 {\n    return add(40, 2);\n}\n",
+    "README.md": [
+      "# " + path4.basename(name),
+      "",
+      "A [toiljs](https://toil.org) app.",
+      "",
+      "## Develop",
+      "",
+      "    npm install",
+      "    npm run dev",
+      "",
+      "## Build",
+      "",
+      "    npm run build",
+      ""
+    ].join("\n")
+  };
+  if (template === "minimal") Object.assign(files, minimalClient(name, features));
+  Object.assign(files, aiHelperFiles(aiTools));
+  for (const [docName, content] of Object.entries(TOIL_DOCS)) {
+    files[`.toil/docs/${docName}`] = content;
+  }
+  return files;
+}
+function minimalClient(name, features) {
+  const files = {
+    "client/public/index.html": `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="theme-color" content="#080D11" />
+    <meta name="description" content="" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <link rel="manifest" href="/manifest.webmanifest" />
+    <title>${path4.basename(name)}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>
+`,
+    "client/public/favicon.svg": '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">\n  <defs>\n    <linearGradient id="g" x1="0" y1="0" x2="1" y2="1">\n      <stop offset="0" stop-color="#2563FF" />\n      <stop offset="0.5" stop-color="#7C3AED" />\n      <stop offset="1" stop-color="#22E3AB" />\n    </linearGradient>\n  </defs>\n  <rect width="32" height="32" rx="7" fill="#080D11" />\n  <path d="M9 10h14v3.2h-5.4V24h-3.2V13.2H9z" fill="url(#g)" />\n</svg>\n',
+    "client/public/robots.txt": "User-agent: *\nAllow: /\n",
+    "client/public/manifest.webmanifest": JSON.stringify(
+      {
+        name: path4.basename(name),
+        short_name: path4.basename(name),
+        start_url: "/",
+        display: "standalone",
+        background_color: "#080D11",
+        theme_color: "#080D11",
+        icons: [{ src: "/favicon.svg", type: "image/svg+xml", sizes: "any" }]
+      },
+      null,
+      4
+    ) + "\n",
+    "client/public/images/.gitkeep": "# Place images and other static assets here; served at /images/*.\n",
+    "client/toil.tsx": "import { routes, layout, notFound, globalError, slots } from 'toiljs/routes';\n\n" + styleImportLines(features).join("\n") + "\n\nToil.mount(routes, layout, notFound, globalError, slots);\n",
+    [`client/${styleEntry(features.preprocessor)}`]: DEFAULT_STYLE_CONTENT,
+    "client/components/.gitkeep": "# Place shared React components here.\n",
+    "client/layout.tsx": `import { type ReactNode } from 'react';
+
+export default function Layout({ children }: { children?: ReactNode }) {
+    return (
+        <div style={{ maxWidth: 680, margin: '0 auto', padding: '3rem 1.5rem' }}>
+            <header
+                style={{
+                    display: 'flex',
+                    gap: '1rem',
+                    alignItems: 'baseline',
+                    borderBottom: '1px solid #1b2330',
+                    paddingBottom: '0.75rem',
+                    marginBottom: '1.5rem',
+                }}>
+                <strong style={{ color: '#2563FF', fontSize: '1.1rem' }}>${path4.basename(name)}</strong>
+                <nav style={{ display: 'flex', gap: '1rem' }}>
+                    <Toil.Link href="/">home</Toil.Link>
+                </nav>
+            </header>
+            {children}
+        </div>
+    );
+}
+`,
+    "client/routes/index.tsx": "export default function Home() {\n    return (\n        <main>\n            <h1>Welcome to toiljs</h1>\n            <p>File-based routing, bundled by Vite, zero config.</p>\n        </main>\n    );\n}\n"
+  };
+  if (features.tailwind) files[`client/${TAILWIND_ENTRY}`] = TAILWIND_CSS;
+  return files;
+}
+function appClientDir() {
+  return path4.resolve(
+    path4.dirname(fileURLToPath2(import.meta.url)),
+    "..",
+    "..",
+    "examples",
+    "basic",
+    "client"
+  );
+}
+async function applyStyling(clientDir, features) {
+  if (features.preprocessor === "css" && !features.tailwind) return;
+  const entry = styleEntry(features.preprocessor);
+  if (entry !== "styles/main.css") {
+    await fs3.rename(path4.join(clientDir, "styles", "main.css"), path4.join(clientDir, entry));
+  }
+  if (features.tailwind) {
+    await fs3.writeFile(path4.join(clientDir, TAILWIND_ENTRY), TAILWIND_CSS, "utf8");
+  }
+  const toilPath = path4.join(clientDir, "toil.tsx");
+  await fs3.writeFile(
+    toilPath,
+    setStyleImports(await fs3.readFile(toilPath, "utf8"), features),
+    "utf8"
+  );
+}
+async function writeFiles(dir, files) {
+  for (const [rel, contents] of Object.entries(files)) {
+    const full = path4.join(dir, rel);
+    await fs3.mkdir(path4.dirname(full), { recursive: true });
+    await fs3.writeFile(full, contents, "utf8");
+  }
+}
+async function runCreate(opts) {
+  ye(accent(" toiljs create "));
+  let name = opts.name;
+  if (!name) {
+    if (opts.yes) {
+      name = "my-toil-app";
+    } else {
+      const answer = await Re({
+        message: "Project name",
+        placeholder: "my-toil-app",
+        defaultValue: "my-toil-app",
+        validate: (v2) => {
+          const result = isValidName(v2 || "my-toil-app");
+          return result === true ? void 0 : result;
+        }
+      });
+      bail2(answer);
+      name = answer.trim() || "my-toil-app";
+    }
+  }
+  const valid = isValidName(name);
+  if (valid !== true) {
+    ge(valid);
+    process.exit(1);
+  }
+  const targetDir = resolveProjectDir(opts.cwd, name);
+  if (targetDir === null) {
+    ge('Project name must stay inside the current directory (no "..", no absolute paths).');
+    process.exit(1);
+  }
+  const rel = path4.relative(opts.cwd, targetDir) || ".";
+  if (!await isEmptyDir(targetDir)) {
+    if (opts.yes) {
+      ge(`Directory ${import_picocolors3.default.cyan(rel)} is not empty.`);
+      process.exit(1);
+    }
+    const proceed = await le({
+      message: `Directory ${import_picocolors3.default.cyan(rel)} is not empty. Scaffold into it anyway?`,
+      initialValue: false
+    });
+    bail2(proceed);
+    if (!proceed) {
+      ge("Scaffolding cancelled.");
+      process.exit(0);
+    }
+  }
+  let template = opts.template ?? "app";
+  if (!opts.template && !opts.yes) {
+    const templateOptions = [
+      {
+        value: "app",
+        label: "App",
+        hint: "the full ToilJS starter, landing page, layout, styles, demo routes"
+      },
+      { value: "minimal", label: "Minimal", hint: "just a layout and a home route" }
+    ];
+    const choice = await Ee({
+      message: "Which template?",
+      options: templateOptions,
+      initialValue: "app"
+    });
+    bail2(choice);
+    template = choice === "minimal" ? "minimal" : "app";
+  }
+  let preprocessor = opts.preprocessor ?? "css";
+  let tailwind = opts.tailwind ?? false;
+  if (!opts.yes) {
+    if (opts.preprocessor === void 0) {
+      const choice = await Ee({
+        message: "Styling",
+        options: PREPROCESSORS.map((value) => ({
+          value,
+          label: PREPROCESSOR_LABEL2[value]
+        })),
+        initialValue: "css"
+      });
+      bail2(choice);
+      preprocessor = choice;
+    }
+    if (opts.tailwind === void 0) {
+      const tw = await le({ message: "Add Tailwind CSS?", initialValue: false });
+      bail2(tw);
+      tailwind = tw;
+    }
+  }
+  const features = { preprocessor, tailwind };
+  let aiTools = opts.ai === false ? [] : [...AI_HELPER_IDS];
+  if (opts.ai === void 0 && !opts.yes) {
+    const picked = await we({
+      message: "AI assistant files (read by Claude, Cursor, Codex, Copilot)",
+      options: [
+        ...AI_HELPERS.map((h2) => ({ value: h2.id, label: h2.label })),
+        { value: "none", label: "None" }
+      ],
+      initialValues: [...AI_HELPER_IDS],
+      required: false
+    });
+    bail2(picked);
+    aiTools = picked.includes("none") ? [] : picked;
+  }
+  let images = opts.images ?? true;
+  if (opts.images === void 0 && !opts.yes) {
+    const im = await le({ message: "Optimize images at build time?", initialValue: true });
+    bail2(im);
+    images = im;
+  }
+  let initGit = opts.git ?? false;
+  let install = opts.install ?? false;
+  const pm = opts.pm ?? "npm";
+  if (!isPackageManager(pm)) {
+    ge(`Unsupported package manager: ${pm} (use npm, pnpm, yarn, or bun).`);
+    process.exit(1);
+  }
+  if (!opts.yes) {
+    if (opts.git === void 0) {
+      const g = await le({
+        message: "Initialize a git repository?",
+        initialValue: true
+      });
+      bail2(g);
+      initGit = g;
+    }
+    if (opts.install === void 0) {
+      const i = await le({ message: "Install dependencies now?", initialValue: false });
+      bail2(i);
+      install = i;
+    }
+  }
+  const s = vt();
+  s.start("Scaffolding project");
+  await writeFiles(targetDir, scaffold(name, template, features, aiTools, images));
+  if (template === "app") {
+    await fs3.cp(appClientDir(), path4.join(targetDir, "client"), { recursive: true });
+    const indexHtml = path4.join(targetDir, "client", "public", "index.html");
+    const html = await fs3.readFile(indexHtml, "utf8");
+    await fs3.writeFile(
+      indexHtml,
+      html.replace(/<title>[^<]*<\/title>/, `<title>${path4.basename(name)}</title>`)
+    );
+    await applyStyling(path4.join(targetDir, "client"), features);
+  }
+  s.stop(`Scaffolded ${import_picocolors3.default.cyan(rel)}`);
+  if (initGit) {
+    const g = vt();
+    g.start("Initializing git repository");
+    try {
+      await run("git", ["init", "-q"], targetDir);
+      await run("git", ["add", "-A"], targetDir);
+      g.stop("Initialized git repository");
+    } catch {
+      g.stop(import_picocolors3.default.yellow("Skipped git init (git not available)"));
+    }
+  }
+  if (install) {
+    const i = vt();
+    i.start(`Installing dependencies with ${pm}`);
+    try {
+      await run(pm, ["install"], targetDir);
+      i.stop("Installed dependencies");
+    } catch {
+      i.stop(import_picocolors3.default.yellow(`Could not install with ${pm}, run it yourself later`));
+      install = false;
+    }
+  }
+  const steps = [];
+  if (rel !== ".") steps.push(`cd ${rel}`);
+  if (!install) steps.push("npm install");
+  steps.push(`${accent("npm run dev")}   ${dim("start the dev server")}`);
+  steps.push(`${accent("npm run build")} ${dim("build for production")}`);
+  Ce(steps.map((l) => dim("  ") + l).join("\n"), "Next steps");
+  fe(`Created ${accent(path4.basename(name))}, happy building! ${dim("\xB7 v" + version())}`);
+}
+
+// src/cli/doctor.ts
+import fs4 from "node:fs";
+import { createRequire } from "node:module";
+import path5 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { loadConfig as loadConfig2, scanRoutes } from "toiljs/compiler";
+
+// src/cli/diagnostics.ts
+function parseVersion(v2) {
+  const m2 = /(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(v2);
+  if (!m2) return [0, 0, 0];
+  return [Number(m2[1]), Number(m2[2] ?? 0), Number(m2[3] ?? 0)];
+}
+function satisfiesMin(version2, range) {
+  const [a, b2, c] = parseVersion(version2);
+  const [x3, y, z3] = parseVersion(range);
+  if (a !== x3) return a > x3;
+  if (b2 !== y) return b2 > y;
+  return c >= z3;
+}
+function checkNode(current, requiredRange) {
+  const ok = satisfiesMin(current, requiredRange);
+  return {
+    id: "node",
+    label: "Node.js",
+    status: ok ? "pass" : "fail",
+    detail: `${current} (requires ${requiredRange})`,
+    fix: ok ? void 0 : `Upgrade Node to ${requiredRange}.`
+  };
+}
+function checkPeer(name, installed, range) {
+  if (installed === null) {
+    return {
+      id: `peer:${name}`,
+      label: name,
+      status: "fail",
+      detail: `not installed (requires ${range})`,
+      fix: `Install ${name}@"${range}".`
+    };
+  }
+  const ok = satisfiesMin(installed, range);
+  return {
+    id: `peer:${name}`,
+    label: name,
+    status: ok ? "pass" : "warn",
+    detail: `${installed} (requires ${range})`,
+    fix: ok ? void 0 : `Update ${name} to ${range}.`
+  };
+}
+function checkPackageManager(lockfiles) {
+  if (lockfiles.length === 0) {
+    return {
+      id: "pm",
+      label: "Package manager",
+      status: "warn",
+      detail: "no lockfile found",
+      fix: "Run an install (npm/pnpm/yarn/bun) to create a lockfile."
+    };
+  }
+  return { id: "pm", label: "Package manager", status: "pass", detail: lockfiles.join(", ") };
+}
+function checkToiljsInstalled(version2) {
+  return version2 ? { id: "toiljs", label: "toiljs", status: "pass", detail: version2 } : {
+    id: "toiljs",
+    label: "toiljs",
+    status: "fail",
+    detail: "not a dependency of this project",
+    fix: "Add toiljs to dependencies, or run from the project root with --root."
+  };
+}
+function checkDir(id, label, exists, fix) {
+  return exists ? { id, label, status: "pass" } : { id, label, status: "fail", detail: "missing", fix };
+}
+function checkMountSlots(entrySource) {
+  const label = "App entry mount()";
+  if (entrySource === null) {
+    return {
+      id: "mount",
+      label,
+      status: "warn",
+      detail: "entry file not found",
+      fix: "Ensure client/toil.tsx calls Toil.mount(...)."
+    };
+  }
+  const call = /\bmount\s*\(([^)]*)\)/.exec(entrySource);
+  if (!call) {
+    return {
+      id: "mount",
+      label,
+      status: "warn",
+      detail: "no mount() call found",
+      fix: "Call Toil.mount(routes, layout, notFound, globalError, slots)."
+    };
+  }
+  const hasSlots = /\bslots\b/.test(call[1]);
+  return hasSlots ? { id: "mount", label, status: "pass", detail: "passes slots" } : {
+    id: "mount",
+    label,
+    status: "warn",
+    detail: "mount() is missing the slots argument",
+    fix: "Pass slots last: mount(routes, layout, notFound, globalError, slots). Without it, parallel and intercepting routes are ignored."
+  };
+}
+function checkRootElement(indexHtml) {
+  const label = "index.html mount target";
+  if (indexHtml === null) {
+    return {
+      id: "root-el",
+      label,
+      status: "fail",
+      detail: "index.html not found",
+      fix: 'Add public/index.html with <div id="root"></div>.'
+    };
+  }
+  const ok = /id\s*=\s*["']root["']/.test(indexHtml);
+  return ok ? { id: "root-el", label, status: "pass" } : {
+    id: "root-el",
+    label,
+    status: "fail",
+    detail: 'no element with id="root"',
+    fix: 'Add <div id="root"></div> to public/index.html.'
+  };
+}
+function checkRoutesPresent(routeCount) {
+  return routeCount > 0 ? {
+    id: "routes",
+    label: "Routes",
+    status: "pass",
+    detail: `${routeCount} route${routeCount === 1 ? "" : "s"}`
+  } : {
+    id: "routes",
+    label: "Routes",
+    status: "fail",
+    detail: "no routes found",
+    fix: "Add a page, e.g. client/routes/index.tsx."
+  };
+}
+function checkDuplicatePatterns(patterns) {
+  const seen = /* @__PURE__ */ new Set();
+  const dupes = /* @__PURE__ */ new Set();
+  for (const p2 of patterns) {
+    if (seen.has(p2)) dupes.add(p2);
+    else seen.add(p2);
+  }
+  return dupes.size === 0 ? { id: "route-dupes", label: "Unique route patterns", status: "pass" } : {
+    id: "route-dupes",
+    label: "Unique route patterns",
+    status: "warn",
+    detail: `duplicate: ${[...dupes].join(", ")}`,
+    fix: "Two route files map to the same URL; rename or remove one."
+  };
+}
+function isBrokenRelativeAsset(value) {
+  if (value === "") return false;
+  if (value.startsWith("/")) return false;
+  if (/^[a-z][a-z0-9+.-]*:/i.test(value)) return false;
+  if (value.startsWith("#") || value.startsWith("?")) return false;
+  return /\.(svgz?|png|jpe?g|gif|webp|avif|ico|css|m?js|woff2?|ttf|otf|eot|mp4|webm|json)$/i.test(
+    value
+  );
+}
+function findRelativeAssets(files) {
+  const issues = [];
+  const attr = /\b(?:src|href)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+  for (const file of files) {
+    const lines = file.source.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      attr.lastIndex = 0;
+      let m2;
+      while ((m2 = attr.exec(lines[i])) !== null) {
+        const value = m2[1] ?? m2[2] ?? "";
+        if (isBrokenRelativeAsset(value)) {
+          issues.push({ file: file.path, line: i + 1, value });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function checkRelativeAssets(issues) {
+  if (issues.length === 0) return { id: "rel-assets", label: "Asset paths", status: "pass" };
+  const shown = issues.slice(0, 5).map((i) => `${i.file}:${String(i.line)} "${i.value}"`).join("; ");
+  const more = issues.length > 5 ? `, and ${String(issues.length - 5)} more` : "";
+  return {
+    id: "rel-assets",
+    label: "Asset paths",
+    status: "warn",
+    detail: `${String(issues.length)} relative reference(s): ${shown}${more}`,
+    fix: 'Use a root-absolute path (e.g. "/images/logo.svg") or import the asset; relative paths 404 on nested routes.'
+  };
+}
+function checkConfigLoads(loaded, error) {
+  return loaded ? { id: "config", label: "toil.config loads", status: "pass" } : {
+    id: "config",
+    label: "toil.config loads",
+    status: "fail",
+    detail: error ?? "failed to load",
+    fix: "Fix the error in your toil.config.* so dev/build can read it."
+  };
+}
+function checkBasePath(base) {
+  const ok = base === "/" || base.startsWith("/") && base.endsWith("/");
+  return ok ? { id: "base", label: "Base path", status: "pass", detail: base } : {
+    id: "base",
+    label: "Base path",
+    status: "warn",
+    detail: `"${base}"`,
+    fix: 'A non-root base should start and end with "/" (e.g. "/app/").'
+  };
+}
+function checkSeoUrl(seoConfigured, hasUrl) {
+  if (!seoConfigured) {
+    return {
+      id: "seo-url",
+      label: "SEO site url",
+      status: "pass",
+      detail: "SEO not configured"
+    };
+  }
+  return hasUrl ? { id: "seo-url", label: "SEO site url", status: "pass" } : {
+    id: "seo-url",
+    label: "SEO site url",
+    status: "warn",
+    detail: "seo is set without a url",
+    fix: "Set client.seo.url so sitemap.xml and canonical links are absolute."
+  };
+}
+function checkStyling(f2) {
+  const label = "Styling";
+  if (f2.preprocessorImported && f2.preprocessorImported !== "css" && !f2.preprocessorInstalled) {
+    return {
+      id: "styling",
+      label,
+      status: "fail",
+      detail: `${f2.preprocessorImported} stylesheet imported but ${f2.preprocessorImported} is not installed`,
+      fix: `Install ${f2.preprocessorImported}, or run toiljs configure.`
+    };
+  }
+  if (f2.tailwindImported && !f2.tailwindInstalled) {
+    return {
+      id: "styling",
+      label,
+      status: "fail",
+      detail: "Tailwind entry imported but @tailwindcss/vite is not installed",
+      fix: "Run toiljs configure --tailwind, or install @tailwindcss/vite."
+    };
+  }
+  return { id: "styling", label, status: "pass" };
+}
+function checkToilconfig(present) {
+  return present ? { id: "toilconfig", label: "Server target (toilconfig.json)", status: "pass" } : {
+    id: "toilconfig",
+    label: "Server target (toilconfig.json)",
+    status: "warn",
+    detail: "no toilconfig.json (no WebAssembly server)",
+    fix: "Add toilconfig.json + a server/ entry if you want a WASM backend."
+  };
+}
+function checkServerEntry(missing) {
+  return missing.length === 0 ? { id: "server-entry", label: "Server entries", status: "pass" } : {
+    id: "server-entry",
+    label: "Server entries",
+    status: "fail",
+    detail: `missing: ${missing.join(", ")}`,
+    fix: 'Create the entry file(s) listed in toilconfig.json "entries", or update them.'
+  };
+}
+function checkToilscriptInstalled(installed) {
+  return installed ? { id: "toilscript", label: "toilscript compiler", status: "pass" } : {
+    id: "toilscript",
+    label: "toilscript compiler",
+    status: "warn",
+    detail: "toilconfig.json present but toilscript is not installed",
+    fix: "Install toilscript to compile the server to WebAssembly."
+  };
+}
+function checkWasmBuilt(exists) {
+  return exists ? { id: "wasm", label: "Server build", status: "pass" } : {
+    id: "wasm",
+    label: "Server build",
+    status: "warn",
+    detail: "no compiled .wasm found",
+    fix: "Run your server build (toilscript) before toiljs start."
+  };
+}
+function summarize(groups) {
+  let pass = 0;
+  let warn2 = 0;
+  let fail = 0;
+  for (const group of groups) {
+    for (const check of group.checks) {
+      if (check.status === "pass") pass++;
+      else if (check.status === "warn") warn2++;
+      else fail++;
+    }
+  }
+  return { pass, warn: warn2, fail };
+}
+function hasFailures(summary) {
+  return summary.fail > 0;
+}
+
+// src/cli/doctor.ts
+function readJsonObject(file) {
+  try {
+    const parsed = JSON.parse(fs4.readFileSync(file, "utf8"));
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function stringRecord(value) {
+  if (typeof value !== "object" || value === null) return {};
+  const out = {};
+  for (const [k2, v2] of Object.entries(value)) if (typeof v2 === "string") out[k2] = v2;
+  return out;
+}
+function readFile(file) {
+  try {
+    return fs4.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+function frameworkMeta() {
+  const pkgPath = path5.resolve(
+    path5.dirname(fileURLToPath3(import.meta.url)),
+    "..",
+    "..",
+    "package.json"
+  );
+  const pkg = readJsonObject(pkgPath);
+  const engines = pkg ? stringRecord(pkg.engines) : {};
+  const peers = pkg ? stringRecord(pkg.peerDependencies) : {};
+  return { node: engines.node ?? ">=24.0.0", peers };
+}
+var LOCKFILES = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb"];
+function readEntry(clientAbsDir) {
+  for (const name of ["toil.tsx", "toil.jsx", "main.tsx", "main.jsx"]) {
+    const source = readFile(path5.join(clientAbsDir, name));
+    if (source !== null && /toiljs\/routes|\bmount\s*\(/.test(source)) return source;
+  }
+  return null;
+}
+function collectSources(root, dir, cap) {
+  const out = [];
+  const visit = (current) => {
+    if (out.length >= cap) return;
+    let entries;
+    try {
+      entries = fs4.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (out.length >= cap) break;
+      const full = path5.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name !== "node_modules") visit(full);
+      } else if (/\.(tsx|jsx)$/.test(entry.name)) {
+        const source = readFile(full);
+        if (source !== null) out.push({ path: path5.relative(root, full), source });
+      }
+    }
+  };
+  visit(dir);
+  return out;
+}
+function glyph(status) {
+  if (status === "pass") return success("\u2713");
+  if (status === "warn") return warn("\u26A0");
+  return danger("\u2717");
+}
+function renderHuman(groups) {
+  const summary = summarize(groups);
+  const out = [];
+  for (const group of groups) {
+    out.push("  " + bold(group.title));
+    for (const check of group.checks) {
+      let line = `    ${glyph(check.status)} ${check.label}`;
+      if (check.detail) line += dim(`  ${check.detail}`);
+      out.push(line);
+      if (check.fix && check.status !== "pass")
+        out.push("       " + dim(`fix: ${check.fix}`));
+    }
+    out.push("");
+  }
+  const parts = [success(`${String(summary.pass)} passed`)];
+  if (summary.warn > 0) {
+    parts.push(warn(`${String(summary.warn)} warning${summary.warn === 1 ? "" : "s"}`));
+  }
+  if (summary.fail > 0) parts.push(danger(`${String(summary.fail)} failed`));
+  out.push("  " + parts.join(dim(", ")));
+  out.push("");
+  process.stdout.write(out.join("\n") + "\n");
+}
+async function runDoctor(opts) {
+  const root = path5.resolve(opts.root ?? opts.cwd);
+  const meta = frameworkMeta();
+  const projectPkg = readJsonObject(path5.join(root, "package.json"));
+  const deps = {
+    ...projectPkg ? stringRecord(projectPkg.dependencies) : {},
+    ...projectPkg ? stringRecord(projectPkg.devDependencies) : {}
+  };
+  let cfg = null;
+  let configError;
+  try {
+    cfg = await loadConfig2({ root });
+  } catch (err) {
+    configError = err instanceof Error ? err.message : String(err);
+  }
+  const clientAbsDir = cfg ? cfg.clientAbsDir : path5.join(root, "client");
+  const routesAbsDir = cfg ? cfg.routesAbsDir : path5.join(clientAbsDir, "routes");
+  const publicDir = cfg ? cfg.publicDir : path5.join(clientAbsDir, "public");
+  const entrySource = readEntry(clientAbsDir);
+  const indexHtml = readFile(path5.join(publicDir, "index.html"));
+  const routes = scanRoutes(routesAbsDir);
+  const mainPatterns = routes.filter((r) => r.slot === void 0).map((r) => r.pattern);
+  const assetIssues = findRelativeAssets(collectSources(root, clientAbsDir, 200));
+  let preprocessorImported = null;
+  let tailwindImported = false;
+  if (entrySource) {
+    const styleImport = /import\s+['"]\.\/styles\/main\.([a-z]+)['"]/.exec(entrySource);
+    if (styleImport) preprocessorImported = preprocessorForExt(styleImport[1]);
+    tailwindImported = entrySource.includes(TAILWIND_ENTRY);
+  }
+  const ppPkg = preprocessorImported ? PREPROCESSOR_PKG[preprocessorImported] : null;
+  const preprocessorInstalled = ppPkg === null || ppPkg in deps;
+  const toilconfig = readJsonObject(path5.join(root, "toilconfig.json"));
+  const serverPresent = toilconfig !== null;
+  let missingEntries = [];
+  let toilscriptInstalled = false;
+  let wasmExists = false;
+  if (toilconfig) {
+    const entries = Array.isArray(toilconfig.entries) ? toilconfig.entries.filter((e2) => typeof e2 === "string") : [];
+    missingEntries = entries.filter((e2) => !fs4.existsSync(path5.join(root, e2)));
+    try {
+      createRequire(path5.join(root, "package.json")).resolve("toilscript");
+      toilscriptInstalled = true;
+    } catch {
+      toilscriptInstalled = false;
+    }
+    const targets = typeof toilconfig.targets === "object" && toilconfig.targets !== null ? toilconfig.targets : {};
+    const outFiles = [];
+    for (const target of Object.values(targets)) {
+      if (typeof target === "object" && target !== null) {
+        const outFile = target.outFile;
+        if (typeof outFile === "string") outFiles.push(outFile);
+      }
+    }
+    wasmExists = outFiles.some((f2) => fs4.existsSync(path5.join(root, f2)));
+    if (!wasmExists && outFiles.length === 0) {
+      try {
+        wasmExists = fs4.readdirSync(path5.join(root, "build", "server")).some((f2) => f2.endsWith(".wasm"));
+      } catch {
+        wasmExists = false;
+      }
+    }
+  }
+  const peerName = (n) => checkPeer(n, deps[n] ?? null, meta.peers[n] ?? "*");
+  const peerChecks = Object.keys(meta.peers).map(peerName);
+  const groups = [
+    {
+      title: "Environment",
+      checks: [
+        checkNode(process.versions.node, meta.node),
+        checkToiljsInstalled("toiljs" in deps ? version() : null),
+        ...peerChecks,
+        checkPackageManager(LOCKFILES.filter((f2) => fs4.existsSync(path5.join(root, f2))))
+      ]
+    },
+    {
+      title: "Project + routing",
+      checks: [
+        checkDir(
+          "client-dir",
+          "client/ directory",
+          fs4.existsSync(clientAbsDir),
+          "Create a client/ directory for your app."
+        ),
+        checkDir(
+          "routes-dir",
+          "routes/ directory",
+          fs4.existsSync(routesAbsDir),
+          "Create client/routes/ and add an index.tsx."
+        ),
+        checkRootElement(indexHtml),
+        checkMountSlots(entrySource),
+        checkRoutesPresent(routes.length),
+        checkDuplicatePatterns(mainPatterns),
+        checkRelativeAssets(assetIssues)
+      ]
+    },
+    {
+      title: "Config + assets",
+      checks: [
+        checkConfigLoads(cfg !== null, configError),
+        checkBasePath(cfg ? cfg.base : "/"),
+        checkSeoUrl(cfg?.seo != null, cfg?.seo?.url != null),
+        checkStyling({
+          preprocessorImported,
+          preprocessorInstalled,
+          tailwindImported,
+          tailwindInstalled: detectTailwind(deps)
+        })
+      ]
+    },
+    {
+      title: "Server / WASM",
+      checks: serverPresent ? [
+        checkToilconfig(true),
+        checkServerEntry(missingEntries),
+        checkToilscriptInstalled(toilscriptInstalled),
+        checkWasmBuilt(wasmExists)
+      ] : [checkToilconfig(false)]
+    }
+  ];
+  const summary = summarize(groups);
+  if (opts.json) {
+    process.stdout.write(JSON.stringify({ groups, summary }, null, 2) + "\n");
+  } else {
+    process.stdout.write("\n" + accent("  Doctor") + dim(`  ${root}`) + "\n\n");
+    renderHuman(groups);
+  }
+  if (hasFailures(summary)) process.exitCode = 1;
+}
+
+// src/cli/update.ts
+import fs5 from "node:fs";
+import path6 from "node:path";
+
+// src/cli/updates.ts
+function parseVersion2(v2) {
+  const m2 = /(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(v2);
+  if (!m2) return [0, 0, 0];
+  return [Number(m2[1]), Number(m2[2] ?? 0), Number(m2[3] ?? 0)];
+}
+function classifyBump(from, to) {
+  const [fa, fb, fc] = parseVersion2(from);
+  const [ta, tb, tc] = parseVersion2(to);
+  if (ta !== fa) return "major";
+  if (tb !== fb) return "minor";
+  if (tc !== fc) return "patch";
+  return "other";
+}
+function parseNcuJson(stdout) {
+  const start2 = stdout.indexOf("{");
+  const end = stdout.lastIndexOf("}");
+  if (start2 === -1 || end <= start2) return {};
+  try {
+    const parsed = JSON.parse(stdout.slice(start2, end + 1));
+    if (typeof parsed !== "object" || parsed === null) return {};
+    const out = {};
+    for (const [k2, v2] of Object.entries(parsed)) if (typeof v2 === "string") out[k2] = v2;
+    return out;
+  } catch {
+    return {};
+  }
+}
+var SEVERITY = { major: 0, minor: 1, patch: 2, other: 3 };
+function buildRows(upgraded, currentDeps) {
+  return Object.entries(upgraded).map(([name, to]) => {
+    const from = currentDeps[name] ?? "?";
+    return { name, from, to, bump: classifyBump(from, to) };
+  }).sort((a, b2) => SEVERITY[a.bump] - SEVERITY[b2.bump] || a.name.localeCompare(b2.name));
+}
+
+// src/cli/update.ts
+function detectPackageManager2(root) {
+  if (fs5.existsSync(path6.join(root, "pnpm-lock.yaml"))) return { name: "pnpm", ncuName: "pnpm" };
+  if (fs5.existsSync(path6.join(root, "yarn.lock"))) return { name: "yarn", ncuName: "yarn" };
+  if (fs5.existsSync(path6.join(root, "bun.lockb"))) return { name: "bun", ncuName: "bun" };
+  return { name: "npm", ncuName: "npm" };
+}
+function readDependencies(pkgPath) {
+  const parsed = JSON.parse(fs5.readFileSync(pkgPath, "utf8"));
+  if (typeof parsed !== "object" || parsed === null) return {};
+  const pkg = parsed;
+  const merge = (v2) => {
+    if (typeof v2 !== "object" || v2 === null) return {};
+    const out = {};
+    for (const [k2, val] of Object.entries(v2)) if (typeof val === "string") out[k2] = val;
+    return out;
+  };
+  return { ...merge(pkg.dependencies), ...merge(pkg.devDependencies) };
+}
+function bumpColor(bump, text) {
+  if (bump === "major") return danger(text);
+  if (bump === "minor") return warn(text);
+  if (bump === "patch") return success(text);
+  return dim(text);
+}
+function rowLine(row) {
+  return `${row.name}  ${dim(row.from)} ${dim("->")} ${bumpColor(row.bump, row.to)}`;
+}
+var TARGETS = /* @__PURE__ */ new Set(["latest", "minor", "patch", "newest", "greatest"]);
+async function runUpdate(opts) {
+  const root = path6.resolve(opts.root ?? opts.cwd);
+  const pkgPath = path6.join(root, "package.json");
+  if (!fs5.existsSync(pkgPath)) {
+    throw new Error("No package.json here. Run from your project root or pass --root <dir>.");
+  }
+  const currentDeps = readDependencies(pkgPath);
+  const pm = detectPackageManager2(root);
+  const target = opts.target && TARGETS.has(opts.target) ? opts.target : "latest";
+  const ncuArgs = (extra) => [
+    "--yes",
+    "npm-check-updates",
+    "--packageManager",
+    pm.ncuName,
+    "--target",
+    target,
+    ...extra
+  ];
+  ye(accent("toiljs update"));
+  const s = vt();
+  s.start("Checking the registry for updates");
+  const res = await capture("npx", ncuArgs(["--jsonUpgraded"]), root);
+  if (res.code !== 0 && res.stdout.indexOf("{") === -1) {
+    s.stop("Could not check for updates");
+    Ce(dim(res.stderr.trim() || "npm-check-updates failed."), "Error");
+    process.exitCode = 1;
+    return;
+  }
+  const rows = buildRows(parseNcuJson(res.stdout), currentDeps);
+  if (rows.length === 0) {
+    s.stop("Everything is up to date");
+    fe(success("Nothing to update."));
+    return;
+  }
+  s.stop(`${String(rows.length)} update${rows.length === 1 ? "" : "s"} available`);
+  const counts = { major: 0, minor: 0, patch: 0, other: 0 };
+  for (const r of rows) counts[r.bump]++;
+  Ce(
+    rows.map(rowLine).join("\n"),
+    `${danger(`${String(counts.major)} major`)}  ${warn(`${String(counts.minor)} minor`)}  ${success(`${String(counts.patch)} patch`)}`
+  );
+  let selected;
+  if (opts.yes) {
+    selected = rows.map((r) => r.name);
+  } else {
+    const answer = await we({
+      message: "Select packages to update (space to toggle, enter to confirm)",
+      options: rows.map((r) => ({
+        value: r.name,
+        label: r.name,
+        hint: `${r.from} -> ${r.to}`
+      })),
+      initialValues: rows.map((r) => r.name),
+      required: false
+    });
+    if (R(answer)) {
+      ge("Update cancelled.");
+      return;
+    }
+    selected = answer;
+  }
+  if (selected.length === 0) {
+    fe(dim("No packages selected."));
+    return;
+  }
+  s.start("Updating package.json");
+  const applyAll = selected.length === rows.length;
+  await run("npx", ncuArgs(applyAll ? ["-u"] : ["-u", "--filter", selected.join(" ")]), root);
+  s.stop("package.json updated");
+  s.start(`Installing with ${pm.name}`);
+  await run(pm.name, ["install"], root);
+  s.stop("Dependencies installed");
+  fe(
+    success(`Updated ${String(selected.length)} package${selected.length === 1 ? "" : "s"}.`)
+  );
+}
+
+// src/cli/index.ts
+function parseArgs(argv) {
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--root":
+        flags.root = argv[++i];
+        break;
+      case "--port": {
+        const port = Number(argv[++i]);
+        if (!Number.isNaN(port)) flags.port = port;
+        break;
+      }
+      case "--template":
+      case "-t": {
+        const t = argv[++i];
+        if (t === "app" || t === "minimal") flags.template = t;
+        break;
+      }
+      case "--pm":
+        flags.pm = argv[++i];
+        break;
+      case "--style": {
+        const s = argv[++i];
+        if (PREPROCESSORS.includes(s))
+          flags.preprocessor = s;
+        break;
+      }
+      case "--tailwind":
+        flags.tailwind = true;
+        break;
+      case "--no-tailwind":
+        flags.tailwind = false;
+        break;
+      case "--ai":
+        flags.ai = true;
+        break;
+      case "--no-ai":
+        flags.ai = false;
+        break;
+      case "--images":
+        flags.images = true;
+        break;
+      case "--no-images":
+        flags.images = false;
+        break;
+      case "--install":
+        flags.install = true;
+        break;
+      case "--no-install":
+        flags.install = false;
+        break;
+      case "--git":
+        flags.git = true;
+        break;
+      case "--no-git":
+        flags.git = false;
+        break;
+      case "-y":
+      case "--yes":
+        flags.yes = true;
+        break;
+      case "--json":
+        flags.json = true;
+        break;
+      case "--target":
+        flags.target = argv[++i];
+        break;
+      default:
+        if (!arg.startsWith("-") && flags.name === void 0) flags.name = arg;
+    }
+  }
+  return flags;
 }
 function printHelp() {
-    const cmd = (name, desc) => `  ${accent(name.padEnd(15))}${dim(desc)}`;
-    process.stdout.write([
-        `${bold('Usage')}  ${dim('toiljs')} <command> [options]`,
-        '',
-        bold('Commands'),
-        cmd('create [name]', 'scaffold a new toiljs app'),
-        cmd('configure', 'toggle styling features (Sass/Less/Stylus, Tailwind)'),
-        cmd('dev', 'start the dev server with HMR'),
-        cmd('build', 'build the optimized production bundle'),
-        cmd('start', 'self-host the built app (hyper-express / uWS)'),
-        cmd('doctor', 'diagnose project setup and dependencies'),
-        cmd('update', 'check for and apply dependency updates'),
-        '',
-        bold('Options'),
-        cmd('--root <dir>', 'project root (default: current directory)'),
-        cmd('--port <n>', 'dev server port'),
-        cmd('-t, --template', 'create: app | minimal'),
-        cmd('--style <name>', 'create/configure: css | sass | less | stylus'),
-        cmd('--tailwind', 'create/configure: enable Tailwind (--no-tailwind to remove)'),
-        cmd('--no-ai', 'create: skip AI assistant files (CLAUDE.md, etc.)'),
-        cmd('-y, --yes', 'create: accept defaults (non-interactive)'),
-        cmd('--no-install', "create: don't install dependencies"),
-        cmd('--json', 'doctor: machine-readable output'),
-        cmd('--target <t>', 'update: latest | minor | patch | newest | greatest'),
-        cmd('-v, --version', 'print the toiljs version'),
-        '',
-    ].join('\n') + '\n');
+  const cmd = (name, desc) => `  ${accent(name.padEnd(15))}${dim(desc)}`;
+  process.stdout.write(
+    [
+      `${bold("Usage")}  ${dim("toiljs")} <command> [options]`,
+      "",
+      bold("Commands"),
+      cmd("create [name]", "scaffold a new toiljs app"),
+      cmd("configure", "toggle styling features (Sass/Less/Stylus, Tailwind)"),
+      cmd("dev", "start the dev server with HMR"),
+      cmd("build", "build the optimized production bundle"),
+      cmd("start", "self-host the built app (hyper-express / uWS)"),
+      cmd("doctor", "diagnose project setup and dependencies"),
+      cmd("update", "check for and apply dependency updates"),
+      "",
+      bold("Options"),
+      cmd("--root <dir>", "project root (default: current directory)"),
+      cmd("--port <n>", "dev server port"),
+      cmd("-t, --template", "create: app | minimal"),
+      cmd("--style <name>", "create/configure: css | sass | less | stylus"),
+      cmd("--tailwind", "create/configure: enable Tailwind (--no-tailwind to remove)"),
+      cmd("--no-ai", "create: skip AI assistant files (CLAUDE.md, etc.)"),
+      cmd("-y, --yes", "create: accept defaults (non-interactive)"),
+      cmd("--no-install", "create: don't install dependencies"),
+      cmd("--json", "doctor: machine-readable output"),
+      cmd("--target <t>", "update: latest | minor | patch | newest | greatest"),
+      cmd("-v, --version", "print the toiljs version"),
+      ""
+    ].join("\n") + "\n"
+  );
 }
 async function main() {
-    const [command, ...rest] = process.argv.slice(2);
-    if (command === '--version' || command === '-v') {
-        process.stdout.write(version() + '\n');
-        return;
-    }
-    const flags = parseArgs(rest);
-    switch (command) {
-        case 'create':
-            banner();
-            await runCreate({
-                name: flags.name,
-                template: flags.template,
-                preprocessor: flags.preprocessor,
-                tailwind: flags.tailwind,
-                ai: flags.ai,
-                images: flags.images,
-                install: flags.install,
-                git: flags.git,
-                pm: flags.pm,
-                yes: flags.yes,
-                cwd: process.cwd(),
-            });
-            break;
-        case 'configure':
-            banner();
-            await runConfigure({
-                root: flags.root,
-                preprocessor: flags.preprocessor,
-                tailwind: flags.tailwind,
-                images: flags.images,
-                install: flags.install,
-                cwd: process.cwd(),
-            });
-            break;
-        case 'dev':
-            banner();
-            process.stdout.write(dim('  starting dev server…') + '\n\n');
-            await dev({ root: flags.root, port: flags.port });
-            break;
-        case 'build':
-            banner();
-            process.stdout.write(dim('  building for production…') + '\n\n');
-            await build({ root: flags.root });
-            process.stdout.write('\n' + success('  ✓ ') + bold('build complete') + '\n\n');
-            break;
-        case 'start': {
-            banner();
-            process.stdout.write(dim('  self-hosting the built app…') + '\n\n');
-            const server = await start({ root: flags.root, port: flags.port });
-            process.stdout.write(accent('  ➜ ') +
-                bold(`http://localhost:${String(server.port)}`) +
-                dim(`   ws channel: ${server.wsPath}`) +
-                '\n\n');
-            break;
-        }
-        case 'doctor':
-            if (!flags.json)
-                banner();
-            await runDoctor({ root: flags.root, cwd: process.cwd(), json: flags.json });
-            break;
-        case 'update':
-            banner();
-            await runUpdate({
-                root: flags.root,
-                cwd: process.cwd(),
-                yes: flags.yes,
-                target: flags.target,
-            });
-            break;
-        case 'help':
-        case '--help':
-        case '-h':
-        case undefined:
-            banner();
-            printHelp();
-            break;
-        default:
-            banner();
-            process.stdout.write(dim(`  unknown command: ${command}`) + '\n\n');
-            printHelp();
-            process.exitCode = 1;
+  const [command, ...rest] = process.argv.slice(2);
+  if (command === "--version" || command === "-v") {
+    process.stdout.write(version() + "\n");
+    return;
+  }
+  const flags = parseArgs(rest);
+  switch (command) {
+    case "create":
+      banner();
+      await runCreate({
+        name: flags.name,
+        template: flags.template,
+        preprocessor: flags.preprocessor,
+        tailwind: flags.tailwind,
+        ai: flags.ai,
+        images: flags.images,
+        install: flags.install,
+        git: flags.git,
+        pm: flags.pm,
+        yes: flags.yes,
+        cwd: process.cwd()
+      });
+      break;
+    case "configure":
+      banner();
+      await runConfigure({
+        root: flags.root,
+        preprocessor: flags.preprocessor,
+        tailwind: flags.tailwind,
+        images: flags.images,
+        install: flags.install,
+        cwd: process.cwd()
+      });
+      break;
+    case "dev":
+      banner();
+      process.stdout.write(dim("  starting dev server\u2026") + "\n\n");
+      await dev({ root: flags.root, port: flags.port });
+      break;
+    case "build":
+      banner();
+      process.stdout.write(dim("  building for production\u2026") + "\n\n");
+      await build({ root: flags.root });
+      process.stdout.write("\n" + success("  \u2713 ") + bold("build complete") + "\n\n");
+      break;
+    case "start": {
+      banner();
+      process.stdout.write(dim("  self-hosting the built app\u2026") + "\n\n");
+      const server = await start({ root: flags.root, port: flags.port });
+      process.stdout.write(
+        accent("  \u279C ") + bold(`http://localhost:${String(server.port)}`) + dim(`   ws channel: ${server.wsPath}`) + "\n\n"
+      );
+      break;
     }
+    case "doctor":
+      if (!flags.json) banner();
+      await runDoctor({ root: flags.root, cwd: process.cwd(), json: flags.json });
+      break;
+    case "update":
+      banner();
+      await runUpdate({
+        root: flags.root,
+        cwd: process.cwd(),
+        yes: flags.yes,
+        target: flags.target
+      });
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+    case void 0:
+      banner();
+      printHelp();
+      break;
+    default:
+      banner();
+      process.stdout.write(dim(`  unknown command: ${command}`) + "\n\n");
+      printHelp();
+      process.exitCode = 1;
+  }
 }
 main().catch((err) => {
-    const message = err instanceof Error ? err.message : String(err);
-    process.stderr.write('\n' + danger('  ✗ ') + message + '\n');
-    process.exitCode = 1;
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write("\n" + danger("  \u2717 ") + message + "\n");
+  process.exitCode = 1;
 });