toiljs 0.0.16 → 0.0.19

package/build/cli/index.js

@@ -32,15 +32,15 @@ var require_src = __commonJS({
     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`;
+    var cursor3 = {
+      to(x, y) {
+        if (!y) return `${CSI2}${x + 1}G`;
+        return `${CSI2}${y + 1};${x + 1}H`;
       },
-      move(x3, y) {
+      move(x, y) {
         let ret = "";
-        if (x3 < 0) ret += `${CSI2}${-x3}D`;
-        else if (x3 > 0) ret += `${CSI2}${x3}C`;
+        if (x < 0) ret += `${CSI2}${-x}D`;
+        else if (x > 0) ret += `${CSI2}${x}C`;
         if (y < 0) ret += `${CSI2}${-y}A`;
         else if (y > 0) ret += `${CSI2}${y}B`;
         return ret;
@@ -61,7 +61,7 @@ var require_src = __commonJS({
       up: (count = 1) => `${CSI2}S`.repeat(count),
       down: (count = 1) => `${CSI2}T`.repeat(count)
     };
-    var erase = {
+    var erase3 = {
       screen: `${CSI2}2J`,
       up: (count = 1) => `${CSI2}1J`.repeat(count),
       down: (count = 1) => `${CSI2}J`.repeat(count),
@@ -70,82 +70,82 @@ var require_src = __commonJS({
       lineStart: `${CSI2}1K`,
       lines(count) {
         let clear = "";
-        for (let i = 0; i < count; i++)
-          clear += this.line + (i < count - 1 ? cursor.up() : "");
+        for (let i2 = 0; i2 < count; i2++)
+          clear += this.line + (i2 < count - 1 ? cursor3.up() : "");
         if (count)
-          clear += cursor.left;
+          clear += cursor3.left;
         return clear;
       }
     };
-    module.exports = { cursor, scroll, erase, beep };
+    module.exports = { cursor: cursor3, scroll, erase: erase3, 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 p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.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;
+      let result = "", cursor3 = 0;
       do {
-        result += string.substring(cursor, index) + replace;
-        cursor = index + close.length;
-        index = string.indexOf(close, cursor);
+        result += string.substring(cursor3, index) + replace;
+        cursor3 = index + close.length;
+        index = string.indexOf(close, cursor3);
       } while (~index);
-      return result + string.substring(cursor);
+      return result + string.substring(cursor3);
     };
     var createColors = (enabled = isColorSupported) => {
-      let f2 = enabled ? formatter : () => String;
+      let f = 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")
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
       };
     };
     module.exports = createColors();
@@ -161,10 +161,10 @@ 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";
+import { styleText } from "node:util";
+import { stdout, stdin } from "node:process";
+import * as l from "node:readline";
+import l__default from "node:readline";
 
 // node_modules/fast-string-truncated-width/dist/utils.js
 var getCodePointsLength = /* @__PURE__ */ (() => {
@@ -178,11 +178,11 @@ var getCodePointsLength = /* @__PURE__ */ (() => {
     return input.length - surrogatePairsNr;
   };
 })();
-var isFullWidth = (x3) => {
-  return x3 === 12288 || x3 >= 65281 && x3 <= 65376 || x3 >= 65504 && x3 <= 65510;
+var isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 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;
+var isWideNotCJKTNotEmoji = (x) => {
+  return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
 };
 
 // node_modules/fast-string-truncated-width/dist/index.js
@@ -252,8 +252,8 @@ var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {})
     if (index >= length) {
       break outer;
     }
-    for (let i = 0, l = PARSE_BLOCKS.length; i < l; i++) {
-      const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+    for (let i2 = 0, l2 = PARSE_BLOCKS.length; i2 < l2; i2++) {
+      const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i2];
       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;
@@ -456,8 +456,8 @@ var exec = (string, columns, options = {}) => {
   }
   const preString = rows.join("\n");
   let inSurrogate = false;
-  for (let i = 0; i < preString.length; i++) {
-    const character = preString[i];
+  for (let i2 = 0; i2 < preString.length; i2++) {
+    const character = preString[i2];
     returnValue += character;
     if (!inSurrogate) {
       inSurrogate = character >= "\uD800" && character <= "\uDBFF";
@@ -468,7 +468,7 @@ var exec = (string, columns, options = {}) => {
       inSurrogate = false;
     }
     if (character === ESC || character === CSI) {
-      GROUP_REGEX.lastIndex = i + 1;
+      GROUP_REGEX.lastIndex = i2 + 1;
       const groupsResult = GROUP_REGEX.exec(preString);
       const groups = groupsResult?.groups;
       if (groups?.code !== void 0) {
@@ -478,7 +478,7 @@ var exec = (string, columns, options = {}) => {
         escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
       }
     }
-    if (preString[i + 1] === "\n") {
+    if (preString[i2 + 1] === "\n") {
       if (escapeUrl) {
         returnValue += wrapAnsiHyperlink("");
       }
@@ -504,78 +504,144 @@ function wrapAnsi(string, columns, options) {
 
 // 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;
+import { ReadStream } from "node:tty";
+function findCursor(s, o2, l2) {
+  if (!l2.some((r2) => !r2.disabled))
+    return s;
+  const t2 = s + o2, n2 = Math.max(l2.length - 1, 0), e = t2 < 0 ? n2 : t2 > n2 ? 0 : t2;
+  return l2[e].disabled ? findCursor(e, o2 < 0 ? -1 : 1, l2) : e;
+}
+var a$2 = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var t = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var settings = {
+  actions: new Set(a$2),
+  aliases: /* @__PURE__ */ new Map([
+    // vim support
+    ["k", "up"],
+    ["j", "down"],
+    ["h", "left"],
+    ["l", "right"],
+    ["", "cancel"],
+    // opinionated defaults!
+    ["escape", "cancel"]
+  ]),
+  messages: {
+    cancel: "Canceled",
+    error: "Something went wrong"
+  },
+  withGuide: true,
+  date: {
+    monthNames: [...t],
+    messages: {
+      required: "Please enter a valid date",
+      invalidMonth: "There are only 12 months in a year",
+      invalidDay: (n2, e) => `There are only ${n2} days in ${e}`,
+      afterMin: (n2) => `Date must be on or after ${n2.toISOString().slice(0, 10)}`,
+      beforeMax: (n2) => `Date must be on or before ${n2.toISOString().slice(0, 10)}`
+    }
+  }
+};
+function isActionKey(n2, e) {
+  if (typeof n2 == "string")
+    return settings.aliases.get(n2) === e;
+  for (const s of n2)
+    if (s !== void 0 && isActionKey(s, e))
+      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);
+function diffLines(i2, s) {
+  if (i2 === s) return;
+  const e = i2.split(`
+`), t2 = s.split(`
+`), r2 = Math.max(e.length, t2.length), f = [];
+  for (let n2 = 0; n2 < r2; n2++)
+    e[n2] !== t2[n2] && f.push(n2);
+  return {
+    lines: f,
+    numLinesBefore: e.length,
+    numLinesAfter: t2.length,
+    numLines: r2
+  };
+}
+var R = globalThis.process.platform.startsWith("win");
+var CANCEL_SYMBOL = /* @__PURE__ */ Symbol("clack:cancel");
+function isCancel(e) {
+  return e === CANCEL_SYMBOL;
+}
+function setRawMode(e, r2) {
+  const o2 = e;
+  o2.isTTY && o2.setRawMode(r2);
+}
+function block({
+  input: e = stdin,
+  output: r2 = stdout,
+  overwrite: o2 = true,
+  hideCursor: t2 = true
+} = {}) {
+  const s = l.createInterface({
+    input: e,
+    output: r2,
+    prompt: "",
+    tabSize: 1
+  });
+  l.emitKeypressEvents(e, s), e instanceof ReadStream && e.isTTY && e.setRawMode(true);
+  const n2 = (f, { name: a3, sequence: p }) => {
+    const c2 = String(f);
+    if (isActionKey([c2, a3, p], "cancel")) {
+      t2 && r2.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);
+    if (!o2) return;
+    const i2 = a3 === "return" ? 0 : -1, m = a3 === "return" ? -1 : 0;
+    l.moveCursor(r2, i2, m, () => {
+      l.clearLine(r2, 1, () => {
+        e.once("keypress", n2);
       });
     });
   };
-  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();
+  return t2 && r2.write(import_sisteransi.cursor.hide), e.once("keypress", n2), () => {
+    e.off("keypress", n2), t2 && r2.write(import_sisteransi.cursor.show), e instanceof ReadStream && e.isTTY && !R && e.setRawMode(false), s.terminal = false, s.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}`;
+var getColumns = (e) => "columns" in e && typeof e.columns == "number" ? e.columns : 80;
+var getRows = (e) => "rows" in e && typeof e.rows == "number" ? e.rows : 20;
+function wrapTextWithPrefix(e, r2, o2, t2 = o2, s = o2, n2) {
+  const f = getColumns(e ?? stdout);
+  return wrapAnsi(r2, f - o2.length, {
+    hard: true,
+    trim: false
+  }).split(`
+`).map((c2, i2, m) => {
+    const d2 = n2 ? n2(c2, i2) : c2;
+    return i2 === 0 ? `${t2}${d2}` : i2 === m.length - 1 ? `${s}${d2}` : `${o2}${d2}`;
   }).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;
+function runValidation(e, n2) {
+  if ("~standard" in e) {
+    const a3 = e["~standard"].validate(n2);
+    if (a3 instanceof Promise)
+      throw new TypeError(
+        "Schema validation must be synchronous. Update `validate()` and remove any asynchronous logic."
+      );
+    return a3.issues?.at(0)?.message;
   }
-  return r(t);
+  return e(n2);
 }
-var m = class {
+var V = class {
   input;
   output;
   _abortSignal;
@@ -590,171 +656,215 @@ var m = class {
   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;
+  constructor(t2, e = true) {
+    const { input: i2 = stdin, output: n2 = stdout, render: s, signal: r2, ...o2 } = t2;
+    this.opts = o2, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = s.bind(this), this._track = e, this._abortSignal = r2, this.input = i2, this.output = n2;
   }
+  /**
+   * Unsubscribe all listeners
+   */
   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();
+  /**
+   * Set a subscriber with opts
+   * @param event - The event name
+   */
+  setSubscriber(t2, e) {
+    const i2 = this._subscribers.get(t2) ?? [];
+    i2.push(e), this._subscribers.set(t2, i2);
+  }
+  /**
+   * Subscribe to an event
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  on(t2, e) {
+    this.setSubscriber(t2, { cb: e });
+  }
+  /**
+   * Subscribe to an event once
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  once(t2, e) {
+    this.setSubscriber(t2, { cb: e, once: true });
+  }
+  /**
+   * Emit an event with data
+   * @param event - The event name
+   * @param data - The data to pass to the callback
+   */
+  emit(t2, ...e) {
+    const i2 = this._subscribers.get(t2) ?? [], n2 = [];
+    for (const s of i2)
+      s.cb(...e), s.once && n2.push(() => i2.splice(i2.indexOf(s), 1));
+    for (const s of n2)
+      s();
   }
   prompt() {
-    return new Promise((t) => {
+    return new Promise((t2) => {
       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 });
+        if (this._abortSignal.aborted)
+          return this.state = "cancel", this.close(), t2(CANCEL_SYMBOL);
+        this._abortSignal.addEventListener(
+          "abort",
+          () => {
+            this.state = "cancel", this.close();
+          },
+          { once: true }
+        );
       }
-      this.rl = 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.rl = l__default.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), setRawMode(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(this.value);
       }), this.once("cancel", () => {
-        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), w(this.input, false), t(k);
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(CANCEL_SYMBOL);
       });
     });
   }
-  _isActionKey(t, s) {
-    return t === "	";
+  _isActionKey(t2, e) {
+    return t2 === "	";
   }
-  _shouldSubmit(t, s) {
+  _shouldSubmit(t2, e) {
     return true;
   }
-  _setValue(t) {
-    this.value = t, this.emit("value", this.value);
+  _setValue(t2) {
+    this.value = t2, 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);
+  _setUserInput(t2, e) {
+    this.userInput = t2 ?? "", this.emit("userInput", this.userInput), e && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
   }
   _clearUserInput() {
     this.rl?.write(null, { ctrl: true, name: "u" }), this._setUserInput("");
   }
-  onKeypress(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)) {
+  onKeypress(t2, e) {
+    if (this._track && e.name !== "return" && (e.name && this._isActionKey(t2, e) && this.rl?.write(null, { ctrl: true, name: "h" }), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), e?.name && (!this._track && settings.aliases.has(e.name) && this.emit("cursor", settings.aliases.get(e.name)), settings.actions.has(e.name) && this.emit("cursor", e.name)), t2 && (t2.toLowerCase() === "y" || t2.toLowerCase() === "n") && this.emit("confirm", t2.toLowerCase() === "y"), this.emit("key", t2, e), e?.name === "return" && this._shouldSubmit(t2, e)) {
       if (this.opts.validate) {
-        const e2 = P(this.opts.validate, this.value);
-        e2 && (this.error = e2 instanceof Error ? e2.message : e2, this.state = "error", this.rl?.write(this.userInput));
+        const i2 = runValidation(this.opts.validate, this.value);
+        i2 && (this.error = i2 instanceof Error ? i2.message : i2, 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();
+    isActionKey([t2, e?.name, e?.sequence], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
   }
   close() {
     this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
-`), w(this.input, false), this.rl?.close(), this.rl = void 0, this.emit(`${this.state}`, this.value), this.unsubscribe();
+`), setRawMode(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(`
+    const t2 = wrapAnsi(this._prevFrame, process.stdout.columns, { hard: true, trim: false }).split(`
 `).length - 1;
-    this.output.write(import_sisteransi.cursor.move(-999, t * -1));
+    this.output.write(import_sisteransi.cursor.move(-999, t2 * -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);
+    const t2 = wrapAnsi(this._render(this) ?? "", process.stdout.columns, {
+      hard: true,
+      trim: false
+    });
+    if (t2 !== this._prevFrame) {
+      if (this.state === "initial")
+        this.output.write(import_sisteransi.cursor.hide);
       else {
-        const 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;
+        const e = diffLines(this._prevFrame, t2), i2 = getRows(this.output);
+        if (this.restoreCursor(), e) {
+          const n2 = Math.max(0, e.numLinesAfter - i2), s = Math.max(0, e.numLinesBefore - i2);
+          let r2 = e.lines.find((o2) => o2 >= n2);
+          if (r2 === void 0) {
+            this._prevFrame = t2;
             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(`
+          if (e.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, r2 - s)), this.output.write(import_sisteransi.erase.lines(1));
+            const o2 = t2.split(`
 `);
-            this.output.write(u[o]), this._prevFrame = t, this.output.write(import_sisteransi.cursor.move(0, u.length - o - 1));
+            this.output.write(o2[r2]), this._prevFrame = t2, this.output.write(import_sisteransi.cursor.move(0, o2.length - r2 - 1));
             return;
-          } else if (s.lines.length > 1) {
-            if (i < n) o = i;
+          } else if (e.lines.length > 1) {
+            if (n2 < s)
+              r2 = n2;
             else {
-              const a = o - n;
-              a > 0 && this.output.write(import_sisteransi.cursor.move(0, a));
+              const h2 = r2 - s;
+              h2 > 0 && this.output.write(import_sisteransi.cursor.move(0, h2));
             }
             this.output.write(import_sisteransi.erase.down());
-            const u = t.split(`
-`).slice(o);
-            this.output.write(u.join(`
-`)), this._prevFrame = t;
+            const f = t2.split(`
+`).slice(r2);
+            this.output.write(f.join(`
+`)), this._prevFrame = t2;
             return;
           }
         }
         this.output.write(import_sisteransi.erase.down());
       }
-      this.output.write(t), this.state === "initial" && (this.state = "active"), this._prevFrame = t;
+      this.output.write(t2), this.state === "initial" && (this.state = "active"), this._prevFrame = t2;
     }
   }
 };
-var Z = class extends m {
+var r = class extends V {
   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", () => {
+  constructor(t2) {
+    super(t2, false), this.value = !!t2.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("confirm", (i2) => {
+      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = i2, this.state = "submit", this.close();
     }), this.on("cursor", () => {
       this.value = !this.value;
     });
   }
 };
-var ut = class extends m {
+var a$1 = class a extends V {
   options;
   cursor = 0;
   get _value() {
     return this.options[this.cursor].value;
   }
   get _enabledOptions() {
-    return this.options.filter((t) => t.disabled !== true);
+    return this.options.filter((e) => e.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);
+    const e = this._enabledOptions, i2 = this.value !== void 0 && this.value.length === e.length;
+    this.value = i2 ? [] : e.map((t2) => t2.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);
+    const e = this.value;
+    if (!e)
+      return;
+    const i2 = this._enabledOptions.filter((t2) => !e.includes(t2.value));
+    this.value = i2.map((t2) => t2.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) {
+    const e = this.value.includes(this._value);
+    this.value = e ? this.value.filter((i2) => i2 !== this._value) : [...this.value, this._value];
+  }
+  constructor(e) {
+    super(e, false), this.options = e.options, this.value = [...e.initialValues ?? []];
+    const i2 = Math.max(
+      this.options.findIndex(({ value: t2 }) => t2 === e.cursorAt),
+      0
+    );
+    this.cursor = this.options[i2].disabled ? findCursor(i2, 1, this.options) : i2, this.on("key", (t2, l2) => {
+      l2.name === "a" && this.toggleAll(), l2.name === "i" && this.toggleInvert();
+    }), this.on("cursor", (t2) => {
+      switch (t2) {
         case "left":
         case "up":
-          this.cursor = f(this.cursor, -1, this.options);
+          this.cursor = findCursor(this.cursor, -1, this.options);
           break;
         case "down":
         case "right":
-          this.cursor = f(this.cursor, 1, this.options);
+          this.cursor = findCursor(this.cursor, 1, this.options);
           break;
         case "space":
           this.toggleValue();
@@ -763,7 +873,7 @@ var ut = class extends m {
     });
   }
 };
-var ht = class extends m {
+var a2 = class extends V {
   options;
   cursor = 0;
   get _selectedValue() {
@@ -772,383 +882,568 @@ var ht = class extends m {
   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) {
+  constructor(t2) {
+    super(t2, false), this.options = t2.options;
+    const i2 = this.options.findIndex(({ value: s }) => s === t2.initialValue), e = i2 === -1 ? 0 : i2;
+    this.cursor = this.options[e].disabled ? findCursor(e, 1, this.options) : e, this.changeValue(), this.on("cursor", (s) => {
+      switch (s) {
         case "left":
         case "up":
-          this.cursor = f(this.cursor, -1, this.options);
+          this.cursor = findCursor(this.cursor, -1, this.options);
           break;
         case "down":
         case "right":
-          this.cursor = f(this.cursor, 1, this.options);
+          this.cursor = findCursor(this.cursor, 1, this.options);
           break;
       }
       this.changeValue();
     });
   }
 };
-var ct = class extends m {
+var n = class extends V {
   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("")}`;
+    if (this.state === "submit")
+      return this.userInput;
+    const t2 = this.userInput;
+    if (this.cursor >= t2.length)
+      return `${this.userInput}\u2588`;
+    const e = t2.slice(0, this.cursor), [s, ...r2] = t2.slice(this.cursor);
+    return `${e}${styleText("inverse", s)}${r2.join("")}`;
   }
   get cursor() {
     return this._cursor;
   }
-  constructor(t) {
-    super({ ...t, initialUserInput: t.initialUserInput ?? t.initialValue }), this.on("userInput", (s) => {
-      this._setValue(s);
+  constructor(t2) {
+    super({
+      ...t2,
+      initialUserInput: t2.initialUserInput ?? t2.initialValue
+    }), this.on("userInput", (e) => {
+      this._setValue(e);
     }), this.on("finalize", () => {
-      this.value || (this.value = t.defaultValue), this.value === void 0 && (this.value = "");
+      this.value || (this.value = t2.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";
+import { styleText as styleText2, stripVTControlCharacters } from "node:util";
+import process$1 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) {
+function isUnicodeSupported() {
+  if (process$1.platform !== "win32") {
+    return process$1.env.TERM !== "linux";
+  }
+  return Boolean(process$1.env.CI) || Boolean(process$1.env.WT_SESSION) || Boolean(process$1.env.TERMINUS_SUBLIME) || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var unicode = isUnicodeSupported();
+var isCI = () => process.env.CI === "true";
+var unicodeOr = (e, o2) => unicode ? e : o2;
+var S_STEP_ACTIVE = unicodeOr("\u25C6", "*");
+var S_STEP_CANCEL = unicodeOr("\u25A0", "x");
+var S_STEP_ERROR = unicodeOr("\u25B2", "x");
+var S_STEP_SUBMIT = unicodeOr("\u25C7", "o");
+var S_BAR_START = unicodeOr("\u250C", "T");
+var S_BAR = unicodeOr("\u2502", "|");
+var S_BAR_END = unicodeOr("\u2514", "\u2014");
+var S_BAR_START_RIGHT = unicodeOr("\u2510", "T");
+var S_BAR_END_RIGHT = unicodeOr("\u2518", "\u2014");
+var S_RADIO_ACTIVE = unicodeOr("\u25CF", ">");
+var S_RADIO_INACTIVE = unicodeOr("\u25CB", " ");
+var S_CHECKBOX_ACTIVE = unicodeOr("\u25FB", "[\u2022]");
+var S_CHECKBOX_SELECTED = unicodeOr("\u25FC", "[+]");
+var S_CHECKBOX_INACTIVE = unicodeOr("\u25FB", "[ ]");
+var S_PASSWORD_MASK = unicodeOr("\u25AA", "\u2022");
+var S_BAR_H = unicodeOr("\u2500", "-");
+var S_CORNER_TOP_RIGHT = unicodeOr("\u256E", "+");
+var S_CONNECT_LEFT = unicodeOr("\u251C", "+");
+var S_CORNER_BOTTOM_RIGHT = unicodeOr("\u256F", "+");
+var S_CORNER_BOTTOM_LEFT = unicodeOr("\u2570", "+");
+var S_CORNER_TOP_LEFT = unicodeOr("\u256D", "+");
+var S_INFO = unicodeOr("\u25CF", "\u2022");
+var S_SUCCESS = unicodeOr("\u25C6", "*");
+var S_WARN = unicodeOr("\u25B2", "!");
+var S_ERROR = unicodeOr("\u25A0", "x");
+var symbol = (e) => {
+  switch (e) {
     case "initial":
     case "active":
-      return e("cyan", _t);
+      return styleText2("cyan", S_STEP_ACTIVE);
     case "cancel":
-      return e("red", ut2);
+      return styleText2("red", S_STEP_CANCEL);
     case "error":
-      return e("yellow", lt2);
+      return styleText2("yellow", S_STEP_ERROR);
     case "submit":
-      return e("green", H);
+      return styleText2("green", S_STEP_SUBMIT);
   }
 };
-var ft = (t) => {
-  switch (t) {
+var symbolBar = (e) => {
+  switch (e) {
     case "initial":
     case "active":
-      return e("cyan", $);
+      return styleText2("cyan", S_BAR);
     case "cancel":
-      return e("red", $);
+      return styleText2("red", S_BAR);
     case "error":
-      return e("yellow", $);
+      return styleText2("yellow", S_BAR);
     case "submit":
-      return e("green", $);
+      return styleText2("green", S_BAR);
   }
 };
-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 E$1 = (l2, o2, g, c2, h2, O = false) => {
+  let r2 = o2, w = 0;
+  if (O)
+    for (let i2 = c2 - 1; i2 >= g && (r2 -= l2[i2].length, w++, !(r2 <= h2)); i2--)
+      ;
+  else
+    for (let i2 = g; i2 < c2 && (r2 -= l2[i2].length, w++, !(r2 <= h2)); i2++)
+      ;
+  return { lineCount: r2, removals: w };
 };
-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(`
+var limitOptions = ({
+  cursor: l2,
+  options: o2,
+  style: g,
+  output: c2 = process.stdout,
+  maxItems: h2 = Number.POSITIVE_INFINITY,
+  columnPadding: O = 0,
+  rowPadding: r2 = 4
+}) => {
+  const i2 = getColumns(c2) - O, I = getRows(c2), C2 = styleText2("dim", "..."), x = Math.max(I - r2, 0), m = Math.max(Math.min(h2, x), 5);
+  let p = 0;
+  l2 >= m - 3 && (p = Math.max(
+    Math.min(l2 - m + 3, o2.length - m),
+    0
+  ));
+  let f = m < o2.length && p > 0, u3 = m < o2.length && p + m < o2.length;
+  const W2 = Math.min(
+    p + m,
+    o2.length
+  ), e = [];
+  let d2 = 0;
+  f && d2++, u3 && d2++;
+  const v = p + (f ? 1 : 0), P = W2 - (u3 ? 1 : 0);
+  for (let t2 = v; t2 < P; t2++) {
+    const n2 = wrapAnsi(g(o2[t2], t2 === l2), i2, {
+      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;
+    e.push(n2), d2 += n2.length;
+  }
+  if (d2 > x) {
+    let t2 = 0, n2 = 0, s = d2;
+    const M = l2 - v;
+    let a3 = x;
+    const T = () => E$1(e, s, 0, M, a3), L = () => E$1(
+      e,
+      s,
+      M + 1,
+      e.length,
+      a3,
+      true
+    );
+    f ? ({ lineCount: s, removals: t2 } = T(), s > a3 && (u3 || (a3 -= 1), { lineCount: s, removals: n2 } = L())) : (u3 || (a3 -= 1), { lineCount: s, removals: n2 } = L(), s > a3 && (a3 -= 1, { lineCount: s, removals: t2 } = T())), t2 > 0 && (f = true, e.splice(0, t2)), n2 > 0 && (u3 = true, e.splice(e.length - n2, n2));
+  }
+  const b = [];
+  f && b.push(C2);
+  for (const t2 of e)
+    for (const n2 of t2)
+      b.push(n2);
+  return u3 && b.push(C2), b;
 };
-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}
+var confirm = (i2) => {
+  const a3 = i2.active ?? "Yes", s = i2.inactive ?? "No";
+  return new r({
+    active: a3,
+    inactive: s,
+    signal: i2.signal,
+    input: i2.input,
+    output: i2.output,
+    initialValue: i2.initialValue ?? true,
+    render() {
+      const e = i2.withGuide ?? settings.withGuide, u3 = `${symbol(this.state)}  `, l2 = e ? `${styleText2("gray", S_BAR)}  ` : "", f = wrapTextWithPrefix(
+        i2.output,
+        i2.message,
+        l2,
+        u3
+      ), o2 = `${e ? `${styleText2("gray", S_BAR)}
+` : ""}${f}
+`, c2 = this.value ? a3 : s;
+      switch (this.state) {
+        case "submit": {
+          const r2 = e ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${o2}${r2}${styleText2("dim", c2)}`;
+        }
+        case "cancel": {
+          const r2 = e ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${o2}${r2}${styleText2(["strikethrough", "dim"], c2)}${e ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r2 = e ? `${styleText2("cyan", S_BAR)}  ` : "", g = e ? styleText2("cyan", S_BAR_END) : "";
+          return `${o2}${r2}${this.value ? `${styleText2("green", S_RADIO_ACTIVE)} ${a3}` : `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", a3)}`}${i2.vertical ? e ? `
+${styleText2("cyan", S_BAR)}  ` : `
+` : ` ${styleText2("dim", "/")} `}${this.value ? `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", s)}` : `${styleText2("green", S_RADIO_ACTIVE)} ${s}`}
+${g}
 `;
+        }
       }
     }
-  } }).prompt();
+  }).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 cancel = (o2 = "", t2) => {
+  const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_END)}  ` : "";
+  i2.write(`${e}${styleText2("red", o2)}
 
 `);
 };
-var ye = (t = "", i) => {
-  const s = i?.output ?? process.stdout, r = i?.withGuide ?? h.withGuide ? `${e("gray", ct2)}  ` : "";
-  s.write(`${r}${t}
+var intro = (o2 = "", t2) => {
+  const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_START)}  ` : "";
+  i2.write(`${e}${o2}
 `);
 };
-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 outro = (o2 = "", t2) => {
+  const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR)}
+${styleText2("gray", S_BAR_END)}  ` : "";
+  i2.write(`${e}${o2}
 
 `);
 };
-var Q = (t, i) => t.split(`
-`).map((s) => i(s)).join(`
+var d = (n2, a3) => n2.split(`
+`).map((m) => a3(m)).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(`
+var multiselect = (n2) => {
+  const a3 = (t2, o2) => {
+    const r2 = t2.label ?? String(t2.value);
+    return o2 === "disabled" ? `${styleText2("gray", S_CHECKBOX_INACTIVE)} ${d(r2, (l2) => styleText2(["strikethrough", "gray"], l2))}${t2.hint ? ` ${styleText2("dim", `(${t2.hint ?? "disabled"})`)}` : ""}` : o2 === "active" ? `${styleText2("cyan", S_CHECKBOX_ACTIVE)} ${r2}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : o2 === "selected" ? `${styleText2("green", S_CHECKBOX_SELECTED)} ${d(r2, (l2) => styleText2("dim", l2))}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : o2 === "cancelled" ? `${d(r2, (l2) => styleText2(["strikethrough", "dim"], l2))}` : o2 === "active-selected" ? `${styleText2("green", S_CHECKBOX_SELECTED)} ${r2}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : o2 === "submitted" ? `${d(r2, (l2) => styleText2("dim", l2))}` : `${styleText2("dim", S_CHECKBOX_INACTIVE)} ${d(r2, (l2) => styleText2("dim", l2))}`;
+  }, m = n2.required ?? true;
+  return new a$1({
+    options: n2.options,
+    signal: n2.signal,
+    input: n2.input,
+    output: n2.output,
+    initialValues: n2.initialValues,
+    required: m,
+    cursorAt: n2.cursorAt,
+    validate(t2) {
+      if (m && (t2 === void 0 || t2.length === 0))
+        return `Please select at least one option.
+${styleText2(
+          "reset",
+          styleText2(
+            "dim",
+            `Press ${styleText2(["gray", "bgWhite", "inverse"], " space ")} to select, ${styleText2(
+              "gray",
+              styleText2("bgWhite", styleText2("inverse", " enter "))
+            )} to submit`
+          )
+        )}`;
+    },
+    render() {
+      const t2 = n2.withGuide ?? settings.withGuide, o2 = wrapTextWithPrefix(
+        n2.output,
+        n2.message,
+        t2 ? `${symbolBar(this.state)}  ` : "",
+        `${symbol(this.state)}  `
+      ), r2 = `${t2 ? `${styleText2("gray", S_BAR)}
+` : ""}${o2}
+`, l2 = this.value ?? [], g = (i2, u3) => {
+        if (i2.disabled)
+          return a3(i2, "disabled");
+        const s = l2.includes(i2.value);
+        return u3 && s ? a3(i2, "active-selected") : s ? a3(i2, "selected") : a3(i2, u3 ? "active" : "inactive");
+      };
+      switch (this.state) {
+        case "submit": {
+          const i2 = this.options.filter(({ value: s }) => l2.includes(s)).map((s) => a3(s, "submitted")).join(styleText2("dim", ", ")) || styleText2("dim", "none"), u3 = wrapTextWithPrefix(
+            n2.output,
+            i2,
+            t2 ? `${styleText2("gray", S_BAR)}  ` : ""
+          );
+          return `${r2}${u3}`;
+        }
+        case "cancel": {
+          const i2 = this.options.filter(({ value: s }) => l2.includes(s)).map((s) => a3(s, "cancelled")).join(styleText2("dim", ", "));
+          if (i2.trim() === "")
+            return `${r2}${styleText2("gray", S_BAR)}`;
+          const u3 = wrapTextWithPrefix(
+            n2.output,
+            i2,
+            t2 ? `${styleText2("gray", S_BAR)}  ` : ""
+          );
+          return `${r2}${u3}${t2 ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        case "error": {
+          const i2 = t2 ? `${styleText2("yellow", S_BAR)}  ` : "", u3 = this.error.split(`
+`).map(
+            (h2, x) => x === 0 ? `${t2 ? `${styleText2("yellow", S_BAR_END)}  ` : ""}${styleText2("yellow", h2)}` : `   ${h2}`
+          ).join(`
+`), s = r2.split(`
+`).length, v = u3.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}
+          return `${r2}${i2}${limitOptions({
+            output: n2.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: n2.maxItems,
+            columnPadding: i2.length,
+            rowPadding: s + v,
+            style: g
+          }).join(`
+${i2}`)}
+${u3}
 `;
-      }
-      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) : ""}
+        }
+        default: {
+          const i2 = t2 ? `${styleText2("cyan", S_BAR)}  ` : "", u3 = r2.split(`
+`).length, s = t2 ? 2 : 1;
+          return `${r2}${i2}${limitOptions({
+            output: n2.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: n2.maxItems,
+            columnPadding: i2.length,
+            rowPadding: u3 + s,
+            style: g
+          }).join(`
+${i2}`)}
+${t2 ? styleText2("cyan", S_BAR_END) : ""}
 `;
+        }
       }
     }
-  } }).prompt();
+  }).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 W$1 = (o2) => styleText2("dim", o2);
+var C = (o2, e, s) => {
+  const a3 = {
+    hard: true,
+    trim: false
+  }, i2 = wrapAnsi(o2, e, a3).split(`
+`), c2 = i2.reduce((n2, r2) => Math.max(dist_default2(r2), n2), 0), u3 = i2.map(s).reduce((n2, r2) => Math.max(dist_default2(r2), n2), 0), g = e - (u3 - c2);
+  return wrapAnsi(o2, g, a3);
 };
-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 note = (o2 = "", e = "", s) => {
+  const a3 = s?.output ?? process$1.stdout, i2 = s?.withGuide ?? settings.withGuide, c2 = s?.format ?? W$1, g = ["", ...C(o2, getColumns(a3) - 6, c2).split(`
+`).map(c2), ""], n2 = dist_default2(e), r2 = Math.max(
+    g.reduce((m, F) => {
+      const O = dist_default2(F);
+      return O > m ? O : m;
+    }, 0),
+    n2
+  ) + 2, h2 = g.map(
+    (m) => `${styleText2("gray", S_BAR)}  ${m}${" ".repeat(r2 - dist_default2(m))}${styleText2("gray", S_BAR)}`
+  ).join(`
+`), T = i2 ? `${styleText2("gray", S_BAR)}
+` : "", l$1 = i2 ? S_CONNECT_LEFT : S_CORNER_BOTTOM_LEFT;
+  a3.write(
+    `${T}${styleText2("green", S_STEP_SUBMIT)}  ${styleText2("reset", e)} ${styleText2(
+      "gray",
+      S_BAR_H.repeat(Math.max(r2 - n2 - 1, 1)) + S_CORNER_TOP_RIGHT
+    )}
+${h2}
+${styleText2("gray", l$1 + S_BAR_H.repeat(r2 + 2) + S_CORNER_BOTTOM_RIGHT)}
+`
+  );
 };
-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(`
+var W = (l2) => styleText2("magenta", l2);
+var spinner = ({
+  indicator: l2 = "dots",
+  onCancel: h2,
+  output: n2 = process.stdout,
+  cancelMessage: G,
+  errorMessage: O,
+  frames: E = unicode ? ["\u25D2", "\u25D0", "\u25D3", "\u25D1"] : ["\u2022", "o", "O", "0"],
+  delay: F = unicode ? 80 : 120,
+  signal: m,
+  ...I
+} = {}) => {
+  const u3 = isCI();
+  let M, T, d2 = false, S = false, s = "", p, w = performance.now();
+  const x = getColumns(n2), k = I?.styleFrame ?? W, g = (e) => {
+    const r2 = e > 1 ? O ?? settings.messages.error : G ?? settings.messages.cancel;
+    S = e === 1, d2 && (a3(r2, e), S && typeof h2 == "function" && h2());
+  }, f = () => g(2), i2 = () => g(1), A = () => {
+    process.on("uncaughtExceptionMonitor", f), process.on("unhandledRejection", f), process.on("SIGINT", i2), process.on("SIGTERM", i2), process.on("exit", g), m && m.addEventListener("abort", i2);
+  }, H = () => {
+    process.removeListener("uncaughtExceptionMonitor", f), process.removeListener("unhandledRejection", f), process.removeListener("SIGINT", i2), process.removeListener("SIGTERM", i2), process.removeListener("exit", g), m && m.removeEventListener("abort", i2);
+  }, y = () => {
+    if (p === void 0) return;
+    u3 && n2.write(`
 `);
-    const _ = wrapAnsi(I, y, { hard: true, trim: false }).split(`
+    const r2 = wrapAnsi(p, x, {
+      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", $)}
+    r2.length > 1 && n2.write(import_sisteransi2.cursor.up(r2.length - 1)), n2.write(import_sisteransi2.cursor.to(0)), n2.write(import_sisteransi2.erase.down());
+  }, C2 = (e) => e.replace(/\.+$/, ""), _ = (e) => {
+    const r2 = (performance.now() - e) / 1e3, t2 = Math.floor(r2 / 60), o2 = Math.floor(r2 % 60);
+    return t2 > 0 ? `[${t2}m ${o2}s]` : `[${o2}s]`;
+  }, N = I.withGuide ?? settings.withGuide, P = (e = "") => {
+    d2 = true, M = block({ output: n2 }), s = C2(e), w = performance.now(), N && n2.write(`${styleText2("gray", S_BAR)}
 `);
-    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)}`;
+    let r2 = 0, t2 = 0;
+    A(), T = setInterval(() => {
+      if (u3 && s === p)
+        return;
+      y(), p = s;
+      const o2 = k(E[r2]);
+      let v;
+      if (u3)
+        v = `${o2}  ${s}...`;
+      else if (l2 === "timer")
+        v = `${o2}  ${s} ${_(w)}`;
       else {
-        const Lt = ".".repeat(Math.floor(L2)).slice(0, 3);
-        Z2 = `${D2}  ${h2}${Lt}`;
+        const B = ".".repeat(Math.floor(t2)).slice(0, 3);
+        v = `${o2}  ${s}${B}`;
       }
-      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();
+      const j = wrapAnsi(v, x, {
+        hard: true,
+        trim: false
+      });
+      n2.write(j), r2 = r2 + 1 < E.length ? r2 + 1 : 0, t2 = t2 < 4 ? t2 + 0.125 : 0;
+    }, F);
+  }, a3 = (e = "", r2 = 0, t2 = false) => {
+    if (!d2) return;
+    d2 = false, clearInterval(T), y();
+    const o2 = r2 === 0 ? styleText2("green", S_STEP_SUBMIT) : r2 === 1 ? styleText2("red", S_STEP_CANCEL) : styleText2("red", S_STEP_ERROR);
+    s = e ?? s, t2 || (l2 === "timer" ? n2.write(`${o2}  ${s} ${_(w)}
+`) : n2.write(`${o2}  ${s}
+`)), H(), M();
+  };
+  return {
+    start: P,
+    stop: (e = "") => a3(e, 0),
+    message: (e = "") => {
+      s = C2(e ?? s);
+    },
+    cancel: (e = "") => a3(e, 1),
+    error: (e = "") => a3(e, 2),
+    clear: () => a3("", 0, true),
+    get isCancelled() {
+      return S;
+    }
   };
-  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) {
+var u2 = {
+  light: unicodeOr("\u2500", "-"),
+  heavy: unicodeOr("\u2501", "="),
+  block: unicodeOr("\u2588", "#")
+};
+var c = (e, a3) => e.includes(`
+`) ? e.split(`
+`).map((t2) => a3(t2)).join(`
+`) : a3(e);
+var select = (e) => {
+  const a3 = (t2, d2) => {
+    const s = t2.label ?? String(t2.value);
+    switch (d2) {
       case "disabled":
-        return `${e("gray", U)} ${it2(u, (n) => e("gray", n))}${s.hint ? ` ${e("dim", `(${s.hint ?? "disabled"})`)}` : ""}`;
+        return `${styleText2("gray", S_RADIO_INACTIVE)} ${c(s, (n2) => styleText2("gray", n2))}${t2.hint ? ` ${styleText2("dim", `(${t2.hint ?? "disabled"})`)}` : ""}`;
       case "selected":
-        return `${it2(u, (n) => e("dim", n))}`;
+        return `${c(s, (n2) => styleText2("dim", n2))}`;
       case "active":
-        return `${e("green", z2)} ${u}${s.hint ? ` ${e("dim", `(${s.hint})`)}` : ""}`;
+        return `${styleText2("green", S_RADIO_ACTIVE)} ${s}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}`;
       case "cancelled":
-        return `${it2(u, (n) => e(["strikethrough", "dim"], n))}`;
+        return `${c(s, (n2) => styleText2(["strikethrough", "dim"], n2))}`;
       default:
-        return `${e("dim", U)} ${it2(u, (n) => e("dim", n))}`;
+        return `${styleText2("dim", S_RADIO_INACTIVE)} ${c(s, (n2) => styleText2("dim", n2))}`;
     }
   };
-  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}
+  return new a2({
+    options: e.options,
+    signal: e.signal,
+    input: e.input,
+    output: e.output,
+    initialValue: e.initialValue,
+    render() {
+      const t2 = e.withGuide ?? settings.withGuide, d2 = `${symbol(this.state)}  `, s = `${symbolBar(this.state)}  `, n2 = wrapTextWithPrefix(
+        e.output,
+        e.message,
+        s,
+        d2
+      ), u3 = `${t2 ? `${styleText2("gray", S_BAR)}
+` : ""}${n2}
+`;
+      switch (this.state) {
+        case "submit": {
+          const r2 = t2 ? `${styleText2("gray", S_BAR)}  ` : "", l2 = wrapTextWithPrefix(
+            e.output,
+            a3(this.options[this.cursor], "selected"),
+            r2
+          );
+          return `${u3}${l2}`;
+        }
+        case "cancel": {
+          const r2 = t2 ? `${styleText2("gray", S_BAR)}  ` : "", l2 = wrapTextWithPrefix(
+            e.output,
+            a3(this.options[this.cursor], "cancelled"),
+            r2
+          );
+          return `${u3}${l2}${t2 ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r2 = t2 ? `${styleText2("cyan", S_BAR)}  ` : "", l2 = t2 ? styleText2("cyan", S_BAR_END) : "", g = u3.split(`
+`).length, h2 = t2 ? 2 : 1;
+          return `${u3}${r2}${limitOptions({
+            output: e.output,
+            cursor: this.cursor,
+            options: this.options,
+            maxItems: e.maxItems,
+            columnPadding: r2.length,
+            rowPadding: g + h2,
+            style: (p, b) => a3(p, p.disabled ? "disabled" : b ? "active" : "inactive")
+          }).join(`
+${r2}`)}
+${l2}
 `;
+        }
+      }
+    }
+  }).prompt();
+};
+var i = `${styleText2("gray", S_BAR)}  `;
+var text = (t2) => new n({
+  validate: t2.validate,
+  placeholder: t2.placeholder,
+  defaultValue: t2.defaultValue,
+  initialValue: t2.initialValue,
+  output: t2.output,
+  signal: t2.signal,
+  input: t2.input,
+  render() {
+    const i2 = t2?.withGuide ?? settings.withGuide, s = `${`${i2 ? `${styleText2("gray", S_BAR)}
+` : ""}${symbol(this.state)}  `}${t2.message}
+`, c2 = t2.placeholder ? styleText2("inverse", t2.placeholder[0]) + styleText2("dim", t2.placeholder.slice(1)) : styleText2(["inverse", "hidden"], "_"), o2 = this.userInput ? this.userInputWithCursor : c2, a3 = this.value ?? "";
     switch (this.state) {
+      case "error": {
+        const n2 = this.error ? `  ${styleText2("yellow", this.error)}` : "", r2 = i2 ? `${styleText2("yellow", S_BAR)}  ` : "", d2 = i2 ? styleText2("yellow", S_BAR_END) : "";
+        return `${s.trim()}
+${r2}${o2}
+${d2}${n2}
+`;
+      }
       case "submit": {
-        const c = s ? `${e("gray", $)}  ` : "", o = B(t.output, i(this.options[this.cursor], "selected"), c);
-        return `${a}${o}`;
+        const n2 = a3 ? `  ${styleText2("dim", a3)}` : "", r2 = i2 ? styleText2("gray", S_BAR) : "";
+        return `${s}${r2}${n2}`;
       }
       case "cancel": {
-        const c = s ? `${e("gray", $)}  ` : "", o = B(t.output, i(this.options[this.cursor], "cancelled"), c);
-        return `${a}${o}${s ? `
-${e("gray", $)}` : ""}`;
+        const n2 = a3 ? `  ${styleText2(["strikethrough", "dim"], a3)}` : "", r2 = i2 ? styleText2("gray", S_BAR) : "";
+        return `${s}${r2}${n2}${a3.trim() ? `
+${r2}` : ""}`;
       }
       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}
+        const n2 = i2 ? `${styleText2("cyan", S_BAR)}  ` : "", r2 = i2 ? styleText2("cyan", S_BAR_END) : "";
+        return `${s}${n2}${o2}
+${r2}
 `;
       }
     }
-  } }).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();
+}).prompt();
 
 // src/cli/configure.ts
 var import_picocolors2 = __toESM(require_picocolors(), 1);
@@ -1179,55 +1474,55 @@ var PKG_VERSION = {
 var TAILWIND_ENTRY = "styles/tailwind.css";
 var TAILWIND_CSS = `@import 'tailwindcss';
 `;
-function styleEntry(p2) {
-  return `styles/main.${STYLE_EXT[p2]}`;
+function styleEntry(p) {
+  return `styles/main.${STYLE_EXT[p]}`;
 }
 function preprocessorForExt(ext) {
-  const e2 = ext.replace(/^\./, "");
-  if (e2 === "sass") return "sass";
-  return PREPROCESSORS.find((p2) => STYLE_EXT[p2] === e2) ?? null;
+  const e = ext.replace(/^\./, "");
+  if (e === "sass") return "sass";
+  return PREPROCESSORS.find((p) => STYLE_EXT[p] === e) ?? null;
 }
-function requiredPackages(f2) {
+function requiredPackages(f) {
   const pkgs = [];
-  const pp = PREPROCESSOR_PKG[f2.preprocessor];
+  const pp = PREPROCESSOR_PKG[f.preprocessor];
   if (pp) pkgs.push(pp);
-  if (f2.tailwind) pkgs.push(...TAILWIND_PKGS);
+  if (f.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))
+    add: [...want].filter((p) => !had.has(p)),
+    remove: [...had].filter((p) => !want.has(p))
   };
 }
-function styleImportLines(f2) {
+function styleImportLines(f) {
   const lines = [];
-  if (f2.tailwind) lines.push(`import './${TAILWIND_ENTRY}';`);
-  lines.push(`import './${styleEntry(f2.preprocessor)}';`);
+  if (f.tailwind) lines.push(`import './${TAILWIND_ENTRY}';`);
+  lines.push(`import './${styleEntry(f.preprocessor)}';`);
   return lines;
 }
-function setStyleImports(source, f2) {
+function setStyleImports(source, f) {
   const stripped = source.replace(
     /^[ \t]*import\s+['"]\.\/styles\/[^'"]+['"];?[ \t]*\r?\n/gm,
     ""
   );
-  const block = styleImportLines(f2).join("\n") + "\n";
+  const block2 = styleImportLines(f).join("\n") + "\n";
   const lines = stripped.split("\n");
-  const routesIdx = lines.findIndex((l) => /from\s+['"]toiljs\/routes['"]/.test(l));
+  const routesIdx = lines.findIndex((l2) => /from\s+['"]toiljs\/routes['"]/.test(l2));
   let insertAt;
   if (routesIdx !== -1) {
     insertAt = routesIdx + 1;
   } else {
-    const lastImport = lines.reduce((acc, l, i) => /^\s*import\s/.test(l) ? i : acc, -1);
+    const lastImport = lines.reduce((acc, l2, i2) => /^\s*import\s/.test(l2) ? i2 : acc, -1);
     insertAt = lastImport + 1;
   }
   const head = lines.slice(0, insertAt).join("\n");
   const tail = lines.slice(insertAt).join("\n");
   return `${head}
 
-${block}
+${block2}
 ${tail}`.replace(/\n{3,}/g, "\n\n");
 }
 function defaultConfigSource(images) {
@@ -1286,17 +1581,17 @@ 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 stdout2 = "";
     let stderr = "";
-    child.stdout?.on("data", (d) => {
-      stdout += d.toString();
+    child.stdout?.on("data", (d2) => {
+      stdout2 += d2.toString();
     });
-    child.stderr?.on("data", (d) => {
-      stderr += d.toString();
+    child.stderr?.on("data", (d2) => {
+      stderr += d2.toString();
     });
     child.on("error", reject);
     child.on("close", (code) => {
-      resolve({ stdout, stderr, code: code ?? 1 });
+      resolve({ stdout: stdout2, stderr, code: code ?? 1 });
     });
   });
 }
@@ -1337,24 +1632,24 @@ function success(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 lerp(a3, b, t2) {
+  return Math.round(a3 + (b - a3) * t2);
 }
-function gradientAt(t) {
+function gradientAt(t2) {
   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)];
+  const scaled = t2 * segments;
+  const i2 = Math.min(Math.floor(scaled), segments - 1);
+  const a3 = GRADIENT[i2];
+  const b = GRADIENT[i2 + 1];
+  const localT = scaled - i2;
+  return [lerp(a3[0], b[0], localT), lerp(a3[1], b[1], localT), lerp(a3[2], b[2], localT)];
 }
 function gradientLine(line) {
-  const n = line.length;
+  const n2 = 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]}`;
+  for (let i2 = 0; i2 < n2; i2++) {
+    const [r2, g, b] = gradientAt(n2 > 1 ? i2 / (n2 - 1) : 0);
+    out += `\x1B[38;2;${r2};${g};${b}m${line[i2]}`;
   }
   return out + "\x1B[39m";
 }
@@ -1393,9 +1688,9 @@ var CONFIG_FILES = [
 ];
 async function readConfigFile(root) {
   for (const name of CONFIG_FILES) {
-    const p2 = path2.join(root, name);
+    const p = path2.join(root, name);
     try {
-      return { path: p2, source: await fs2.readFile(p2, "utf8") };
+      return { path: p, source: await fs2.readFile(p, "utf8") };
     } catch {
     }
   }
@@ -1434,16 +1729,16 @@ var PREPROCESSOR_LABEL = {
   stylus: "Stylus"
 };
 function bail(value) {
-  if (R(value)) {
-    ge("Configuration cancelled.");
+  if (isCancel(value)) {
+    cancel("Configuration cancelled.");
     process.exit(0);
   }
 }
 async function detectStylesheet(clientDir) {
-  for (const p2 of PREPROCESSORS) {
+  for (const p of PREPROCESSORS) {
     try {
-      await fs2.access(path2.join(clientDir, styleEntry(p2)));
-      return p2;
+      await fs2.access(path2.join(clientDir, styleEntry(p)));
+      return p;
     } catch {
     }
   }
@@ -1456,10 +1751,10 @@ async function detectStylesheet(clientDir) {
 }
 async function findMainStylesheet(clientDir) {
   for (const ext of ["css", "scss", "sass", "less", "styl"]) {
-    const p2 = path2.join(clientDir, "styles", `main.${ext}`);
+    const p = path2.join(clientDir, "styles", `main.${ext}`);
     try {
-      await fs2.access(p2);
-      return p2;
+      await fs2.access(p);
+      return p;
     } catch {
     }
   }
@@ -1522,7 +1817,7 @@ async function applyPackages(pkgPath, pkg, from, to) {
     delete deps[name];
   }
   const sortedDev = Object.fromEntries(
-    Object.entries(dev2).sort(([a], [b2]) => a.localeCompare(b2))
+    Object.entries(dev2).sort(([a3], [b]) => a3.localeCompare(b))
   );
   const next = { ...pkg, devDependencies: sortedDev };
   if (Object.keys(deps).length) next.dependencies = deps;
@@ -1542,17 +1837,17 @@ function describe(from, to) {
   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");
+  return lines.map((l2) => dim("  ") + l2).join("\n");
 }
 async function runConfigure(opts) {
-  ye(accent(" toiljs configure "));
+  intro(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.`);
+    cancel(`No package.json in ${import_picocolors2.default.cyan(root)}, run this inside a toiljs project.`);
     process.exit(1);
   }
   const clientAbsDir = await resolveClientDir(root);
@@ -1572,18 +1867,18 @@ async function runConfigure(opts) {
     };
     targetImages = opts.images ?? currentImages;
   } else {
-    const ppChoice = await Ee({
+    const ppChoice = await select({
       message: "CSS preprocessor",
       options: PREPROCESSORS.map((value) => ({ value, label: PREPROCESSOR_LABEL[value] })),
       initialValue: current.preprocessor
     });
     bail(ppChoice);
-    const twChoice = await le({
+    const twChoice = await confirm({
       message: "Use Tailwind CSS?",
       initialValue: current.tailwind
     });
     bail(twChoice);
-    const imChoice = await le({
+    const imChoice = await confirm({
       message: "Optimize images at build time?",
       initialValue: currentImages
     });
@@ -1594,10 +1889,10 @@ async function runConfigure(opts) {
   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.");
+    outro("No changes, your setup is already up to date.");
     return;
   }
-  const s = vt();
+  const s = spinner();
   s.start("Updating project files");
   if (styleChanged) await applyConfigure(clientAbsDir, pkgPath, pkg, current, target);
   let imagesWarning = "";
@@ -1610,15 +1905,15 @@ async function runConfigure(opts) {
   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");
+      note(`${import_picocolors2.default.cyan(`${pm} install`)} to sync the dependency changes.`, "Next step");
     } else {
-      const i = vt();
-      i.start(`Syncing dependencies with ${pm}`);
+      const i2 = spinner();
+      i2.start(`Syncing dependencies with ${pm}`);
       try {
         await run(pm, ["install"], root);
-        i.stop("Dependencies synced");
+        i2.stop("Dependencies synced");
       } catch {
-        i.stop(import_picocolors2.default.yellow(`Could not run \`${pm} install\`, run it yourself to finish`));
+        i2.stop(import_picocolors2.default.yellow(`Could not run \`${pm} install\`, run it yourself to finish`));
       }
     }
   }
@@ -1627,8 +1922,8 @@ async function runConfigure(opts) {
     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.`);
+  note(summary, "Updated");
+  outro(`Reconfigured, restart \`${accent("toiljs dev")}\` to pick up the changes.`);
 }
 
 // src/cli/create.ts
@@ -1665,8 +1960,8 @@ var PREPROCESSOR_LABEL2 = {
 };
 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.");
+  if (isCancel(value)) {
+    cancel("Scaffolding cancelled.");
     process.exit(0);
   }
 }
@@ -1685,7 +1980,7 @@ function scaffold(name, template, features, aiTools, images) {
     "@types/react-dom": "^19.2.3",
     eslint: "^10.2.0",
     prettier: "^3.8.1",
-    toilscript: "^0.1.2",
+    toilscript: "^0.1.11",
     typescript: "^6.0.3"
   };
   for (const dep of requiredPackages(features).sort()) {
@@ -1697,9 +1992,9 @@ function scaffold(name, template, features, aiTools, images) {
     type: "module",
     scripts: {
       dev: "toiljs dev",
-      build: "toiljs build && toilscript --target release",
+      build: "toilscript --target release --rpcModule shared/server.ts && toiljs build",
       "build:client": "toiljs build",
-      "build:server": "toilscript --target release",
+      "build:server": "toilscript --target release --rpcModule shared/server.ts",
       lint: "eslint client",
       typecheck: "tsc --noEmit",
       format: 'prettier --write "client/**/*.{ts,tsx,css,scss,less}" "client/public/**/*.html"'
@@ -1722,10 +2017,13 @@ export default defineConfig({
     },
 });
 `,
-    "tsconfig.json": '{\n    "extends": "toiljs/tsconfig",\n    "include": ["client", "toil-env.d.ts", "toil-routes.d.ts"]\n}\n',
+    "tsconfig.json": '{\n    "extends": "toiljs/tsconfig",\n    "compilerOptions": {\n        "paths": { "shared/*": ["./shared/*"] }\n    },\n    "include": ["client", "shared", "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",
+    // Generated files don't need formatting. (toilscript server decorators like @main /
+    // @remote-on-functions are handled by the toiljs/prettier-plugin, so server/ is not ignored.)
+    ".prettierignore": "node_modules\nbuild\n.toil\nshared/server.ts\ntoil-env.d.ts\ntoil-routes.d.ts\n",
+    ".gitignore": "node_modules\nbuild\n.toil\nshared/server.ts\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,
@@ -1898,18 +2196,18 @@ async function writeFiles(dir, files) {
   }
 }
 async function runCreate(opts) {
-  ye(accent(" toiljs create "));
+  intro(accent(" toiljs create "));
   let name = opts.name;
   if (!name) {
     if (opts.yes) {
       name = "my-toil-app";
     } else {
-      const answer = await Re({
+      const answer = await text({
         message: "Project name",
         placeholder: "my-toil-app",
         defaultValue: "my-toil-app",
-        validate: (v2) => {
-          const result = isValidName(v2 || "my-toil-app");
+        validate: (v) => {
+          const result = isValidName(v || "my-toil-app");
           return result === true ? void 0 : result;
         }
       });
@@ -1919,27 +2217,27 @@ async function runCreate(opts) {
   }
   const valid = isValidName(name);
   if (valid !== true) {
-    ge(valid);
+    cancel(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).');
+    cancel('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.`);
+      cancel(`Directory ${import_picocolors3.default.cyan(rel)} is not empty.`);
       process.exit(1);
     }
-    const proceed = await le({
+    const proceed = await confirm({
       message: `Directory ${import_picocolors3.default.cyan(rel)} is not empty. Scaffold into it anyway?`,
       initialValue: false
     });
     bail2(proceed);
     if (!proceed) {
-      ge("Scaffolding cancelled.");
+      cancel("Scaffolding cancelled.");
       process.exit(0);
     }
   }
@@ -1953,7 +2251,7 @@ async function runCreate(opts) {
       },
       { value: "minimal", label: "Minimal", hint: "just a layout and a home route" }
     ];
-    const choice = await Ee({
+    const choice = await select({
       message: "Which template?",
       options: templateOptions,
       initialValue: "app"
@@ -1965,7 +2263,7 @@ async function runCreate(opts) {
   let tailwind = opts.tailwind ?? false;
   if (!opts.yes) {
     if (opts.preprocessor === void 0) {
-      const choice = await Ee({
+      const choice = await select({
         message: "Styling",
         options: PREPROCESSORS.map((value) => ({
           value,
@@ -1977,7 +2275,7 @@ async function runCreate(opts) {
       preprocessor = choice;
     }
     if (opts.tailwind === void 0) {
-      const tw = await le({ message: "Add Tailwind CSS?", initialValue: false });
+      const tw = await confirm({ message: "Add Tailwind CSS?", initialValue: false });
       bail2(tw);
       tailwind = tw;
     }
@@ -1985,7 +2283,7 @@ async function runCreate(opts) {
   const features = { preprocessor, tailwind };
   let aiTools = opts.ai === false ? [] : [...AI_HELPER_IDS];
   if (opts.ai === void 0 && !opts.yes) {
-    const picked = await we({
+    const picked = await multiselect({
       message: "AI assistant files (read by Claude, Cursor, Codex, Copilot)",
       options: [
         ...AI_HELPERS.map((h2) => ({ value: h2.id, label: h2.label })),
@@ -1999,7 +2297,7 @@ async function runCreate(opts) {
   }
   let images = opts.images ?? true;
   if (opts.images === void 0 && !opts.yes) {
-    const im = await le({ message: "Optimize images at build time?", initialValue: true });
+    const im = await confirm({ message: "Optimize images at build time?", initialValue: true });
     bail2(im);
     images = im;
   }
@@ -2007,12 +2305,12 @@ async function runCreate(opts) {
   let install = opts.install ?? false;
   const pm = opts.pm ?? "npm";
   if (!isPackageManager(pm)) {
-    ge(`Unsupported package manager: ${pm} (use npm, pnpm, yarn, or bun).`);
+    cancel(`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({
+      const g = await confirm({
         message: "Initialize a git repository?",
         initialValue: true
       });
@@ -2020,12 +2318,12 @@ async function runCreate(opts) {
       initGit = g;
     }
     if (opts.install === void 0) {
-      const i = await le({ message: "Install dependencies now?", initialValue: false });
-      bail2(i);
-      install = i;
+      const i2 = await confirm({ message: "Install dependencies now?", initialValue: false });
+      bail2(i2);
+      install = i2;
     }
   }
-  const s = vt();
+  const s = spinner();
   s.start("Scaffolding project");
   await writeFiles(targetDir, scaffold(name, template, features, aiTools, images));
   if (template === "app") {
@@ -2040,7 +2338,7 @@ async function runCreate(opts) {
   }
   s.stop(`Scaffolded ${import_picocolors3.default.cyan(rel)}`);
   if (initGit) {
-    const g = vt();
+    const g = spinner();
     g.start("Initializing git repository");
     try {
       await run("git", ["init", "-q"], targetDir);
@@ -2051,13 +2349,13 @@ async function runCreate(opts) {
     }
   }
   if (install) {
-    const i = vt();
-    i.start(`Installing dependencies with ${pm}`);
+    const i2 = spinner();
+    i2.start(`Installing dependencies with ${pm}`);
     try {
       await run(pm, ["install"], targetDir);
-      i.stop("Installed dependencies");
+      i2.stop("Installed dependencies");
     } catch {
-      i.stop(import_picocolors3.default.yellow(`Could not install with ${pm}, run it yourself later`));
+      i2.stop(import_picocolors3.default.yellow(`Could not install with ${pm}, run it yourself later`));
       install = false;
     }
   }
@@ -2066,8 +2364,8 @@ async function runCreate(opts) {
   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())}`);
+  note(steps.map((l2) => dim("  ") + l2).join("\n"), "Next steps");
+  outro(`Created ${accent(path4.basename(name))}, happy building! ${dim("\xB7 v" + version())}`);
 }
 
 // src/cli/doctor.ts
@@ -2078,17 +2376,17 @@ 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 parseVersion(v) {
+  const m = /(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(v);
+  if (!m) return [0, 0, 0];
+  return [Number(m[1]), Number(m[2] ?? 0), Number(m[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;
+  const [a3, b, c2] = parseVersion(version2);
+  const [x, y, z] = parseVersion(range);
+  if (a3 !== x) return a3 > x;
+  if (b !== y) return b > y;
+  return c2 >= z;
 }
 function checkNode(current, requiredRange) {
   const ok = satisfiesMin(current, requiredRange);
@@ -2210,9 +2508,9 @@ function checkRoutesPresent(routeCount) {
 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);
+  for (const p of patterns) {
+    if (seen.has(p)) dupes.add(p);
+    else seen.add(p);
   }
   return dupes.size === 0 ? { id: "route-dupes", label: "Unique route patterns", status: "pass" } : {
     id: "route-dupes",
@@ -2236,13 +2534,13 @@ function findRelativeAssets(files) {
   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++) {
+    for (let i2 = 0; i2 < lines.length; i2++) {
       attr.lastIndex = 0;
-      let m2;
-      while ((m2 = attr.exec(lines[i])) !== null) {
-        const value = m2[1] ?? m2[2] ?? "";
+      let m;
+      while ((m = attr.exec(lines[i2])) !== null) {
+        const value = m[1] ?? m[2] ?? "";
         if (isBrokenRelativeAsset(value)) {
-          issues.push({ file: file.path, line: i + 1, value });
+          issues.push({ file: file.path, line: i2 + 1, value });
         }
       }
     }
@@ -2251,7 +2549,7 @@ function findRelativeAssets(files) {
 }
 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 shown = issues.slice(0, 5).map((i2) => `${i2.file}:${String(i2.line)} "${i2.value}"`).join("; ");
   const more = issues.length > 5 ? `, and ${String(issues.length - 5)} more` : "";
   return {
     id: "rel-assets",
@@ -2297,18 +2595,18 @@ function checkSeoUrl(seoConfigured, hasUrl) {
     fix: "Set client.seo.url so sitemap.xml and canonical links are absolute."
   };
 }
-function checkStyling(f2) {
+function checkStyling(f) {
   const label = "Styling";
-  if (f2.preprocessorImported && f2.preprocessorImported !== "css" && !f2.preprocessorInstalled) {
+  if (f.preprocessorImported && f.preprocessorImported !== "css" && !f.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.`
+      detail: `${f.preprocessorImported} stylesheet imported but ${f.preprocessorImported} is not installed`,
+      fix: `Install ${f.preprocessorImported}, or run toiljs configure.`
     };
   }
-  if (f2.tailwindImported && !f2.tailwindInstalled) {
+  if (f.tailwindImported && !f.tailwindInstalled) {
     return {
       id: "styling",
       label,
@@ -2355,6 +2653,45 @@ function checkWasmBuilt(exists) {
     fix: "Run your server build (toilscript) before toiljs start."
   };
 }
+var RPC_TOILSCRIPT_MIN = "0.1.11";
+function checkRpcWiring(f) {
+  const missing = [];
+  if (!f.toilscriptOk) missing.push(`toilscript >=${RPC_TOILSCRIPT_MIN}`);
+  if (!f.buildServerWired) missing.push("build:server --rpcModule");
+  if (!f.tsconfigWired) missing.push("tsconfig shared/ + alias");
+  if (!f.gitignoreWired) missing.push(".gitignore shared/server.ts");
+  if (missing.length === 0) {
+    return { id: "rpc-wiring", label: "typed RPC wiring", status: "pass" };
+  }
+  return {
+    id: "rpc-wiring",
+    label: "typed RPC wiring",
+    status: "warn",
+    detail: `missing: ${missing.join(", ")}`,
+    fix: "Run `toiljs doctor --fix` to wire @data/@remote RPC (build:server, tsconfig, .gitignore, toilscript)."
+  };
+}
+function checkPrettierPlugin(present) {
+  return present ? { id: "prettier-plugin", label: "prettier toilscript plugin", status: "pass" } : {
+    id: "prettier-plugin",
+    label: "prettier toilscript plugin",
+    status: "warn",
+    detail: "prettier will fail on @main / @remote-on-function in server code",
+    fix: "Run `toiljs doctor --fix` to add toiljs/prettier-plugin to your prettier config."
+  };
+}
+function checkRestDispatch(f) {
+  if (!f.hasControllers || f.dispatched) {
+    return { id: "rest-dispatch", label: "REST dispatch wiring", status: "pass" };
+  }
+  return {
+    id: "rest-dispatch",
+    label: "REST dispatch wiring",
+    status: "warn",
+    detail: "@rest controllers found, but nothing calls Rest.dispatch(req) - their routes will not be served",
+    fix: "In your handler add `const hit = Rest.dispatch(req); if (hit != null) return hit;`, or set `Server.handler = () => new RestHandler()`."
+  };
+}
 function summarize(groups) {
   let pass = 0;
   let warn2 = 0;
@@ -2384,7 +2721,7 @@ function readJsonObject(file) {
 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;
+  for (const [k, v] of Object.entries(value)) if (typeof v === "string") out[k] = v;
   return out;
 }
 function readFile(file) {
@@ -2394,6 +2731,255 @@ function readFile(file) {
     return null;
   }
 }
+function writeFile(file, content) {
+  fs4.writeFileSync(file, content);
+}
+function isPackageInstalled(root, name) {
+  const require2 = createRequire(path5.join(root, "package.json"));
+  for (const id of [`${name}/package.json`, name]) {
+    try {
+      require2.resolve(id);
+      return true;
+    } catch {
+    }
+  }
+  for (let dir = root; ; ) {
+    if (fs4.existsSync(path5.join(dir, "node_modules", name, "package.json"))) return true;
+    const parent = path5.dirname(dir);
+    if (parent === dir) return false;
+    dir = parent;
+  }
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+var RPC_MODULE_FLAG = "--rpcModule shared/server.ts";
+var RPC_GITIGNORE_LINE = "shared/server.ts";
+var RPC_GITIGNORE_RE = /(^|\n)\s*shared\/server\.ts\s*(\r?\n|$)/;
+function looksLikeSemverRange(range) {
+  return /^\s*[v^~>=<]*\s*\d+\.\d+/.test(range);
+}
+function gatherRpcFacts(root) {
+  const pkg = readJsonObject(path5.join(root, "package.json"));
+  const scripts = pkg ? stringRecord(pkg.scripts) : {};
+  const deps = {
+    ...pkg ? stringRecord(pkg.dependencies) : {},
+    ...pkg ? stringRecord(pkg.devDependencies) : {}
+  };
+  const tsconfig = readJsonObject(path5.join(root, "tsconfig.json"));
+  const gitignore = readFile(path5.join(root, ".gitignore"));
+  const buildServerWired = [scripts["build:server"], scripts["build"]].some(
+    (s) => typeof s === "string" && s.includes("--rpcModule")
+  );
+  let tsconfigWired = false;
+  if (tsconfig) {
+    const include = tsconfig.include;
+    const hasShared = !Array.isArray(include) || include.includes("shared");
+    const paths = asRecord(asRecord(tsconfig.compilerOptions)?.paths);
+    tsconfigWired = hasShared && paths !== null && "shared/*" in paths;
+  }
+  const gitignoreWired = gitignore !== null && RPC_GITIGNORE_RE.test(gitignore);
+  const range = deps.toilscript;
+  const toilscriptOk = range == null ? false : looksLikeSemverRange(range) ? satisfiesMin(range, RPC_TOILSCRIPT_MIN) : true;
+  return { buildServerWired, tsconfigWired, gitignoreWired, toilscriptOk };
+}
+function serverSources(root, toilconfig) {
+  const dirs = /* @__PURE__ */ new Set();
+  const entries = Array.isArray(toilconfig?.entries) ? toilconfig.entries.filter((e) => typeof e === "string") : [];
+  for (const e of entries) dirs.add(path5.dirname(path5.resolve(root, e)));
+  const out = [];
+  const cap = 200;
+  const maxDepth = 16;
+  const visit = (current, depth) => {
+    if (out.length >= cap || depth > maxDepth) return;
+    let listing;
+    try {
+      listing = fs4.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of listing) {
+      if (out.length >= cap) break;
+      const full = path5.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name !== "node_modules") visit(full, depth + 1);
+      } else if (entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
+        const src = readFile(full);
+        if (src !== null) out.push(src);
+      }
+    }
+  };
+  for (const dir of dirs) visit(dir, 0);
+  return out;
+}
+function gatherRestFacts(root, toilconfig) {
+  let hasControllers = false;
+  let dispatched = false;
+  for (const src of serverSources(root, toilconfig)) {
+    if (/@rest\b/.test(src)) hasControllers = true;
+    if (/\bRest\s*\.\s*dispatch\s*\(/.test(src) || /\bRestHandler\b/.test(src))
+      dispatched = true;
+    if (hasControllers && dispatched) break;
+  }
+  return { hasControllers, dispatched };
+}
+function applyRpcFix(root) {
+  const changed = [];
+  const skipped = [];
+  const pkgPath = path5.join(root, "package.json");
+  const pkgRaw = readFile(pkgPath);
+  const pkg = pkgRaw !== null ? readJsonObject(pkgPath) : null;
+  if (pkg !== null) {
+    let touched = false;
+    const scripts = asRecord(pkg.scripts) ?? {};
+    for (const key of ["build", "build:server"]) {
+      const value = scripts[key];
+      if (typeof value === "string" && value.includes("toilscript") && !value.includes("--rpcModule")) {
+        scripts[key] = `${value} ${RPC_MODULE_FLAG}`;
+        pkg.scripts = scripts;
+        touched = true;
+      }
+    }
+    let toilscriptDeclared = false;
+    for (const field of ["devDependencies", "dependencies"]) {
+      const bag = asRecord(pkg[field]);
+      const current = bag?.toilscript;
+      if (bag && typeof current === "string") {
+        toilscriptDeclared = true;
+        if (looksLikeSemverRange(current) && !satisfiesMin(current, RPC_TOILSCRIPT_MIN)) {
+          bag.toilscript = `^${RPC_TOILSCRIPT_MIN}`;
+          touched = true;
+        }
+      }
+    }
+    if (!toilscriptDeclared) {
+      const dd = asRecord(pkg.devDependencies) ?? {};
+      dd.toilscript = `^${RPC_TOILSCRIPT_MIN}`;
+      pkg.devDependencies = dd;
+      touched = true;
+    }
+    if (touched) {
+      writeFile(pkgPath, JSON.stringify(pkg, null, 4) + "\n");
+      changed.push("package.json");
+    }
+  } else if (pkgRaw !== null) {
+    skipped.push("package.json (unparseable)");
+  }
+  const tsPath = path5.join(root, "tsconfig.json");
+  const tsRaw = readFile(tsPath);
+  const tsconfig = tsRaw !== null ? readJsonObject(tsPath) : null;
+  if (tsconfig !== null) {
+    let touched = false;
+    if (Array.isArray(tsconfig.include)) {
+      const include = [...tsconfig.include];
+      if (!include.includes("shared")) {
+        const at = include.indexOf("client");
+        include.splice(at >= 0 ? at + 1 : include.length, 0, "shared");
+        tsconfig.include = include;
+        touched = true;
+      }
+    }
+    const co = asRecord(tsconfig.compilerOptions) ?? {};
+    const paths = asRecord(co.paths) ?? {};
+    if (!("shared/*" in paths)) {
+      paths["shared/*"] = ["./shared/*"];
+      co.paths = paths;
+      tsconfig.compilerOptions = co;
+      touched = true;
+    }
+    if (touched) {
+      writeFile(tsPath, JSON.stringify(tsconfig, null, 4) + "\n");
+      changed.push("tsconfig.json");
+    }
+  } else if (tsRaw !== null) {
+    skipped.push('tsconfig.json (JSON with comments, add "shared" + paths by hand)');
+  }
+  const giPath = path5.join(root, ".gitignore");
+  const giRaw = readFile(giPath);
+  if (giRaw === null) {
+    writeFile(giPath, `${RPC_GITIGNORE_LINE}
+`);
+    changed.push(".gitignore");
+  } else if (!RPC_GITIGNORE_RE.test(giRaw)) {
+    const sep = giRaw.length === 0 || giRaw.endsWith("\n") ? "" : "\n";
+    writeFile(giPath, `${giRaw}${sep}${RPC_GITIGNORE_LINE}
+`);
+    changed.push(".gitignore");
+  }
+  return { changed, skipped };
+}
+var PRETTIER_PLUGIN = "toiljs/prettier-plugin";
+var PRETTIER_MENTION = /toiljs\/prettier(-plugin)?/;
+var PRETTIER_CONFIG_FILES = [
+  ".prettierrc",
+  ".prettierrc.json",
+  ".prettierrc.json5",
+  ".prettierrc.yaml",
+  ".prettierrc.yml",
+  ".prettierrc.js",
+  ".prettierrc.cjs",
+  ".prettierrc.mjs",
+  ".prettierrc.ts",
+  "prettier.config.js",
+  "prettier.config.cjs",
+  "prettier.config.mjs",
+  "prettier.config.ts"
+];
+function prettierPluginPresent(root, pkg) {
+  if (pkg && pkg.prettier !== void 0 && PRETTIER_MENTION.test(JSON.stringify(pkg.prettier))) {
+    return true;
+  }
+  for (const name of PRETTIER_CONFIG_FILES) {
+    const raw = readFile(path5.join(root, name));
+    if (raw !== null && PRETTIER_MENTION.test(raw)) return true;
+  }
+  return false;
+}
+function applyPrettierFix(root, pkg) {
+  const changed = [];
+  const skipped = [];
+  if (prettierPluginPresent(root, pkg)) return { changed, skipped };
+  const pkgPath = path5.join(root, "package.json");
+  const pkgConfig = pkg ? asRecord(pkg.prettier) : null;
+  if (pkgConfig !== null) {
+    const full = readJsonObject(pkgPath);
+    const target = full ? asRecord(full.prettier) : null;
+    if (full && target) {
+      target.plugins = [
+        ...Array.isArray(target.plugins) ? target.plugins : [],
+        PRETTIER_PLUGIN
+      ];
+      writeFile(pkgPath, JSON.stringify(full, null, 4) + "\n");
+      changed.push("package.json");
+      return { changed, skipped };
+    }
+  }
+  for (const name of [".prettierrc", ".prettierrc.json"]) {
+    const filePath = path5.join(root, name);
+    const raw = readFile(filePath);
+    if (raw === null) continue;
+    const obj = readJsonObject(filePath);
+    if (obj === null) {
+      skipped.push(`${name} (add "${PRETTIER_PLUGIN}" to plugins by hand)`);
+      return { changed, skipped };
+    }
+    obj.plugins = [...Array.isArray(obj.plugins) ? obj.plugins : [], PRETTIER_PLUGIN];
+    writeFile(filePath, JSON.stringify(obj, null, 4) + "\n");
+    changed.push(name);
+    return { changed, skipped };
+  }
+  const jsConfig = PRETTIER_CONFIG_FILES.find((name) => readFile(path5.join(root, name)) !== null);
+  if (jsConfig) {
+    skipped.push(`${jsConfig} (add "${PRETTIER_PLUGIN}" to its plugins by hand)`);
+    return { changed, skipped };
+  }
+  writeFile(
+    path5.join(root, ".prettierrc.json"),
+    JSON.stringify({ plugins: [PRETTIER_PLUGIN] }, null, 4) + "\n"
+  );
+  changed.push(".prettierrc.json");
+  return { changed, skipped };
+}
 function frameworkMeta() {
   const pkgPath = path5.resolve(
     path5.dirname(fileURLToPath3(import.meta.url)),
@@ -2487,7 +3073,7 @@ async function runDoctor(opts) {
   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 mainPatterns = routes.filter((r2) => r2.slot === void 0).map((r2) => r2.pattern);
   const assetIssues = findRelativeAssets(collectSources(root, clientAbsDir, 200));
   let preprocessorImported = null;
   let tailwindImported = false;
@@ -2504,14 +3090,9 @@ async function runDoctor(opts) {
   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 entries = Array.isArray(toilconfig.entries) ? toilconfig.entries.filter((e) => typeof e === "string") : [];
+    missingEntries = entries.filter((e) => !fs4.existsSync(path5.join(root, e)));
+    toilscriptInstalled = isPackageInstalled(root, "toilscript");
     const targets = typeof toilconfig.targets === "object" && toilconfig.targets !== null ? toilconfig.targets : {};
     const outFiles = [];
     for (const target of Object.values(targets)) {
@@ -2520,17 +3101,29 @@ async function runDoctor(opts) {
         if (typeof outFile === "string") outFiles.push(outFile);
       }
     }
-    wasmExists = outFiles.some((f2) => fs4.existsSync(path5.join(root, f2)));
+    wasmExists = outFiles.some((f) => fs4.existsSync(path5.join(root, f)));
     if (!wasmExists && outFiles.length === 0) {
       try {
-        wasmExists = fs4.readdirSync(path5.join(root, "build", "server")).some((f2) => f2.endsWith(".wasm"));
+        wasmExists = fs4.readdirSync(path5.join(root, "build", "server")).some((f) => f.endsWith(".wasm"));
       } catch {
         wasmExists = false;
       }
     }
   }
-  const peerName = (n) => checkPeer(n, deps[n] ?? null, meta.peers[n] ?? "*");
+  const peerName = (n2) => checkPeer(n2, deps[n2] ?? null, meta.peers[n2] ?? "*");
   const peerChecks = Object.keys(meta.peers).map(peerName);
+  const rpcFix = serverPresent && opts.fix ? applyRpcFix(root) : null;
+  const prettierFix = serverPresent && opts.fix ? applyPrettierFix(root, projectPkg) : null;
+  const rpcFacts = gatherRpcFacts(root);
+  const restFacts = gatherRestFacts(root, toilconfig);
+  const prettierPresent = prettierPluginPresent(
+    root,
+    readJsonObject(path5.join(root, "package.json"))
+  );
+  const serverFix = rpcFix || prettierFix ? {
+    changed: [...rpcFix?.changed ?? [], ...prettierFix?.changed ?? []],
+    skipped: [...rpcFix?.skipped ?? [], ...prettierFix?.skipped ?? []]
+  } : null;
   const groups = [
     {
       title: "Environment",
@@ -2538,7 +3131,7 @@ async function runDoctor(opts) {
         checkNode(process.versions.node, meta.node),
         checkToiljsInstalled("toiljs" in deps ? version() : null),
         ...peerChecks,
-        checkPackageManager(LOCKFILES.filter((f2) => fs4.existsSync(path5.join(root, f2))))
+        checkPackageManager(LOCKFILES.filter((f) => fs4.existsSync(path5.join(root, f))))
       ]
     },
     {
@@ -2583,29 +3176,53 @@ async function runDoctor(opts) {
         checkToilconfig(true),
         checkServerEntry(missingEntries),
         checkToilscriptInstalled(toilscriptInstalled),
-        checkWasmBuilt(wasmExists)
+        checkWasmBuilt(wasmExists),
+        checkRpcWiring(rpcFacts),
+        checkRestDispatch(restFacts),
+        checkPrettierPlugin(prettierPresent)
       ] : [checkToilconfig(false)]
     }
   ];
   const summary = summarize(groups);
   if (opts.json) {
-    process.stdout.write(JSON.stringify({ groups, summary }, null, 2) + "\n");
+    process.stdout.write(JSON.stringify({ groups, summary, fixed: serverFix }, null, 2) + "\n");
   } else {
     process.stdout.write("\n" + accent("  Doctor") + dim(`  ${root}`) + "\n\n");
     renderHuman(groups);
+    if (serverFix) renderRpcFix(serverFix);
+    else if (opts.fix && !serverPresent) {
+      process.stdout.write(
+        "  " + dim("--fix: no server (toilconfig.json) found, nothing to wire.") + "\n\n"
+      );
+    }
   }
   if (hasFailures(summary)) process.exitCode = 1;
 }
+function renderRpcFix(result) {
+  const out = [];
+  if (result.changed.length > 0) {
+    out.push("  " + success("fixed RPC wiring") + dim(`  ${result.changed.join(", ")}`));
+    if (result.changed.includes("package.json")) {
+      out.push(
+        "  " + dim("run your installer (npm/pnpm/yarn) if the toilscript version changed.")
+      );
+    }
+  } else {
+    out.push("  " + dim("RPC wiring already in place, nothing to fix."));
+  }
+  for (const item of result.skipped) out.push("  " + warn("skipped") + dim(`  ${item}`));
+  process.stdout.write(out.join("\n") + "\n\n");
+}
 
 // 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 parseVersion2(v) {
+  const m = /(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(v);
+  if (!m) return [0, 0, 0];
+  return [Number(m[1]), Number(m[2] ?? 0), Number(m[3] ?? 0)];
 }
 function classifyBump(from, to) {
   const [fa, fb, fc] = parseVersion2(from);
@@ -2615,15 +3232,15 @@ function classifyBump(from, to) {
   if (tc !== fc) return "patch";
   return "other";
 }
-function parseNcuJson(stdout) {
-  const start2 = stdout.indexOf("{");
-  const end = stdout.lastIndexOf("}");
+function parseNcuJson(stdout2) {
+  const start2 = stdout2.indexOf("{");
+  const end = stdout2.lastIndexOf("}");
   if (start2 === -1 || end <= start2) return {};
   try {
-    const parsed = JSON.parse(stdout.slice(start2, end + 1));
+    const parsed = JSON.parse(stdout2.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;
+    for (const [k, v] of Object.entries(parsed)) if (typeof v === "string") out[k] = v;
     return out;
   } catch {
     return {};
@@ -2634,7 +3251,7 @@ 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));
+  }).sort((a3, b) => SEVERITY[a3.bump] - SEVERITY[b.bump] || a3.name.localeCompare(b.name));
 }
 
 // src/cli/update.ts
@@ -2648,19 +3265,19 @@ 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 merge = (v) => {
+    if (typeof v !== "object" || v === null) return {};
     const out = {};
-    for (const [k2, val] of Object.entries(v2)) if (typeof val === "string") out[k2] = val;
+    for (const [k, val] of Object.entries(v)) if (typeof val === "string") out[k] = 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 bumpColor(bump, text2) {
+  if (bump === "major") return danger(text2);
+  if (bump === "minor") return warn(text2);
+  if (bump === "patch") return success(text2);
+  return dim(text2);
 }
 function rowLine(row) {
   return `${row.name}  ${dim(row.from)} ${dim("->")} ${bumpColor(row.bump, row.to)}`;
@@ -2684,51 +3301,51 @@ async function runUpdate(opts) {
     target,
     ...extra
   ];
-  ye(accent("toiljs update"));
-  const s = vt();
+  intro(accent("toiljs update"));
+  const s = spinner();
   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");
+    note(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."));
+    outro(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(
+  for (const r2 of rows) counts[r2.bump]++;
+  note(
     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);
+    selected = rows.map((r2) => r2.name);
   } else {
-    const answer = await we({
+    const answer = await multiselect({
       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}`
+      options: rows.map((r2) => ({
+        value: r2.name,
+        label: r2.name,
+        hint: `${r2.from} -> ${r2.to}`
       })),
-      initialValues: rows.map((r) => r.name),
+      initialValues: rows.map((r2) => r2.name),
       required: false
     });
-    if (R(answer)) {
-      ge("Update cancelled.");
+    if (isCancel(answer)) {
+      cancel("Update cancelled.");
       return;
     }
     selected = answer;
   }
   if (selected.length === 0) {
-    fe(dim("No packages selected."));
+    outro(dim("No packages selected."));
     return;
   }
   s.start("Updating package.json");
@@ -2738,7 +3355,7 @@ async function runUpdate(opts) {
   s.start(`Installing with ${pm.name}`);
   await run(pm.name, ["install"], root);
   s.stop("Dependencies installed");
-  fe(
+  outro(
     success(`Updated ${String(selected.length)} package${selected.length === 1 ? "" : "s"}.`)
   );
 }
@@ -2746,28 +3363,31 @@ async function runUpdate(opts) {
 // src/cli/index.ts
 function parseArgs(argv) {
   const flags = {};
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
+  for (let i2 = 0; i2 < argv.length; i2++) {
+    const arg = argv[i2];
     switch (arg) {
       case "--root":
-        flags.root = argv[++i];
+        flags.root = argv[++i2];
         break;
       case "--port": {
-        const port = Number(argv[++i]);
+        const port = Number(argv[++i2]);
         if (!Number.isNaN(port)) flags.port = port;
         break;
       }
+      case "--host":
+        flags.host = argv[++i2];
+        break;
       case "--template":
       case "-t": {
-        const t = argv[++i];
-        if (t === "app" || t === "minimal") flags.template = t;
+        const t2 = argv[++i2];
+        if (t2 === "app" || t2 === "minimal") flags.template = t2;
         break;
       }
       case "--pm":
-        flags.pm = argv[++i];
+        flags.pm = argv[++i2];
         break;
       case "--style": {
-        const s = argv[++i];
+        const s = argv[++i2];
         if (PREPROCESSORS.includes(s))
           flags.preprocessor = s;
         break;
@@ -2809,8 +3429,11 @@ function parseArgs(argv) {
       case "--json":
         flags.json = true;
         break;
+      case "--fix":
+        flags.fix = true;
+        break;
       case "--target":
-        flags.target = argv[++i];
+        flags.target = argv[++i2];
         break;
       default:
         if (!arg.startsWith("-") && flags.name === void 0) flags.name = arg;
@@ -2843,6 +3466,7 @@ function printHelp() {
       cmd("-y, --yes", "create: accept defaults (non-interactive)"),
       cmd("--no-install", "create: don't install dependencies"),
       cmd("--json", "doctor: machine-readable output"),
+      cmd("--fix", "doctor: auto-fix what it can (typed-RPC wiring)"),
       cmd("--target <t>", "update: latest | minor | patch | newest | greatest"),
       cmd("-v, --version", "print the toiljs version"),
       ""
@@ -2898,7 +3522,7 @@ async function main() {
     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 });
+      const server = await start({ root: flags.root, port: flags.port, host: flags.host });
       process.stdout.write(
         accent("  \u279C ") + bold(`http://localhost:${String(server.port)}`) + dim(`   ws channel: ${server.wsPath}`) + "\n\n"
       );
@@ -2906,7 +3530,7 @@ async function main() {
     }
     case "doctor":
       if (!flags.json) banner();
-      await runDoctor({ root: flags.root, cwd: process.cwd(), json: flags.json });
+      await runDoctor({ root: flags.root, cwd: process.cwd(), json: flags.json, fix: flags.fix });
       break;
     case "update":
       banner();