@bungres/kit 0.6.1 → 0.7.0

package/dist/cli.js

@@ -1,5 +1,165 @@
 #!/usr/bin/env bun
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = import.meta.require;
+
+// ../../node_modules/.bun/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
+var require_src = __commonJS((exports, module) => {
+  var ESC2 = "\x1B";
+  var CSI2 = `${ESC2}[`;
+  var beep = "\x07";
+  var cursor = {
+    to(x, y) {
+      if (!y)
+        return `${CSI2}${x + 1}G`;
+      return `${CSI2}${y + 1};${x + 1}H`;
+    },
+    move(x, y) {
+      let ret = "";
+      if (x < 0)
+        ret += `${CSI2}${-x}D`;
+      else if (x > 0)
+        ret += `${CSI2}${x}C`;
+      if (y < 0)
+        ret += `${CSI2}${-y}A`;
+      else if (y > 0)
+        ret += `${CSI2}${y}B`;
+      return ret;
+    },
+    up: (count2 = 1) => `${CSI2}${count2}A`,
+    down: (count2 = 1) => `${CSI2}${count2}B`,
+    forward: (count2 = 1) => `${CSI2}${count2}C`,
+    backward: (count2 = 1) => `${CSI2}${count2}D`,
+    nextLine: (count2 = 1) => `${CSI2}E`.repeat(count2),
+    prevLine: (count2 = 1) => `${CSI2}F`.repeat(count2),
+    left: `${CSI2}G`,
+    hide: `${CSI2}?25l`,
+    show: `${CSI2}?25h`,
+    save: `${ESC2}7`,
+    restore: `${ESC2}8`
+  };
+  var scroll = {
+    up: (count2 = 1) => `${CSI2}S`.repeat(count2),
+    down: (count2 = 1) => `${CSI2}T`.repeat(count2)
+  };
+  var erase = {
+    screen: `${CSI2}2J`,
+    up: (count2 = 1) => `${CSI2}1J`.repeat(count2),
+    down: (count2 = 1) => `${CSI2}J`.repeat(count2),
+    line: `${CSI2}2K`,
+    lineEnd: `${CSI2}K`,
+    lineStart: `${CSI2}1K`,
+    lines(count2) {
+      let clear = "";
+      for (let i = 0;i < count2; i++)
+        clear += this.line + (i < count2 - 1 ? cursor.up() : "");
+      if (count2)
+        clear += cursor.left;
+      return clear;
+    }
+  };
+  module.exports = { cursor, scroll, erase, beep };
+});
+
+// ../../node_modules/.bun/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS((exports, module) => {
+  var p2 = process || {};
+  var argv = p2.argv || [];
+  var env = p2.env || {};
+  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p2.platform === "win32" || (p2.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+  var formatter = (open, close, replace = open) => (input2) => {
+    let string = "" + input2, index2 = string.indexOf(close, open.length);
+    return ~index2 ? open + replaceClose(string, close, replace, index2) + close : open + string + close;
+  };
+  var replaceClose = (string, close, replace, index2) => {
+    let result2 = "", cursor3 = 0;
+    do {
+      result2 += string.substring(cursor3, index2) + replace;
+      cursor3 = index2 + close.length;
+      index2 = string.indexOf(close, cursor3);
+    } while (~index2);
+    return result2 + string.substring(cursor3);
+  };
+  var createColors = (enabled = isColorSupported) => {
+    let f2 = enabled ? formatter : () => String;
+    return {
+      isColorSupported: enabled,
+      reset: f2("\x1B[0m", "\x1B[0m"),
+      bold: f2("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+      dim: f2("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+      italic: f2("\x1B[3m", "\x1B[23m"),
+      underline: f2("\x1B[4m", "\x1B[24m"),
+      inverse: f2("\x1B[7m", "\x1B[27m"),
+      hidden: f2("\x1B[8m", "\x1B[28m"),
+      strikethrough: f2("\x1B[9m", "\x1B[29m"),
+      black: f2("\x1B[30m", "\x1B[39m"),
+      red: f2("\x1B[31m", "\x1B[39m"),
+      green: f2("\x1B[32m", "\x1B[39m"),
+      yellow: f2("\x1B[33m", "\x1B[39m"),
+      blue: f2("\x1B[34m", "\x1B[39m"),
+      magenta: f2("\x1B[35m", "\x1B[39m"),
+      cyan: f2("\x1B[36m", "\x1B[39m"),
+      white: f2("\x1B[37m", "\x1B[39m"),
+      gray: f2("\x1B[90m", "\x1B[39m"),
+      bgBlack: f2("\x1B[40m", "\x1B[49m"),
+      bgRed: f2("\x1B[41m", "\x1B[49m"),
+      bgGreen: f2("\x1B[42m", "\x1B[49m"),
+      bgYellow: f2("\x1B[43m", "\x1B[49m"),
+      bgBlue: f2("\x1B[44m", "\x1B[49m"),
+      bgMagenta: f2("\x1B[45m", "\x1B[49m"),
+      bgCyan: f2("\x1B[46m", "\x1B[49m"),
+      bgWhite: f2("\x1B[47m", "\x1B[49m"),
+      blackBright: f2("\x1B[90m", "\x1B[39m"),
+      redBright: f2("\x1B[91m", "\x1B[39m"),
+      greenBright: f2("\x1B[92m", "\x1B[39m"),
+      yellowBright: f2("\x1B[93m", "\x1B[39m"),
+      blueBright: f2("\x1B[94m", "\x1B[39m"),
+      magentaBright: f2("\x1B[95m", "\x1B[39m"),
+      cyanBright: f2("\x1B[96m", "\x1B[39m"),
+      whiteBright: f2("\x1B[97m", "\x1B[39m"),
+      bgBlackBright: f2("\x1B[100m", "\x1B[49m"),
+      bgRedBright: f2("\x1B[101m", "\x1B[49m"),
+      bgGreenBright: f2("\x1B[102m", "\x1B[49m"),
+      bgYellowBright: f2("\x1B[103m", "\x1B[49m"),
+      bgBlueBright: f2("\x1B[104m", "\x1B[49m"),
+      bgMagentaBright: f2("\x1B[105m", "\x1B[49m"),
+      bgCyanBright: f2("\x1B[106m", "\x1B[49m"),
+      bgWhiteBright: f2("\x1B[107m", "\x1B[49m")
+    };
+  };
+  module.exports = createColors();
+  module.exports.createColors = createColors;
+});
 
 // src/schema-loader.ts
 import { resolve, join } from "path";
@@ -1361,203 +1521,1588 @@ function isTable(value) {
   return typeof value === "object" && value !== null && TableConfigSymbol in value;
 }
 
-// src/utils/colors.ts
-function colorize(text, color) {
-  const code2 = Bun.color(color, "ansi");
-  return code2 ? `${code2}${text}\x1B[0m` : text;
-}
+// ../../node_modules/.bun/@clack+core@1.4.3/node_modules/@clack/core/dist/index.mjs
+import { styleText } from "util";
+import { stdout, stdin } from "process";
+import * as l from "readline";
+import l__default from "readline";
 
-// src/commands/drop.ts
-async function runDrop(config2, opts = {}) {
-  const schemas2 = await loadSchemas(config2.schema);
-  if (schemas2.length === 0) {
-    console.warn("No table definitions found in schema files.");
-    return;
+// ../../node_modules/.bun/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = (() => {
+  const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  return (input2) => {
+    let surrogatePairsNr = 0;
+    SURROGATE_PAIR_RE.lastIndex = 0;
+    while (SURROGATE_PAIR_RE.test(input2)) {
+      surrogatePairsNr += 1;
+    }
+    return input2.length - surrogatePairsNr;
+  };
+})();
+var isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x) => {
+  return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+// ../../node_modules/.bun/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/yu;
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = /\p{M}+/gu;
+var NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+var getStringTruncatedWidth = (input2, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+  const PARSE_BLOCKS = [
+    [LATIN_RE, REGULAR_WIDTH],
+    [ANSI_RE, ANSI_WIDTH],
+    [CONTROL_RE, CONTROL_WIDTH],
+    [TAB_RE, TAB_WIDTH],
+    [EMOJI_RE, EMOJI_WIDTH],
+    [CJKT_WIDE_RE, WIDE_WIDTH]
+  ];
+  let indexPrev = 0;
+  let index2 = 0;
+  let length = input2.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
+  let widthExtra = 0;
+  outer:
+    while (true) {
+      if (unmatchedEnd > unmatchedStart || index2 >= length && index2 > indexPrev) {
+        const unmatched = input2.slice(unmatchedStart, unmatchedEnd) || input2.slice(indexPrev, index2);
+        lengthExtra = 0;
+        for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+          const codePoint = char.codePointAt(0) || 0;
+          if (isFullWidth(codePoint)) {
+            widthExtra = FULL_WIDTH_WIDTH;
+          } else if (isWideNotCJKTNotEmoji(codePoint)) {
+            widthExtra = WIDE_WIDTH;
+          } else {
+            widthExtra = REGULAR_WIDTH;
+          }
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          lengthExtra += char.length;
+          width += widthExtra;
+        }
+        unmatchedStart = unmatchedEnd = 0;
+      }
+      if (index2 >= length) {
+        break outer;
+      }
+      for (let i = 0, l = PARSE_BLOCKS.length;i < l; i++) {
+        const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+        BLOCK_RE.lastIndex = index2;
+        if (BLOCK_RE.test(input2)) {
+          lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input2.slice(index2, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index2;
+          widthExtra = lengthExtra * BLOCK_WIDTH;
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, index2 + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          width += widthExtra;
+          unmatchedStart = indexPrev;
+          unmatchedEnd = index2;
+          index2 = indexPrev = BLOCK_RE.lastIndex;
+          continue outer;
+        }
+      }
+      index2 += 1;
+    }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+};
+var dist_default = getStringTruncatedWidth;
+
+// ../../node_modules/.bun/fast-string-width@3.0.2/node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input2, options = {}) => {
+  return dist_default(input2, NO_TRUNCATION2, options).width;
+};
+var dist_default2 = fastStringWidth;
+
+// ../../node_modules/.bun/fast-wrap-ansi@0.2.2/node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "\x9B";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return;
+};
+var wrapAnsiCode = (code2) => `${ESC}${ANSI_CSI}${code2}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns2) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible = lastRow === undefined ? 0 : dist_default2(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default2(character);
+    if (visible + characterLength <= columns2) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible += characterLength;
+      if (visible === columns2 && !nextCharacter.done) {
+        rows.push("");
+        visible = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
   }
-  const sql2 = new Bun.SQL(config2.dbUrl);
-  try {
-    const userSchema = config2.dbSchema;
-    const existingUserTablesResult = await sql2.unsafe(`SELECT table_name FROM information_schema.tables WHERE table_schema = $1`, [userSchema]);
-    const existingTableNames = new Set(existingUserTablesResult.map((r) => r.table_name));
-    const migTableCheck = await sql2.unsafe(`SELECT EXISTS (
-        SELECT 1 FROM information_schema.tables
-        WHERE table_schema = $1 AND table_name = $2
-      ) AS exists`, [config2.migrationsSchema, config2.migrationsTable]);
-    const migrationTableExists = migTableCheck[0]?.exists ?? false;
-    const pushTableCheck = await sql2.unsafe(`SELECT EXISTS (
-        SELECT 1 FROM information_schema.tables
-        WHERE table_schema = $1 AND table_name = $2
-      ) AS exists`, [config2.migrationsSchema, "__bungres_push"]);
-    const pushTableExists = pushTableCheck[0]?.exists ?? false;
-    const tablesToDrop = schemas2.filter((s) => existingTableNames.has(s.config.name));
-    if (tablesToDrop.length === 0 && !migrationTableExists && !pushTableExists) {
-      console.log("No tables to drop (they either don't exist or were already dropped).");
-      return;
+  lastRow = rows.at(-1);
+  if (!visible && lastRow !== undefined && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default2(words[last - 1])) {
+      break;
     }
-    const tableNamesToPrint = tablesToDrop.map((s) => (s.config.schema ? s.config.schema + "." : "") + s.config.name);
-    if (migrationTableExists) {
-      tableNamesToPrint.push(`${config2.migrationsSchema}.${config2.migrationsTable}`);
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string, columns2, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index2 = 0;index2 < words.length; index2++) {
+    const word = words[index2];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default2(trimmed);
+      }
     }
-    if (pushTableExists) {
-      tableNamesToPrint.push(`${config2.migrationsSchema}.__bungres_push`);
+    if (index2 !== 0) {
+      if (rowLength >= columns2 && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
     }
-    if (!opts.force) {
-      console.warn(colorize(`
-\u26A0\uFE0F  WARNING: This will drop the following tables and ALL their data:
-`, "red"));
-      for (const name of tableNamesToPrint)
-        console.log(colorize(`  - ${name}`, "yellow"));
-      process.stdout.write(colorize(`
-Are you sure? Type YES to continue: `, "cyan"));
-      for await (const line2 of console) {
-        if (line2.trim().toLowerCase() !== "yes") {
-          console.log("Aborted.");
-          return;
-        }
-        break;
+    const wordLength = dist_default2(word);
+    if (options.hard && wordLength > columns2) {
+      const remainingColumns = columns2 - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns2);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns2);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
       }
+      wrapWord(rows, word, columns2);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
     }
-    for (const entry of tablesToDrop) {
-      const ddl = `DROP TABLE IF EXISTS "${entry.config.name}" CASCADE;`;
-      await sql2.unsafe(ddl);
-      console.log(colorize(`  \u2713 dropped ${entry.config.name}`, "green"));
+    if (rowLength + wordLength > columns2 && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns2) {
+        wrapWord(rows, word, columns2);
+        rowLength = dist_default2(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
     }
-    if (migrationTableExists) {
-      const qualifiedMigTable = `"${config2.migrationsSchema}"."${config2.migrationsTable}"`;
-      await sql2.unsafe(`DROP TABLE IF EXISTS ${qualifiedMigTable} CASCADE`);
-      console.log(colorize(`  \u2713 dropped ${config2.migrationsSchema}.${config2.migrationsTable}`, "green"));
+    if (rowLength + wordLength > columns2 && options.wordWrap === false) {
+      wrapWord(rows, word, columns2);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
     }
-    if (pushTableExists) {
-      await sql2.unsafe(`DROP TABLE IF EXISTS "${config2.migrationsSchema}"."__bungres_push" CASCADE`);
-      console.log(colorize(`  \u2713 dropped ${config2.migrationsSchema}.__bungres_push`, "green"));
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join(`
+`);
+  let inSurrogate = false;
+  for (let i = 0;i < preString.length; i++) {
+    const character = preString[i];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== undefined) {
+        const code2 = Number.parseFloat(groups.code);
+        escapeCode = code2 === END_CODE ? undefined : code2;
+      } else if (groups?.uri !== undefined) {
+        escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+      }
+    }
+    if (preString[i + 1] === `
+`) {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : undefined;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === `
+`) {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
     }
-    console.log(colorize(`
-Drop complete.`, "green"));
-  } finally {
-    await sql2.end();
   }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns2, options) {
+  return String(string).normalize().split(CRLF_OR_LF).map((line2) => exec(line2, columns2, options)).join(`
+`);
 }
 
-// src/commands/migrate.ts
-import { join as join2, resolve as resolve2 } from "path";
-async function runMigrate(config2) {
-  const migrationsDir = resolve2(config2.out);
-  const sql2 = new Bun.SQL(config2.dbUrl);
-  const table2 = config2.migrationsTable;
-  const schema = config2.migrationsSchema;
-  const qualifiedTable = `"${schema}"."${table2}"`;
-  const createSchema = `CREATE SCHEMA IF NOT EXISTS "${schema}";`;
-  const createMigrationsTable = `
-CREATE TABLE IF NOT EXISTS ${qualifiedTable} (
-  id          SERIAL PRIMARY KEY,
-  name        TEXT NOT NULL UNIQUE,
-  applied_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
-);`.trim();
-  try {
-    await sql2.unsafe(createSchema);
-    await sql2.unsafe(createMigrationsTable);
-    const glob = new Bun.Glob("*.sql");
-    const files = [];
-    for await (const file of glob.scan({ cwd: migrationsDir, absolute: false })) {
-      files.push(file);
+// ../../node_modules/.bun/@clack+core@1.4.3/node_modules/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+import { ReadStream } from "tty";
+function findCursor(s, o, l2) {
+  if (!l2.some((r) => !r.disabled))
+    return s;
+  const t = s + o, n = Math.max(l2.length - 1, 0), e = t < 0 ? n : t > n ? 0 : t;
+  return l2[e]?.disabled ? findCursor(e, o < 0 ? -1 : 1, l2) : e;
+}
+function findTextCursor(s, o, l2, i) {
+  const t = i.split(`
+`);
+  let n = 0, e = s;
+  for (const r of t) {
+    if (e <= r.length)
+      break;
+    e -= r.length + 1, n++;
+  }
+  for (n = Math.max(0, Math.min(t.length - 1, n + l2)), e = Math.min(e, t[n].length) + o;e < 0 && n > 0; )
+    n--, e += t[n].length + 1;
+  for (;e > t[n].length && n < t.length - 1; )
+    e -= t[n].length + 1, n++;
+  e = Math.max(0, Math.min(t[n].length, e));
+  let h = 0;
+  for (let r = 0;r < n; r++)
+    h += t[r].length + 1;
+  return h + e;
+}
+var a$1 = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var t = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var settings = {
+  actions: new Set(a$1),
+  aliases: /* @__PURE__ */ new Map([
+    ["k", "up"],
+    ["j", "down"],
+    ["h", "left"],
+    ["l", "right"],
+    ["\x03", "cancel"],
+    ["escape", "cancel"]
+  ]),
+  messages: {
+    cancel: "Canceled",
+    error: "Something went wrong"
+  },
+  withGuide: true,
+  date: {
+    monthNames: [...t],
+    messages: {
+      required: "Please enter a valid date",
+      invalidMonth: "There are only 12 months in a year",
+      invalidDay: (n, e) => `There are only ${n} days in ${e}`,
+      afterMin: (n) => `Date must be on or after ${n.toISOString().slice(0, 10)}`,
+      beforeMax: (n) => `Date must be on or before ${n.toISOString().slice(0, 10)}`
     }
-    files.sort();
-    if (files.length === 0) {
-      console.log(colorize("No migration files found in " + migrationsDir, "yellow"));
-      console.log(colorize("Run `bungres generate` first.", "yellow"));
+  }
+};
+function isActionKey(n, e) {
+  if (typeof n == "string")
+    return settings.aliases.get(n) === e;
+  for (const s of n)
+    if (s !== undefined && isActionKey(s, e))
+      return true;
+  return false;
+}
+function diffLines(i, s) {
+  if (i === s)
+    return;
+  const e = i.split(`
+`), t2 = s.split(`
+`), r = Math.max(e.length, t2.length), f = [];
+  for (let n = 0;n < r; n++)
+    e[n] !== t2[n] && f.push(n);
+  return {
+    lines: f,
+    numLinesBefore: e.length,
+    numLinesAfter: t2.length,
+    numLines: r
+  };
+}
+var R = globalThis.process.platform.startsWith("win");
+var CANCEL_SYMBOL = Symbol("clack:cancel");
+function isCancel(e) {
+  return e === CANCEL_SYMBOL;
+}
+function setRawMode(e, r) {
+  const o = e;
+  o.isTTY && o.setRawMode(r);
+}
+function block({
+  input: e = stdin,
+  output: r = stdout,
+  overwrite: o = true,
+  hideCursor: t2 = true
+} = {}) {
+  const s = l.createInterface({
+    input: e,
+    output: r,
+    prompt: "",
+    tabSize: 1
+  });
+  l.emitKeypressEvents(e, s), e instanceof ReadStream && e.isTTY && e.setRawMode(true);
+  const n = (f, { name: a, sequence: p }) => {
+    const c = String(f);
+    if (isActionKey([c, a, p], "cancel")) {
+      t2 && r.write(import_sisteransi.cursor.show), process.exit(0);
       return;
     }
-    const applied = await sql2.unsafe(`SELECT name FROM ${qualifiedTable}`);
-    const appliedSet = new Set(applied.map((r) => r.name));
-    const pending = files.filter((f) => !appliedSet.has(f));
-    if (pending.length === 0) {
-      console.log(colorize("Everything is up to date.", "green"));
+    if (!o)
       return;
-    }
-    console.log(colorize(`
-Running ${pending.length} pending migration(s)...
-`, "cyan"));
-    for (const file of pending) {
-      const content = await Bun.file(join2(migrationsDir, file)).text();
-      if (config2.verbose) {
-        console.log(`-- ${file} --
-${content}
+    const i = a === "return" ? 0 : -1, m = a === "return" ? -1 : 0;
+    l.moveCursor(r, i, m, () => {
+      l.clearLine(r, 1, () => {
+        e.once("keypress", n);
+      });
+    });
+  };
+  return t2 && r.write(import_sisteransi.cursor.hide), e.once("keypress", n), () => {
+    e.off("keypress", n), t2 && r.write(import_sisteransi.cursor.show), e instanceof ReadStream && e.isTTY && !R && e.setRawMode(false), s.terminal = false, s.close();
+  };
+}
+var getColumns = (e) => ("columns" in e) && typeof e.columns == "number" ? e.columns : 80;
+var getRows = (e) => ("rows" in e) && typeof e.rows == "number" ? e.rows : 20;
+function wrapTextWithPrefix(e, r, o, t2 = o, s = o, n) {
+  const f = getColumns(e ?? stdout);
+  return wrapAnsi(r, f - o.length, {
+    hard: true,
+    trim: false
+  }).split(`
+`).map((c, i, m) => {
+    const d = n ? n(c, i) : c;
+    return i === 0 ? `${t2}${d}` : i === m.length - 1 ? `${s}${d}` : `${o}${d}`;
+  }).join(`
 `);
+}
+function runValidation(e, n) {
+  if ("~standard" in e) {
+    const a = e["~standard"].validate(n);
+    if (a instanceof Promise)
+      throw new TypeError("Schema validation must be synchronous. Update `validate()` and remove any asynchronous logic.");
+    return a.issues?.at(0)?.message;
+  }
+  return e(n);
+}
+
+class V {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map;
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  constructor(t2, e = true) {
+    const { input: i = stdin, output: n = stdout, render: s, signal: r, ...o } = t2;
+    this.opts = o, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = s.bind(this), this._track = e, this._abortSignal = r, this.input = i, this.output = n;
+  }
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  setSubscriber(t2, e) {
+    const i = this._subscribers.get(t2) ?? [];
+    i.push(e), this._subscribers.set(t2, i);
+  }
+  on(t2, e) {
+    this.setSubscriber(t2, { cb: e });
+  }
+  once(t2, e) {
+    this.setSubscriber(t2, { cb: e, once: true });
+  }
+  emit(t2, ...e) {
+    const i = this._subscribers.get(t2) ?? [], n = [];
+    for (const s of i)
+      s.cb(...e), s.once && n.push(() => i.splice(i.indexOf(s), 1));
+    for (const s of n)
+      s();
+  }
+  prompt() {
+    return new Promise((t2) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted)
+          return this.state = "cancel", this.close(), t2(CANCEL_SYMBOL);
+        this._abortSignal.addEventListener("abort", () => {
+          this.state = "cancel", this.close();
+        }, { once: true });
       }
-      await sql2.transaction(async (txSql) => {
-        const statements = config2.breakpoints ? content.split(/-->statement-breakpoint/g).flatMap((chunk) => chunk.split(";").map((s) => s.trim()).filter(Boolean)) : content.split(";").map((s) => s.trim()).filter(Boolean);
-        for (const stmt of statements) {
-          await txSql.unsafe(stmt + ";");
-        }
-        await txSql.unsafe(`INSERT INTO ${qualifiedTable} (name) VALUES ($1)`, [file]);
+      this.rl = l__default.createInterface({
+        input: this.input,
+        tabSize: 2,
+        prompt: "",
+        escapeCodeTimeout: 50,
+        terminal: true
+      }), this.rl.prompt(), this.opts.initialUserInput !== undefined && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), setRawMode(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(this.value);
+      }), this.once("cancel", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(CANCEL_SYMBOL);
       });
-      console.log(colorize(`  \u2713  ${file}`, "green"));
+    });
+  }
+  _isActionKey(t2, e) {
+    return t2 === "\t";
+  }
+  _shouldSubmit(t2, e) {
+    return true;
+  }
+  _setValue(t2) {
+    this.value = t2, this.emit("value", this.value);
+  }
+  _setUserInput(t2, e) {
+    this.userInput = t2 ?? "", this.emit("userInput", this.userInput), e && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
+  }
+  _clearUserInput() {
+    this.rl?.write(null, { ctrl: true, name: "u" }), this._setUserInput("");
+  }
+  onKeypress(t2, e) {
+    if (this._track && e.name !== "return" && (e.name && this._isActionKey(t2, e) && this.rl?.write(null, { ctrl: true, name: "h" }), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), e?.name && (!this._track && settings.aliases.has(e.name) && this.emit("cursor", settings.aliases.get(e.name)), settings.actions.has(e.name) && this.emit("cursor", e.name)), t2 && (t2.toLowerCase() === "y" || t2.toLowerCase() === "n") && this.emit("confirm", t2.toLowerCase() === "y"), this.emit("key", t2, e), e?.name === "return" && this._shouldSubmit(t2, e)) {
+      if (this.opts.validate) {
+        const i = runValidation(this.opts.validate, this.value);
+        i && (this.error = i instanceof Error ? i.message : i, this.state = "error", this.rl?.write(this.userInput));
+      }
+      this.state !== "error" && (this.state = "submit");
+    }
+    isActionKey([t2, e?.name, e?.sequence], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+  }
+  close() {
+    this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), setRawMode(this.input, false), this.rl?.close(), this.rl = undefined, this.emit(`${this.state}`, this.value), this.unsubscribe();
+  }
+  restoreCursor() {
+    const t2 = wrapAnsi(this._prevFrame, process.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(import_sisteransi.cursor.move(-999, t2 * -1));
+  }
+  render() {
+    const t2 = wrapAnsi(this._render(this) ?? "", process.stdout.columns, {
+      hard: true,
+      trim: false
+    });
+    if (t2 !== this._prevFrame) {
+      if (this.state === "initial")
+        this.output.write(import_sisteransi.cursor.hide);
+      else {
+        const e = diffLines(this._prevFrame, t2), i = getRows(this.output);
+        if (this.restoreCursor(), e) {
+          const n = Math.max(0, e.numLinesAfter - i), s = Math.max(0, e.numLinesBefore - i);
+          let r = e.lines.find((o) => o >= n);
+          if (r === undefined) {
+            this._prevFrame = t2;
+            return;
+          }
+          if (e.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, r - s)), this.output.write(import_sisteransi.erase.lines(1));
+            const o = t2.split(`
+`);
+            this.output.write(o[r]), this._prevFrame = t2, this.output.write(import_sisteransi.cursor.move(0, o.length - r - 1));
+            return;
+          } else if (e.lines.length > 1) {
+            if (n < s)
+              r = n;
+            else {
+              const h = r - s;
+              h > 0 && this.output.write(import_sisteransi.cursor.move(0, h));
+            }
+            this.output.write(import_sisteransi.erase.down());
+            const f = t2.split(`
+`).slice(r);
+            this.output.write(f.join(`
+`)), this._prevFrame = t2;
+            return;
+          }
+        }
+        this.output.write(import_sisteransi.erase.down());
+      }
+      this.output.write(t2), this.state === "initial" && (this.state = "active"), this._prevFrame = t2;
     }
-    console.log(colorize(`
-Done.`, "green"));
-  } finally {
-    await sql2.end();
   }
 }
-
-// src/commands/fresh.ts
-async function runFresh(config2) {
-  console.log("Dropping all tables...");
-  await runDrop(config2, { force: true });
-  console.log(`
-Re-running migrations...`);
-  await runMigrate(config2);
-  console.log(`
-Fresh complete.`);
+function p$1(l2, e) {
+  if (l2 === undefined || e.length === 0)
+    return 0;
+  const i = e.findIndex((s) => s.value === l2);
+  return i !== -1 ? i : 0;
 }
-
-// src/commands/generate.ts
-import { join as join3, resolve as resolve3 } from "path";
-
-// src/differ.ts
-function diffSchemas(prev, next) {
-  const statements = [];
-  const summary = [];
-  const warnings = [];
-  const prevTables = new Set(Object.keys(prev));
-  const nextTables = new Set(Object.keys(next));
-  const newTableConfigs = [];
-  for (const tableName of nextTables) {
-    if (!prevTables.has(tableName)) {
-      newTableConfigs.push(next[tableName]);
-    }
+function g(l2, e) {
+  return (e.label ?? String(e.value)).toLowerCase().includes(l2.toLowerCase());
+}
+function m(l2, e) {
+  if (e)
+    return l2 ? e : e[0];
+}
+var T$1 = class T extends V {
+  filteredOptions;
+  multiple;
+  isNavigating = false;
+  selectedValues = [];
+  focusedValue;
+  #e = 0;
+  #s = "";
+  #t;
+  #i;
+  #n;
+  get cursor() {
+    return this.#e;
+  }
+  get userInputWithCursor() {
+    if (!this.userInput)
+      return styleText(["inverse", "hidden"], "_");
+    if (this._cursor >= this.userInput.length)
+      return `${this.userInput}\u2588`;
+    const e = this.userInput.slice(0, this.cursor), t2 = this.userInput.slice(this.cursor, this.cursor + 1), i = this.userInput.slice(this.cursor + 1);
+    return `${e}${styleText("inverse", t2)}${i}`;
+  }
+  get options() {
+    return typeof this.#i == "function" ? this.#i() : this.#i;
+  }
+  constructor(e) {
+    super(e), this.#i = e.options, this.#n = e.placeholder;
+    const t2 = this.options;
+    this.filteredOptions = [...t2], this.multiple = e.multiple === true, this.#t = typeof e.options == "function" ? e.filter : e.filter ?? g;
+    let i;
+    if (e.initialValue && Array.isArray(e.initialValue) ? this.multiple ? i = e.initialValue : i = e.initialValue.slice(0, 1) : !this.multiple && this.options.length > 0 && (i = [this.options[0]?.value]), i)
+      for (const s of i) {
+        const n = t2.findIndex((o) => o.value === s);
+        n !== -1 && (this.toggleSelected(s), this.#e = n);
+      }
+    this.focusedValue = this.options[this.#e]?.value, this.on("key", (s, n) => this.#l(s, n)), this.on("userInput", (s) => this.#u(s));
   }
-  for (const config2 of topoSortConfigs(newTableConfigs)) {
-    statements.push(generateCreateTable(config2, true));
-    summary.push(`CREATE TABLE ${config2.name}`);
+  _isActionKey(e, t2) {
+    return e === "\t" || this.multiple && this.isNavigating && t2.name === "space" && e !== undefined && e !== "";
   }
-  for (const tableName of prevTables) {
-    if (!nextTables.has(tableName)) {
-      const config2 = prev[tableName];
-      const tbl = config2.schema ? `"${config2.schema}"."${tableName}"` : `"${tableName}"`;
-      statements.push(`DROP TABLE IF EXISTS ${tbl};`);
-      summary.push(`DROP TABLE ${tableName}`);
-      warnings.push(`Data loss warning: Table '${tableName}' will be permanently deleted.`);
+  #l(e, t2) {
+    const i = t2.name === "up", s = t2.name === "down", n = t2.name === "return", o = this.userInput === "" || this.userInput === "\t", u = this.#n, a = this.options, f = u !== undefined && u !== "" && a.some((r) => !r.disabled && (this.#t ? this.#t(u, r) : true));
+    if (t2.name === "tab" && o && f) {
+      this.userInput === "\t" && this._clearUserInput(), this._setUserInput(u, true), this.isNavigating = false;
+      return;
     }
+    i || s ? (this.#e = findCursor(this.#e, i ? -1 : 1, this.filteredOptions), this.focusedValue = this.filteredOptions[this.#e]?.value, this.multiple || (this.selectedValues = [this.focusedValue]), this.isNavigating = true) : n ? this.value = m(this.multiple, this.selectedValues) : this.multiple ? this.focusedValue !== undefined && (t2.name === "tab" || this.isNavigating && t2.name === "space") ? this.toggleSelected(this.focusedValue) : this.isNavigating = false : (this.focusedValue && (this.selectedValues = [this.focusedValue]), this.isNavigating = false);
   }
-  for (const tableName of nextTables) {
-    if (!prevTables.has(tableName))
-      continue;
-    const prevConfig = prev[tableName];
-    const nextConfig = next[tableName];
-    const prevCols = prevConfig.columns;
-    const nextCols = nextConfig.columns;
-    const prevColNames = new Set(Object.keys(prevCols));
-    const nextColNames = new Set(Object.keys(nextCols));
-    for (const key of nextColNames) {
-      if (!prevColNames.has(key)) {
-        const col2 = nextCols[key];
-        statements.push(generateAddColumn(tableName, nextConfig.schema, key, col2));
-        summary.push(`ALTER TABLE ${tableName} ADD COLUMN ${col2.name}`);
-      }
+  deselectAll() {
+    this.selectedValues = [];
+  }
+  toggleSelected(e) {
+    this.filteredOptions.length !== 0 && (this.multiple ? this.selectedValues.includes(e) ? this.selectedValues = this.selectedValues.filter((t2) => t2 !== e) : this.selectedValues = [...this.selectedValues, e] : this.selectedValues = [e]);
+  }
+  #u(e) {
+    if (e !== this.#s) {
+      this.#s = e;
+      const t2 = this.options;
+      e && this.#t ? this.filteredOptions = t2.filter((n) => this.#t?.(e, n)) : this.filteredOptions = [...t2];
+      const i = p$1(this.focusedValue, this.filteredOptions);
+      this.#e = findCursor(i, 0, this.filteredOptions);
+      const s = this.filteredOptions[this.#e];
+      s && !s.disabled ? this.focusedValue = s.value : this.focusedValue = undefined, this.multiple || (this.focusedValue !== undefined ? this.toggleSelected(this.focusedValue) : this.deselectAll());
     }
-    for (const key of prevColNames) {
-      if (!nextColNames.has(key)) {
+  }
+};
+
+class r extends V {
+  get cursor() {
+    return this.value ? 0 : 1;
+  }
+  get _value() {
+    return this.cursor === 0;
+  }
+  constructor(t2) {
+    super(t2, false), this.value = !!t2.initialValue, this.on("userInput", () => {
+      this.value = this._value;
+    }), this.on("confirm", (i) => {
+      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = i, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+}
+var _ = {
+  Y: { type: "year", len: 4 },
+  M: { type: "month", len: 2 },
+  D: { type: "day", len: 2 }
+};
+function M(r2) {
+  return [...r2].map((t2) => _[t2]);
+}
+function P(r2) {
+  const i = new Intl.DateTimeFormat(r2, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(new Date(2000, 0, 15)), s = [];
+  let n = "/";
+  for (const e of i)
+    e.type === "literal" ? n = e.value.trim() || e.value : (e.type === "year" || e.type === "month" || e.type === "day") && s.push({ type: e.type, len: e.type === "year" ? 4 : 2 });
+  return { segments: s, separator: n };
+}
+function p(r2) {
+  return Number.parseInt((r2 || "0").replace(/_/g, "0"), 10) || 0;
+}
+function f(r2) {
+  return {
+    year: p(r2.year),
+    month: p(r2.month),
+    day: p(r2.day)
+  };
+}
+function c(r2, t2) {
+  return new Date(r2 || 2001, t2 || 1, 0).getDate();
+}
+function b(r2) {
+  const { year: t2, month: i, day: s } = f(r2);
+  if (!t2 || t2 < 0 || t2 > 9999 || !i || i < 1 || i > 12 || !s || s < 1)
+    return;
+  const n = new Date(Date.UTC(t2, i - 1, s));
+  if (!(n.getUTCFullYear() !== t2 || n.getUTCMonth() !== i - 1 || n.getUTCDate() !== s))
+    return { year: t2, month: i, day: s };
+}
+function C(r2) {
+  const t2 = b(r2);
+  return t2 ? new Date(Date.UTC(t2.year, t2.month - 1, t2.day)) : undefined;
+}
+function T2(r2, t2, i, s) {
+  const n = i ? {
+    year: i.getUTCFullYear(),
+    month: i.getUTCMonth() + 1,
+    day: i.getUTCDate()
+  } : null, e = s ? {
+    year: s.getUTCFullYear(),
+    month: s.getUTCMonth() + 1,
+    day: s.getUTCDate()
+  } : null;
+  return r2 === "year" ? { min: n?.year ?? 1, max: e?.year ?? 9999 } : r2 === "month" ? {
+    min: n && t2.year === n.year ? n.month : 1,
+    max: e && t2.year === e.year ? e.month : 12
+  } : {
+    min: n && t2.year === n.year && t2.month === n.month ? n.day : 1,
+    max: e && t2.year === e.year && t2.month === e.month ? e.day : c(t2.year, t2.month)
+  };
+}
+
+class U extends V {
+  #i;
+  #o;
+  #t;
+  #h;
+  #u;
+  #e = { segmentIndex: 0, positionInSegment: 0 };
+  #n = true;
+  #s = null;
+  inlineError = "";
+  get segmentCursor() {
+    return { ...this.#e };
+  }
+  get segmentValues() {
+    return { ...this.#t };
+  }
+  get segments() {
+    return this.#i;
+  }
+  get separator() {
+    return this.#o;
+  }
+  get formattedValue() {
+    return this.#l(this.#t);
+  }
+  #l(t2) {
+    return this.#i.map((i) => t2[i.type]).join(this.#o);
+  }
+  #r() {
+    this._setUserInput(this.#l(this.#t)), this._setValue(C(this.#t) ?? undefined);
+  }
+  constructor(t2) {
+    const i = t2.format ? { segments: M(t2.format), separator: t2.separator ?? "/" } : P(t2.locale), s = t2.separator ?? i.separator, n = t2.format ? M(t2.format) : i.segments, e = t2.initialValue ?? t2.defaultValue, m2 = e ? {
+      year: String(e.getUTCFullYear()).padStart(4, "0"),
+      month: String(e.getUTCMonth() + 1).padStart(2, "0"),
+      day: String(e.getUTCDate()).padStart(2, "0")
+    } : { year: "____", month: "__", day: "__" }, o = n.map((a) => m2[a.type]).join(s);
+    super({ ...t2, initialUserInput: o }, false), this.#i = n, this.#o = s, this.#t = m2, this.#h = t2.minDate, this.#u = t2.maxDate, this.#r(), this.on("cursor", (a) => this.#f(a)), this.on("key", (a, u) => this.#y(a, u)), this.on("finalize", () => this.#p(t2));
+  }
+  #a() {
+    const t2 = Math.max(0, Math.min(this.#e.segmentIndex, this.#i.length - 1)), i = this.#i[t2];
+    if (i)
+      return this.#e.positionInSegment = Math.max(0, Math.min(this.#e.positionInSegment, i.len - 1)), { segment: i, index: t2 };
+  }
+  #m(t2) {
+    this.inlineError = "", this.#s = null;
+    const i = this.#a();
+    i && (this.#e.segmentIndex = Math.max(0, Math.min(this.#i.length - 1, i.index + t2)), this.#e.positionInSegment = 0, this.#n = true);
+  }
+  #d(t2) {
+    const i = this.#a();
+    if (!i)
+      return;
+    const { segment: s } = i, n = this.#t[s.type], e = !n || n.replace(/_/g, "") === "", m2 = Number.parseInt((n || "0").replace(/_/g, "0"), 10) || 0, o = T2(s.type, f(this.#t), this.#h, this.#u);
+    let a;
+    e ? a = t2 === 1 ? o.min : o.max : a = Math.max(Math.min(o.max, m2 + t2), o.min), this.#t = {
+      ...this.#t,
+      [s.type]: a.toString().padStart(s.len, "0")
+    }, this.#n = true, this.#s = null, this.#r();
+  }
+  #f(t2) {
+    if (t2)
+      switch (t2) {
+        case "right":
+          return this.#m(1);
+        case "left":
+          return this.#m(-1);
+        case "up":
+          return this.#d(1);
+        case "down":
+          return this.#d(-1);
+      }
+  }
+  #y(t2, i) {
+    if (i?.name === "backspace" || i?.sequence === "\x7F" || i?.sequence === "\b" || t2 === "\x7F" || t2 === "\b") {
+      this.inlineError = "";
+      const n = this.#a();
+      if (!n)
+        return;
+      if (!this.#t[n.segment.type].replace(/_/g, "")) {
+        this.#m(-1);
+        return;
+      }
+      this.#t[n.segment.type] = "_".repeat(n.segment.len), this.#n = true, this.#e.positionInSegment = 0, this.#r();
+      return;
+    }
+    if (i?.name === "tab") {
+      this.inlineError = "";
+      const n = this.#a();
+      if (!n)
+        return;
+      const e = i.shift ? -1 : 1, m2 = n.index + e;
+      m2 >= 0 && m2 < this.#i.length && (this.#e.segmentIndex = m2, this.#e.positionInSegment = 0, this.#n = true);
+      return;
+    }
+    if (t2 && /^[0-9]$/.test(t2)) {
+      const n = this.#a();
+      if (!n)
+        return;
+      const { segment: e } = n, m2 = !this.#t[e.type].replace(/_/g, "");
+      if (this.#n && this.#s !== null && !m2) {
+        const h = this.#s + t2, d = { ...this.#t, [e.type]: h }, g2 = this.#g(d, e);
+        if (g2) {
+          this.inlineError = g2, this.#s = null, this.#n = false;
+          return;
+        }
+        this.inlineError = "", this.#t[e.type] = h, this.#s = null, this.#n = false, this.#r(), n.index < this.#i.length - 1 && (this.#e.segmentIndex = n.index + 1, this.#e.positionInSegment = 0, this.#n = true);
+        return;
+      }
+      this.#n && !m2 && (this.#t[e.type] = "_".repeat(e.len), this.#e.positionInSegment = 0), this.#n = false, this.#s = null;
+      const o = this.#t[e.type], a = o.indexOf("_"), u = a >= 0 ? a : Math.min(this.#e.positionInSegment, e.len - 1);
+      if (u < 0 || u >= e.len)
+        return;
+      let l2 = o.slice(0, u) + t2 + o.slice(u + 1), D = false;
+      if (u === 0 && o === "__" && (e.type === "month" || e.type === "day")) {
+        const h = Number.parseInt(t2, 10);
+        l2 = `0${t2}`, D = h <= (e.type === "month" ? 1 : 2);
+      }
+      if (e.type === "year" && (l2 = (o.replace(/_/g, "") + t2).padStart(e.len, "_")), !l2.includes("_")) {
+        const h = { ...this.#t, [e.type]: l2 }, d = this.#g(h, e);
+        if (d) {
+          this.inlineError = d;
+          return;
+        }
+      }
+      this.inlineError = "", this.#t[e.type] = l2;
+      const y = l2.includes("_") ? undefined : b(this.#t);
+      if (y) {
+        const { year: h, month: d } = y, g2 = c(h, d);
+        this.#t = {
+          year: String(Math.max(0, Math.min(9999, h))).padStart(4, "0"),
+          month: String(Math.max(1, Math.min(12, d))).padStart(2, "0"),
+          day: String(Math.max(1, Math.min(g2, y.day))).padStart(2, "0")
+        };
+      }
+      this.#r();
+      const S = l2.indexOf("_");
+      D ? (this.#n = true, this.#s = t2) : S >= 0 ? this.#e.positionInSegment = S : a >= 0 && n.index < this.#i.length - 1 ? (this.#e.segmentIndex = n.index + 1, this.#e.positionInSegment = 0, this.#n = true) : this.#e.positionInSegment = Math.min(u + 1, e.len - 1);
+    }
+  }
+  #g(t2, i) {
+    const { month: s, day: n } = f(t2);
+    if (i.type === "month" && (s < 0 || s > 12))
+      return settings.date.messages.invalidMonth;
+    if (i.type === "day" && (n < 0 || n > 31))
+      return settings.date.messages.invalidDay(31, "any month");
+  }
+  #p(t2) {
+    const { year: i, month: s, day: n } = f(this.#t);
+    if (i && s && n) {
+      const e = c(i, s);
+      this.#t = {
+        ...this.#t,
+        day: String(Math.min(n, e)).padStart(2, "0")
+      };
+    }
+    this.value = C(this.#t) ?? t2.defaultValue ?? undefined;
+  }
+}
+var u$2 = class u extends V {
+  options;
+  cursor = 0;
+  #t;
+  getGroupItems(t2) {
+    return this.options.filter((r2) => r2.group === t2);
+  }
+  isGroupSelected(t2) {
+    const r2 = this.getGroupItems(t2), e = this.value;
+    return e === undefined ? false : r2.every((s) => e.includes(s.value));
+  }
+  toggleValue() {
+    const t2 = this.options[this.cursor];
+    if (t2 !== undefined)
+      if (this.value === undefined && (this.value = []), t2.group === true) {
+        const r2 = t2.value, e = this.getGroupItems(r2);
+        this.isGroupSelected(r2) ? this.value = this.value.filter((s) => e.findIndex((i) => i.value === s) === -1) : this.value = [...this.value, ...e.map((s) => s.value)], this.value = Array.from(new Set(this.value));
+      } else {
+        const r2 = this.value.includes(t2.value);
+        this.value = r2 ? this.value.filter((e) => e !== t2.value) : [...this.value, t2.value];
+      }
+  }
+  constructor(t2) {
+    super(t2, false);
+    const { options: r2 } = t2;
+    this.#t = t2.selectableGroups !== false, this.options = Object.entries(r2).flatMap(([e, s]) => [
+      { value: e, group: true, label: e },
+      ...s.map((i) => ({ ...i, group: e }))
+    ]), this.value = [...t2.initialValues ?? []], this.cursor = Math.max(this.options.findIndex(({ value: e }) => e === t2.cursorAt), this.#t ? 0 : 1), this.on("cursor", (e) => {
+      switch (e) {
+        case "left":
+        case "up": {
+          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+          const s = this.options[this.cursor]?.group === true;
+          !this.#t && s && (this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1);
+          break;
+        }
+        case "down":
+        case "right": {
+          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+          const s = this.options[this.cursor]?.group === true;
+          !this.#t && s && (this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1);
+          break;
+        }
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+};
+var o = /* @__PURE__ */ new Set(["up", "down", "left", "right"]);
+
+class h extends V {
+  #t = false;
+  #s;
+  focused = "editor";
+  get userInputWithCursor() {
+    if (this.state === "submit")
+      return this.userInput;
+    const t2 = this.userInput;
+    if (this.cursor >= t2.length)
+      return `${t2}\u2588`;
+    const s = t2.slice(0, this.cursor), r2 = t2.slice(this.cursor, this.cursor + 1), i = t2.slice(this.cursor + 1);
+    return r2 === `
+` ? `${s}\u2588
+${i}` : `${s}${styleText("inverse", r2)}${i}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  #r(t2) {
+    if (this.userInput.length === 0) {
+      this._setUserInput(t2);
+      return;
+    }
+    this._setUserInput(this.userInput.slice(0, this.cursor) + t2 + this.userInput.slice(this.cursor));
+  }
+  #i(t2) {
+    const s = this.value ?? "";
+    switch (t2) {
+      case "up":
+        this._cursor = findTextCursor(this._cursor, 0, -1, s);
+        return;
+      case "down":
+        this._cursor = findTextCursor(this._cursor, 0, 1, s);
+        return;
+      case "left":
+        this._cursor = findTextCursor(this._cursor, -1, 0, s);
+        return;
+      case "right":
+        this._cursor = findTextCursor(this._cursor, 1, 0, s);
+        return;
+    }
+  }
+  _shouldSubmit(t2, s) {
+    if (this.#s)
+      return this.focused === "submit" ? true : (this.#r(`
+`), this._cursor++, false);
+    const r2 = this.#t;
+    return this.#t = true, r2 && this.cursor === this.userInput.length ? (this.userInput[this.cursor - 1] === `
+` && (this._setUserInput(this.userInput.slice(0, this.cursor - 1) + this.userInput.slice(this.cursor)), this._cursor--), true) : (this.#r(`
+`), this._cursor++, false);
+  }
+  constructor(t2) {
+    const s = t2.initialUserInput ?? t2.initialValue;
+    super({
+      ...t2,
+      initialUserInput: s
+    }, false), s !== undefined && (this._cursor = s.length), this.#s = t2.showSubmit ?? false, this.on("key", (r2, i) => {
+      if (i?.name && o.has(i.name)) {
+        this.#t = false, this.#i(i.name);
+        return;
+      }
+      if (r2 === "\t" && this.#s) {
+        this.focused = this.focused === "editor" ? "submit" : "editor";
+        return;
+      }
+      if (i?.name !== "return") {
+        if (this.#t = false, i?.name === "backspace" && this.cursor > 0) {
+          this._setUserInput(this.userInput.slice(0, this.cursor - 1) + this.userInput.slice(this.cursor)), this._cursor--;
+          return;
+        }
+        if (i?.name === "delete" && this.cursor < this.userInput.length) {
+          this._setUserInput(this.userInput.slice(0, this.cursor) + this.userInput.slice(this.cursor + 1));
+          return;
+        }
+        r2 && (this.#s && this.focused === "submit" && (this.focused = "editor"), this.#r(r2 ?? ""), this._cursor++);
+      }
+    }), this.on("userInput", (r2) => {
+      this._setValue(r2);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t2.defaultValue), this.value === undefined && (this.value = "");
+    });
+  }
+}
+
+// ../../node_modules/.bun/@clack+prompts@1.7.0/node_modules/@clack/prompts/dist/index.mjs
+import { styleText as styleText2, stripVTControlCharacters } from "util";
+import process$1 from "process";
+var import_sisteransi2 = __toESM(require_src(), 1);
+function isUnicodeSupported() {
+  if (process$1.platform !== "win32") {
+    return process$1.env.TERM !== "linux";
+  }
+  return Boolean(process$1.env.CI) || Boolean(process$1.env.WT_SESSION) || Boolean(process$1.env.TERMINUS_SUBLIME) || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var unicode = isUnicodeSupported();
+var isCI = () => process.env.CI === "true";
+var unicodeOr = (o2, e) => unicode ? o2 : e;
+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 = (o2) => {
+  switch (o2) {
+    case "initial":
+    case "active":
+      return styleText2("cyan", S_STEP_ACTIVE);
+    case "cancel":
+      return styleText2("red", S_STEP_CANCEL);
+    case "error":
+      return styleText2("yellow", S_STEP_ERROR);
+    case "submit":
+      return styleText2("green", S_STEP_SUBMIT);
+  }
+};
+var confirm = (i) => {
+  const a2 = i.active ?? "Yes", s = i.inactive ?? "No";
+  return new r({
+    active: a2,
+    inactive: s,
+    signal: i.signal,
+    input: i.input,
+    output: i.output,
+    initialValue: i.initialValue ?? true,
+    render() {
+      const e = i.withGuide ?? settings.withGuide, u3 = `${symbol(this.state)}  `, l2 = e ? `${styleText2("gray", S_BAR)}  ` : "", f2 = wrapTextWithPrefix(i.output, i.message, l2, u3), o2 = `${e ? `${styleText2("gray", S_BAR)}
+` : ""}${f2}
+`, c2 = this.value ? a2 : s;
+      switch (this.state) {
+        case "submit": {
+          const r2 = e ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${o2}${r2}${styleText2("dim", c2)}`;
+        }
+        case "cancel": {
+          const r2 = e ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${o2}${r2}${styleText2(["strikethrough", "dim"], c2)}${e ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r2 = e ? `${styleText2("cyan", S_BAR)}  ` : "", g2 = e ? styleText2("cyan", S_BAR_END) : "";
+          return `${o2}${r2}${this.value ? `${styleText2("green", S_RADIO_ACTIVE)} ${a2}` : `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", a2)}`}${i.vertical ? e ? `
+${styleText2("cyan", S_BAR)}  ` : `
+` : ` ${styleText2("dim", "/")} `}${this.value ? `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", s)}` : `${styleText2("green", S_RADIO_ACTIVE)} ${s}`}
+${g2}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var MULTISELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "\u2191/\u2193")} to navigate`,
+  `${styleText2("dim", "Space:")} select`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var log = {
+  message: (s = [], {
+    symbol: e = styleText2("gray", S_BAR),
+    secondarySymbol: r2 = styleText2("gray", S_BAR),
+    output: m2 = process.stdout,
+    spacing: l2 = 1,
+    withGuide: c2
+  } = {}) => {
+    const t2 = [], o2 = c2 ?? settings.withGuide, f2 = o2 ? r2 : "", O = o2 ? `${e}  ` : "", u3 = o2 ? `${r2}  ` : "";
+    for (let i = 0;i < l2; i++)
+      t2.push(f2);
+    const g2 = Array.isArray(s) ? s : s.split(`
+`);
+    if (g2.length > 0) {
+      const [i, ...y] = g2;
+      i.length > 0 ? t2.push(`${O}${i}`) : t2.push(o2 ? e : "");
+      for (const p2 of y)
+        p2.length > 0 ? t2.push(`${u3}${p2}`) : t2.push(o2 ? r2 : "");
+    }
+    m2.write(`${t2.join(`
+`)}
+`);
+  },
+  info: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("blue", S_INFO) });
+  },
+  success: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("green", S_SUCCESS) });
+  },
+  step: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("green", S_STEP_SUBMIT) });
+  },
+  warn: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("yellow", S_WARN) });
+  },
+  warning: (s, e) => {
+    log.warn(s, e);
+  },
+  error: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("red", S_ERROR) });
+  }
+};
+var intro = (o2 = "", t2) => {
+  const i = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_START)}  ` : "";
+  i.write(`${e}${o2}
+`);
+};
+var outro = (o2 = "", t2) => {
+  const i = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR)}
+${styleText2("gray", S_BAR_END)}  ` : "";
+  i.write(`${e}${o2}
+
+`);
+};
+var W$1 = (o2) => o2;
+var C2 = (o2, e, s) => {
+  const a2 = {
+    hard: true,
+    trim: false
+  }, i = wrapAnsi(o2, e, a2).split(`
+`), c2 = i.reduce((n2, t2) => Math.max(dist_default2(t2), n2), 0), u3 = i.map(s).reduce((n2, t2) => Math.max(dist_default2(t2), n2), 0), g2 = e - (u3 - c2);
+  return wrapAnsi(o2, g2, a2);
+};
+var note = (o2 = "", e = "", s) => {
+  const a2 = s?.output ?? process$1.stdout, i = s?.withGuide ?? settings.withGuide, c2 = s?.format ?? W$1, g2 = ["", ...C2(o2, getColumns(a2) - 6, c2).split(`
+`).map(c2), ""], n2 = dist_default2(e), t2 = Math.max(g2.reduce((m2, F) => {
+    const O = dist_default2(F);
+    return O > m2 ? O : m2;
+  }, 0), n2) + 2, h2 = g2.map((m2) => `${styleText2("gray", S_BAR)}  ${m2}${" ".repeat(t2 - dist_default2(m2))}${styleText2("gray", S_BAR)}`).join(`
+`), T3 = i ? `${styleText2("gray", S_BAR)}
+` : "", l$1 = i ? S_CONNECT_LEFT : S_CORNER_BOTTOM_LEFT;
+  a2.write(`${T3}${styleText2("green", S_STEP_SUBMIT)}  ${styleText2("reset", e)} ${styleText2("gray", S_BAR_H.repeat(Math.max(t2 - n2 - 1, 1)) + S_CORNER_TOP_RIGHT)}
+${h2}
+${styleText2("gray", l$1 + S_BAR_H.repeat(t2 + 2) + S_CORNER_BOTTOM_RIGHT)}
+`);
+};
+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: m2,
+  ...I
+} = {}) => {
+  const u3 = isCI();
+  let M2, T3, d = false, S = false, s = "", p2, w = performance.now();
+  const x = getColumns(n2), k = I?.styleFrame ?? W, g2 = (e) => {
+    const r2 = e > 1 ? O ?? settings.messages.error : G ?? settings.messages.cancel;
+    S = e === 1, d && (a2(r2, e), S && typeof h2 == "function" && h2());
+  }, f2 = () => g2(2), i = () => g2(1), A = () => {
+    process.on("uncaughtExceptionMonitor", f2), process.on("unhandledRejection", f2), process.on("SIGINT", i), process.on("SIGTERM", i), process.on("exit", g2), m2 && m2.addEventListener("abort", i);
+  }, H = () => {
+    process.removeListener("uncaughtExceptionMonitor", f2), process.removeListener("unhandledRejection", f2), process.removeListener("SIGINT", i), process.removeListener("SIGTERM", i), process.removeListener("exit", g2), m2 && m2.removeEventListener("abort", i);
+  }, y = () => {
+    if (p2 === undefined)
+      return;
+    u3 && n2.write(`
+`);
+    const r2 = wrapAnsi(p2, x, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    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());
+  }, C3 = (e) => e.replace(/\.+$/, ""), _2 = (e) => {
+    const r2 = (performance.now() - e) / 1000, t2 = Math.floor(r2 / 60), o2 = Math.floor(r2 % 60);
+    return t2 > 0 ? `[${t2}m ${o2}s]` : `[${o2}s]`;
+  }, N = I.withGuide ?? settings.withGuide, P2 = (e = "") => {
+    d = true, M2 = block({ output: n2 }), s = C3(e), w = performance.now(), N && n2.write(`${styleText2("gray", S_BAR)}
+`);
+    let r2 = 0, t2 = 0;
+    A(), T3 = setInterval(() => {
+      if (u3 && s === p2)
+        return;
+      y(), p2 = s;
+      const o2 = k(E[r2]);
+      let v;
+      if (u3)
+        v = `${o2}  ${s}...`;
+      else if (l2 === "timer")
+        v = `${o2}  ${s} ${_2(w)}`;
+      else {
+        const B = ".".repeat(Math.floor(t2)).slice(0, 3);
+        v = `${o2}  ${s}${B}`;
+      }
+      const j = wrapAnsi(v, x, {
+        hard: true,
+        trim: false
+      });
+      n2.write(j), r2 = r2 + 1 < E.length ? r2 + 1 : 0, t2 = t2 < 4 ? t2 + 0.125 : 0;
+    }, F);
+  }, a2 = (e = "", r2 = 0, t2 = false) => {
+    if (!d)
+      return;
+    d = false, clearInterval(T3), y();
+    const o2 = r2 === 0 ? styleText2("green", S_STEP_SUBMIT) : r2 === 1 ? styleText2("red", S_STEP_CANCEL) : styleText2("red", S_STEP_ERROR);
+    s = e ?? s, t2 || (l2 === "timer" ? n2.write(`${o2}  ${s} ${_2(w)}
+`) : n2.write(`${o2}  ${s}
+`)), H(), M2();
+  };
+  return {
+    start: P2,
+    stop: (e = "") => a2(e, 0),
+    message: (e = "") => {
+      s = C3(e ?? s);
+    },
+    cancel: (e = "") => a2(e, 1),
+    error: (e = "") => a2(e, 2),
+    clear: () => a2("", 0, true),
+    get isCancelled() {
+      return S;
+    }
+  };
+};
+var u3 = {
+  light: unicodeOr("\u2500", "-"),
+  heavy: unicodeOr("\u2501", "="),
+  block: unicodeOr("\u2588", "#")
+};
+var SELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "\u2191/\u2193")} to navigate`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var i = `${styleText2("gray", S_BAR)}  `;
+
+// src/commands/drop.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+async function runDrop(config2, opts = {}) {
+  intro(import_picocolors.default.bgCyan(import_picocolors.default.black(" @bungres/kit drop ")));
+  const s = spinner();
+  s.start("Loading schemas...");
+  const schemas2 = await loadSchemas(config2.schema);
+  if (schemas2.length === 0) {
+    s.stop("No schemas found.");
+    log.warn(import_picocolors.default.yellow("No table definitions found in schema files."));
+    outro("Failed.");
+    return;
+  }
+  s.stop(`Loaded ${schemas2.length} schemas.`);
+  const ms = spinner();
+  ms.start("Checking database tables...");
+  const sql2 = new Bun.SQL(config2.dbUrl);
+  try {
+    const userSchema = config2.dbSchema;
+    const existingUserTablesResult = await sql2.unsafe(`SELECT table_name FROM information_schema.tables WHERE table_schema = $1`, [userSchema]);
+    const existingTableNames = new Set(existingUserTablesResult.map((r2) => r2.table_name));
+    const migTableCheck = await sql2.unsafe(`SELECT EXISTS (
+        SELECT 1 FROM information_schema.tables
+        WHERE table_schema = $1 AND table_name = $2
+      ) AS exists`, [config2.migrationsSchema, config2.migrationsTable]);
+    const migrationTableExists = migTableCheck[0]?.exists ?? false;
+    const pushTableCheck = await sql2.unsafe(`SELECT EXISTS (
+        SELECT 1 FROM information_schema.tables
+        WHERE table_schema = $1 AND table_name = $2
+      ) AS exists`, [config2.migrationsSchema, "__bungres_push"]);
+    const pushTableExists = pushTableCheck[0]?.exists ?? false;
+    const tablesToDrop = schemas2.filter((sch) => existingTableNames.has(sch.config.name));
+    if (tablesToDrop.length === 0 && !migrationTableExists && !pushTableExists) {
+      ms.stop("Nothing to do.");
+      log.success(import_picocolors.default.green("No tables to drop (they either don't exist or were already dropped)."));
+      outro("Done.");
+      return;
+    }
+    ms.stop("Database check complete.");
+    const tableNamesToPrint = tablesToDrop.map((sch) => (sch.config.schema ? sch.config.schema + "." : "") + sch.config.name);
+    if (migrationTableExists) {
+      tableNamesToPrint.push(`${config2.migrationsSchema}.${config2.migrationsTable}`);
+    }
+    if (pushTableExists) {
+      tableNamesToPrint.push(`${config2.migrationsSchema}.__bungres_push`);
+    }
+    if (!opts.force) {
+      log.warn(import_picocolors.default.bgRed(import_picocolors.default.white(" \u26A0\uFE0F WARNING ")));
+      log.message(import_picocolors.default.bold(import_picocolors.default.red("This will drop the following tables and ALL their data:")));
+      for (const name of tableNamesToPrint) {
+        log.info(import_picocolors.default.yellow(`  - ${name}`));
+      }
+      const confirm2 = await confirm({
+        message: "Are you sure you want to proceed?",
+        initialValue: false
+      });
+      if (isCancel(confirm2) || !confirm2) {
+        outro(import_picocolors.default.gray("Drop aborted."));
+        return;
+      }
+    }
+    const exSpinner = spinner();
+    exSpinner.start("Dropping tables...");
+    for (const entry of tablesToDrop) {
+      const ddl = `DROP TABLE IF EXISTS "${entry.config.name}" CASCADE;`;
+      await sql2.unsafe(ddl);
+      log.step(import_picocolors.default.gray(`Dropped ${entry.config.name}`));
+    }
+    if (migrationTableExists) {
+      const qualifiedMigTable = `"${config2.migrationsSchema}"."${config2.migrationsTable}"`;
+      await sql2.unsafe(`DROP TABLE IF EXISTS ${qualifiedMigTable} CASCADE`);
+      log.step(import_picocolors.default.gray(`Dropped ${config2.migrationsSchema}.${config2.migrationsTable}`));
+    }
+    if (pushTableExists) {
+      await sql2.unsafe(`DROP TABLE IF EXISTS "${config2.migrationsSchema}"."__bungres_push" CASCADE`);
+      log.step(import_picocolors.default.gray(`Dropped ${config2.migrationsSchema}.__bungres_push`));
+    }
+    exSpinner.stop("Tables dropped.");
+    outro(import_picocolors.default.cyan("\u2728 Drop complete."));
+  } catch (err) {
+    log.error(import_picocolors.default.red(`Drop failed: ${err.message}`));
+    outro("Failed.");
+  } finally {
+    await sql2.end();
+  }
+}
+
+// src/commands/migrate.ts
+import { join as join2, resolve as resolve2 } from "path";
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+async function runMigrate(config2) {
+  intro(import_picocolors2.default.bgCyan(import_picocolors2.default.black(" @bungres/kit migrate ")));
+  const migrationsDir = resolve2(config2.out);
+  const sql2 = new Bun.SQL(config2.dbUrl);
+  const table2 = config2.migrationsTable;
+  const schema = config2.migrationsSchema;
+  const qualifiedTable = `"${schema}"."${table2}"`;
+  const createSchema = `CREATE SCHEMA IF NOT EXISTS "${schema}";`;
+  const createMigrationsTable = `
+CREATE TABLE IF NOT EXISTS ${qualifiedTable} (
+  id          SERIAL PRIMARY KEY,
+  name        TEXT NOT NULL UNIQUE,
+  applied_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);`.trim();
+  const s = spinner();
+  s.start("Checking pending migrations...");
+  try {
+    await sql2.unsafe(createSchema);
+    await sql2.unsafe(createMigrationsTable);
+    const glob = new Bun.Glob("*.sql");
+    const files = [];
+    for await (const file of glob.scan({ cwd: migrationsDir, absolute: false })) {
+      files.push(file);
+    }
+    files.sort();
+    if (files.length === 0) {
+      s.stop("No files found.");
+      log.warn(import_picocolors2.default.yellow(`No migration files found in ${migrationsDir}`));
+      log.info(`Run ${import_picocolors2.default.green("bungres generate")} first.`);
+      outro("Done.");
+      return;
+    }
+    const applied = await sql2.unsafe(`SELECT name FROM ${qualifiedTable}`);
+    const appliedSet = new Set(applied.map((r2) => r2.name));
+    const pending = files.filter((f2) => !appliedSet.has(f2));
+    if (pending.length === 0) {
+      s.stop("Up to date.");
+      log.success(import_picocolors2.default.green("Everything is up to date."));
+      outro("Done.");
+      return;
+    }
+    s.stop(`Found ${pending.length} pending migration(s).`);
+    for (const file of pending) {
+      const ms = spinner();
+      ms.start(`Applying ${file}...`);
+      const content = await Bun.file(join2(migrationsDir, file)).text();
+      let upContent = content;
+      const upMatch = content.match(/-- ==== UP ====([\s\S]*?)(?:-- ==== DOWN ====|$)/i);
+      if (upMatch) {
+        upContent = upMatch[1].trim();
+      }
+      if (config2.verbose) {
+        log.info(import_picocolors2.default.gray(`-- ${file} --
+${upContent}
+`));
+      }
+      await sql2.transaction(async (txSql) => {
+        const statements = config2.breakpoints ? upContent.split(/-->statement-breakpoint/g).flatMap((chunk) => chunk.split(";").map((s2) => s2.trim()).filter(Boolean)) : upContent.split(";").map((s2) => s2.trim()).filter(Boolean);
+        for (const stmt of statements) {
+          await txSql.unsafe(stmt + ";");
+        }
+        await txSql.unsafe(`INSERT INTO ${qualifiedTable} (name) VALUES ($1)`, [file]);
+      });
+      ms.stop(import_picocolors2.default.green(`\u2713 Applied ${file}`));
+    }
+    outro(import_picocolors2.default.cyan("\u2728 All migrations applied successfully."));
+  } catch (err) {
+    log.error(import_picocolors2.default.red(`Migration failed: ${err.message}`));
+    outro("Failed.");
+  } finally {
+    await sql2.end();
+  }
+}
+
+// src/commands/fresh.ts
+async function runFresh(config2) {
+  console.log("Dropping all tables...");
+  await runDrop(config2, { force: true });
+  console.log(`
+Re-running migrations...`);
+  await runMigrate(config2);
+  console.log(`
+Fresh complete.`);
+}
+
+// src/commands/generate.ts
+import { join as join3, resolve as resolve3 } from "path";
+import { readdirSync } from "fs";
+
+// src/differ.ts
+function diffSchemas(prev, next) {
+  const statements = [];
+  const summary = [];
+  const warnings = [];
+  const prevTables = new Set(Object.keys(prev));
+  const nextTables = new Set(Object.keys(next));
+  const newTableConfigs = [];
+  for (const tableName of nextTables) {
+    if (!prevTables.has(tableName)) {
+      newTableConfigs.push(next[tableName]);
+    }
+  }
+  for (const config2 of topoSortConfigs(newTableConfigs)) {
+    statements.push(generateCreateTable(config2, true));
+    summary.push(`CREATE TABLE ${config2.name}`);
+  }
+  for (const tableName of prevTables) {
+    if (!nextTables.has(tableName)) {
+      const config2 = prev[tableName];
+      const tbl = config2.schema ? `"${config2.schema}"."${tableName}"` : `"${tableName}"`;
+      statements.push(`DROP TABLE IF EXISTS ${tbl};`);
+      summary.push(`DROP TABLE ${tableName}`);
+      warnings.push(`Data loss warning: Table '${tableName}' will be permanently deleted.`);
+    }
+  }
+  for (const tableName of nextTables) {
+    if (!prevTables.has(tableName))
+      continue;
+    const prevConfig = prev[tableName];
+    const nextConfig = next[tableName];
+    const prevCols = prevConfig.columns;
+    const nextCols = nextConfig.columns;
+    const prevColNames = new Set(Object.keys(prevCols));
+    const nextColNames = new Set(Object.keys(nextCols));
+    for (const key of nextColNames) {
+      if (!prevColNames.has(key)) {
+        const col2 = nextCols[key];
+        statements.push(generateAddColumn(tableName, nextConfig.schema, key, col2));
+        summary.push(`ALTER TABLE ${tableName} ADD COLUMN ${col2.name}`);
+      }
+    }
+    for (const key of prevColNames) {
+      if (!nextColNames.has(key)) {
         const col2 = prevCols[key];
         statements.push(generateDropColumn(tableName, prevConfig.schema, col2.name));
         summary.push(`ALTER TABLE ${tableName} DROP COLUMN ${col2.name}`);
@@ -1594,20 +3139,20 @@ function diffSchemas(prev, next) {
         }
       }
     }
-    const prevIdxNames = new Set((prevConfig.indexes ?? []).map((i) => i.name ?? `idx_${tableName}_${i.columns.join("_")}`));
+    const prevIdxNames = new Set((prevConfig.indexes ?? []).map((i2) => i2.name ?? `idx_${tableName}_${i2.columns.join("_")}`));
     for (const idx of nextConfig.indexes ?? []) {
       const idxName = idx.name ?? `idx_${tableName}_${idx.columns.join("_")}`;
       if (!prevIdxNames.has(idxName)) {
         const tbl = nextConfig.schema ? `"${nextConfig.schema}"."${tableName}"` : `"${tableName}"`;
         const unique2 = idx.unique ? "UNIQUE " : "";
         const using = idx.using ? ` USING ${idx.using.toUpperCase()}` : "";
-        const cols = idx.columns.map((c) => `"${c}"`).join(", ");
+        const cols = idx.columns.map((c2) => `"${c2}"`).join(", ");
         const where = idx.where ? ` WHERE ${idx.where}` : "";
         statements.push(`CREATE ${unique2}INDEX IF NOT EXISTS "${idxName}" ON ${tbl}${using} (${cols})${where};`);
         summary.push(`CREATE INDEX ${idxName} ON ${tableName}`);
       }
     }
-    const nextIdxNames = new Set((nextConfig.indexes ?? []).map((i) => i.name ?? `idx_${tableName}_${i.columns.join("_")}`));
+    const nextIdxNames = new Set((nextConfig.indexes ?? []).map((i2) => i2.name ?? `idx_${tableName}_${i2.columns.join("_")}`));
     for (const idx of prevConfig.indexes ?? []) {
       const idxName = idx.name ?? `idx_${tableName}_${idx.columns.join("_")}`;
       if (!nextIdxNames.has(idxName)) {
@@ -1619,11 +3164,11 @@ function diffSchemas(prev, next) {
   return { statements, summary, warnings };
 }
 function topoSortConfigs(tables) {
-  const byName = new Map(tables.map((t) => [t.name, t]));
+  const byName = new Map(tables.map((t2) => [t2.name, t2]));
   const visited = new Set;
   const result2 = [];
   function deps(config2) {
-    return Object.values(config2.columns).map((col2) => col2.references?.table).filter((t) => t !== undefined && byName.has(t) && t !== config2.name);
+    return Object.values(config2.columns).map((col2) => col2.references?.table).filter((t2) => t2 !== undefined && byName.has(t2) && t2 !== config2.name);
   }
   function visit(name) {
     if (visited.has(name))
@@ -1688,21 +3233,40 @@ function formatDefault(value, dataType) {
 }
 
 // src/commands/generate.ts
-var SNAPSHOT_FILE = ".snapshot.json";
+var import_picocolors3 = __toESM(require_picocolors(), 1);
 async function runGenerate(config2, name) {
-  console.log("@bungres/kit generate: loading schemas...");
+  intro(import_picocolors3.default.bgCyan(import_picocolors3.default.black(" @bungres/kit generate ")));
+  const s = spinner();
+  s.start("Loading schemas...");
   const schemas2 = await loadSchemas(config2.schema);
   if (schemas2.length === 0) {
-    console.warn(colorize("No table definitions found. Check your schema glob pattern.", "yellow"));
+    s.stop("No table definitions found.");
+    log.warn(import_picocolors3.default.yellow("Check your schema glob pattern."));
+    outro("Failed.");
     return;
   }
+  s.stop(`Loaded ${schemas2.length} schemas.`);
   const migrationsDir = resolve3(config2.out);
+  const metaDir = join3(migrationsDir, "meta");
   await Bun.$`mkdir -p ${migrationsDir}`.quiet();
-  const currentSnapshot = Object.fromEntries(schemas2.map((s) => [s.config.name, s.config]));
-  const snapshotPath = join3(migrationsDir, SNAPSHOT_FILE);
-  const snapshotFile = Bun.file(snapshotPath);
-  const isFirstMigration = !await snapshotFile.exists();
-  const prevSnapshot = isFirstMigration ? {} : JSON.parse(await snapshotFile.text());
+  await Bun.$`mkdir -p ${metaDir}`.quiet();
+  const currentSnapshot = Object.fromEntries(schemas2.map((s2) => [s2.config.name, s2.config]));
+  let prevSnapshot = {};
+  let isFirstMigration = true;
+  try {
+    const files = readdirSync(metaDir).filter((f2) => f2.endsWith("_snapshot.json")).sort();
+    if (files.length > 0) {
+      const latest = files[files.length - 1];
+      prevSnapshot = JSON.parse(await Bun.file(join3(metaDir, latest)).text());
+      isFirstMigration = false;
+    } else {
+      const legacyFile2 = Bun.file(join3(migrationsDir, ".snapshot.json"));
+      if (await legacyFile2.exists()) {
+        prevSnapshot = JSON.parse(await legacyFile2.text());
+        isFirstMigration = false;
+      }
+    }
+  } catch (e) {}
   const now = new Date;
   const yyyy = now.getUTCFullYear();
   const mm = String(now.getUTCMonth() + 1).padStart(2, "0");
@@ -1713,60 +3277,86 @@ async function runGenerate(config2, name) {
   const prefix = `${yyyy}_${mm}_${dd}_${HH}${MM}${SS}`;
   const filename = name ? `${prefix}_${name}.sql` : `${prefix}.sql`;
   const outPath = join3(migrationsDir, filename);
-  let statements;
+  let upStatements;
+  let downStatements;
   let summary;
   let warnings = [];
   if (isFirstMigration) {
     const sorted = topoSort(schemas2);
-    statements = [
-      ...sorted.flatMap((entry) => [
-        `-- ${entry.exportName}`,
-        generateCreateTable(entry.config, true),
-        ``
-      ])
-    ];
-    summary = sorted.map((s) => `CREATE TABLE ${s.config.name}`);
+    upStatements = sorted.flatMap((entry) => [
+      `-- ${entry.exportName}`,
+      generateCreateTable(entry.config, true),
+      ``
+    ]);
+    downStatements = [...sorted].reverse().flatMap((entry) => {
+      const tbl = entry.config.schema ? `"${entry.config.schema}"."${entry.config.name}"` : `"${entry.config.name}"`;
+      return [`DROP TABLE IF EXISTS ${tbl};`];
+    });
+    summary = sorted.map((s2) => `CREATE TABLE ${s2.config.name}`);
   } else {
-    const diff = diffSchemas(prevSnapshot, currentSnapshot);
-    if (diff.statements.length === 0) {
-      console.log(colorize(`
-No schema changes detected. Nothing to generate.`, "yellow"));
+    const upDiff = diffSchemas(prevSnapshot, currentSnapshot);
+    if (upDiff.statements.length === 0) {
+      log.warn(import_picocolors3.default.yellow("No schema changes detected. Nothing to generate."));
+      outro("Done.");
       return;
     }
-    statements = diff.statements;
-    summary = diff.summary;
-    warnings = diff.warnings;
+    upStatements = upDiff.statements;
+    summary = upDiff.summary;
+    warnings = upDiff.warnings;
+    const downDiff = diffSchemas(currentSnapshot, prevSnapshot);
+    downStatements = downDiff.statements;
+  }
+  log.message(import_picocolors3.default.bold("Schema changes detected:"));
+  for (const s2 of summary) {
+    if (s2.startsWith("CREATE") || s2.startsWith("ALTER TABLE") && s2.includes("ADD")) {
+      log.success(import_picocolors3.default.green(`  + ${s2}`));
+    } else if (s2.startsWith("DROP") || s2.startsWith("ALTER TABLE") && s2.includes("DROP")) {
+      log.error(import_picocolors3.default.red(`  - ${s2}`));
+    } else {
+      log.info(import_picocolors3.default.blue(`  ~ ${s2}`));
+    }
   }
+  if (warnings.length > 0) {
+    log.warn(import_picocolors3.default.bgRed(import_picocolors3.default.white(" \u26A0\uFE0F DATA LOSS DETECTED ")));
+    for (const w of warnings)
+      log.warn(import_picocolors3.default.red(`  ! ${w}`));
+  }
+  const shouldGenerate = await confirm({
+    message: "Generate this migration?",
+    initialValue: true
+  });
+  if (isCancel(shouldGenerate) || !shouldGenerate) {
+    outro(import_picocolors3.default.gray("Generation cancelled."));
+    return;
+  }
+  s.start("Writing files...");
   const lines = [
     `-- Migration: ${filename}`,
     `-- Generated by @bungres/kit at ${new Date().toISOString()}`,
     `-- Changes: ${summary.join(", ")}`,
     ``,
-    ...statements
+    `-- ==== UP ====`,
+    ...upStatements,
+    ``,
+    `-- ==== DOWN ====`,
+    ...downStatements,
+    ``
   ];
   await Bun.write(outPath, lines.join(`
 `));
-  await Bun.write(snapshotPath, JSON.stringify(currentSnapshot, null, 2));
-  console.log(colorize(`
-Generated: ${outPath}`, "green"));
-  console.log(`  Changes:`);
-  for (const s of summary)
-    console.log(colorize(`    + ${s}`, "cyan"));
-  if (warnings.length > 0) {
-    console.warn(colorize(`
-  \u26A0\uFE0F  WARNING: Data Loss Detected!`, "red"));
-    for (const w of warnings)
-      console.warn(colorize(`    ! ${w}`, "red"));
-    console.warn(colorize(`  Please review the generated migration carefully before applying it.
-`, "yellow"));
-  }
-  console.log(colorize(`
-Run \`bungres migrate\` to apply it.`, "cyan"));
+  const metaPath = join3(metaDir, `${prefix}_snapshot.json`);
+  await Bun.write(metaPath, JSON.stringify(currentSnapshot, null, 2));
+  const legacyFile = Bun.file(join3(migrationsDir, ".snapshot.json"));
+  if (await legacyFile.exists()) {
+    await Bun.$`rm ${legacyFile.name}`.quiet();
+  }
+  s.stop(`Generated ${import_picocolors3.default.cyan(filename)}`);
+  outro(`Run ${import_picocolors3.default.green("bungres migrate")} to apply it.`);
 }
 function topoSort(schemas2) {
   const byName = new Map(schemas2.map((s) => [s.config.name, s]));
   function deps(config2) {
-    return Object.values(config2.columns).map((col2) => col2.references?.table).filter((t) => t !== undefined && byName.has(t) && t !== config2.name);
+    return Object.values(config2.columns).map((col2) => col2.references?.table).filter((t2) => t2 !== undefined && byName.has(t2) && t2 !== config2.name);
   }
   const visited = new Set;
   const result2 = [];
@@ -1790,18 +3380,25 @@ function topoSort(schemas2) {
 import { existsSync } from "fs";
 import { mkdir } from "fs/promises";
 import { join as join4 } from "path";
+var import_picocolors4 = __toESM(require_picocolors(), 1);
 async function runInit(cwd = process.cwd()) {
+  intro(import_picocolors4.default.bgCyan(import_picocolors4.default.black(" @bungres/kit init ")));
   const configPath = join4(cwd, "bungres.config.ts");
   const dbDir = join4(cwd, "src", "db");
   if (existsSync(configPath)) {
-    console.log("Config file already exists at bungres.config.ts");
+    log.warn(import_picocolors4.default.yellow("Config file already exists at bungres.config.ts"));
+    outro("Failed.");
     return;
   }
+  const s = spinner();
+  s.start("Creating project structure...");
   try {
     await mkdir(dbDir, { recursive: true });
-    console.log("Created src/db directory");
+    log.step(`Created ${import_picocolors4.default.cyan("src/db")} directory`);
   } catch (e) {
-    console.error("Failed to create src/db directory:", e);
+    s.stop("Failed");
+    log.error(`Failed to create src/db directory: ${e}`);
+    outro("Failed.");
     return;
   }
   const configContent = `import { defineConfig } from "@bungres/kit";
@@ -1816,9 +3413,11 @@ export default defineConfig({
 `;
   try {
     await Bun.write(configPath, configContent);
-    console.log("Created bungres.config.ts");
+    log.step(`Created ${import_picocolors4.default.cyan("bungres.config.ts")}`);
   } catch (e) {
-    console.error("Failed to create config file:", e);
+    s.stop("Failed");
+    log.error(`Failed to create config file: ${e}`);
+    outro("Failed.");
     return;
   }
   const schemaContent = `import {
@@ -1842,9 +3441,9 @@ export const users = table("users", {
 `;
   try {
     await Bun.write(join4(dbDir, "schema.ts"), schemaContent);
-    console.log("Created src/db/schema.ts with example table");
+    log.step(`Created ${import_picocolors4.default.cyan("src/db/schema.ts")} with example table`);
   } catch (e) {
-    console.error("Failed to create schema file:", e);
+    log.error(`Failed to create schema file: ${e}`);
   }
   const clientContent = `import { bungres } from "@bungres/orm";
 import * as schema from "./schema";
@@ -1855,18 +3454,17 @@ export const db = bungres({ url, schema });
 `;
   try {
     await Bun.write(join4(dbDir, "client.ts"), clientContent);
-    console.log("Created src/db/client.ts");
+    log.step(`Created ${import_picocolors4.default.cyan("src/db/client.ts")}`);
   } catch (e) {
-    console.error("Failed to create client file:", e);
-  }
-  console.log(`
-\u2728 Bungres project initialized!`);
-  console.log(`
-Next steps:`);
-  console.log("  1. Set DATABASE_URL in your .env file");
-  console.log("  2. Edit src/db/schema.ts to define your tables");
-  console.log("  3. Run 'bungres generate' to create migrations");
-  console.log("  4. Run 'bungres migrate' to apply migrations");
+    log.error(`Failed to create client file: ${e}`);
+  }
+  s.stop("Project initialized.");
+  const nextSteps = `1. Set DATABASE_URL in your .env file
+2. Edit src/db/schema.ts to define your tables
+3. Run ${import_picocolors4.default.green("bungres generate")} to create migrations
+4. Run ${import_picocolors4.default.green("bungres migrate")} to apply migrations`;
+  note(nextSteps, "Next steps");
+  outro(import_picocolors4.default.cyan("\u2728 Bungres project initialized!"));
 }
 
 // src/commands/pull.ts
@@ -1936,13 +3534,13 @@ function groupByTable(columns2, constraints, indexes) {
       map.set(col2.table_name, {
         tableName: col2.table_name,
         columns: [],
-        indexes: indexes.filter((i) => i.tablename === col2.table_name)
+        indexes: indexes.filter((i2) => i2.tablename === col2.table_name)
       });
     }
-    const tableConstraints = constraints.filter((c) => c.table_name === col2.table_name && c.column_name === col2.column_name);
-    const pkConstraint = tableConstraints.find((c) => c.constraint_type === "PRIMARY KEY");
-    const uniqueConstraint = tableConstraints.find((c) => c.constraint_type === "UNIQUE");
-    const fkConstraint = tableConstraints.find((c) => c.constraint_type === "FOREIGN KEY");
+    const tableConstraints = constraints.filter((c2) => c2.table_name === col2.table_name && c2.column_name === col2.column_name);
+    const pkConstraint = tableConstraints.find((c2) => c2.constraint_type === "PRIMARY KEY");
+    const uniqueConstraint = tableConstraints.find((c2) => c2.constraint_type === "UNIQUE");
+    const fkConstraint = tableConstraints.find((c2) => c2.constraint_type === "FOREIGN KEY");
     map.get(col2.table_name).columns.push({
       name: col2.column_name,
       dataType: col2.data_type,
@@ -1991,19 +3589,19 @@ function generateSchemaTS(tableMap, dbSchema) {
     if (table2.indexes.length > 0) {
       const idxLines = [];
       for (const idx of table2.indexes) {
-        const m = idx.indexdef.match(/CREATE (UNIQUE )?INDEX (.+) ON (.+) USING (\w+) \((.+)\)(?: WHERE (.+))?/i);
-        if (m) {
-          const isUnique = !!m[1];
-          const name = m[2].trim().replace(/^"|"$/g, "");
+        const m2 = idx.indexdef.match(/CREATE (UNIQUE )?INDEX (.+) ON (.+) USING (\w+) \((.+)\)(?: WHERE (.+))?/i);
+        if (m2) {
+          const isUnique = !!m2[1];
+          const name = m2[2].trim().replace(/^"|"$/g, "");
           if (name.endsWith("_pkey") || name.endsWith("_key"))
             continue;
-          const using = m[4].toLowerCase();
-          const cols = m[5].split(",").map((c) => `"${c.trim().replace(/^"|"$/g, "")}"`);
+          const using = m2[4].toLowerCase();
+          const cols = m2[5].split(",").map((c2) => `"${c2.trim().replace(/^"|"$/g, "")}"`);
           let idxStr = `{ name: "${name}", columns: [${cols.join(", ")}], using: "${using}"`;
           if (isUnique)
             idxStr += `, unique: true`;
-          if (m[6])
-            idxStr += `, where: \`${m[6].trim()}\``;
+          if (m2[6])
+            idxStr += `, where: \`${m2[6].trim()}\``;
           idxStr += ` }`;
           idxLines.push(idxStr);
         }
@@ -2122,19 +3720,26 @@ function pgTypeToBungresBuilderName(col2) {
   return "text";
 }
 function toCamelCase(str) {
-  return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+  return str.replace(/_([a-z])/g, (_2, c2) => c2.toUpperCase());
 }
 
 // src/commands/push.ts
-import * as fs from "fs";
+var import_picocolors5 = __toESM(require_picocolors(), 1);
 async function runPush(config2, opts = {}) {
-  console.log("@bungres/kit push: loading schemas...");
+  intro(import_picocolors5.default.bgCyan(import_picocolors5.default.black(" @bungres/kit push ")));
+  const s = spinner();
+  s.start("Loading schemas...");
   const schemas2 = await loadSchemas(config2.schema);
   if (schemas2.length === 0) {
-    console.warn("No table definitions found. Check your schema glob pattern.");
+    s.stop("No schemas found.");
+    log.warn(import_picocolors5.default.yellow("No table definitions found. Check your schema glob pattern."));
+    outro("Failed.");
     return;
   }
+  s.stop(`Loaded ${schemas2.length} schemas.`);
   const sql2 = new Bun.SQL(config2.dbUrl);
+  const ms = spinner();
+  ms.start("Computing diff from database...");
   try {
     await sql2.unsafe(`CREATE SCHEMA IF NOT EXISTS "${config2.migrationsSchema}";`);
     const qualifiedPush = `"${config2.migrationsSchema}"."__bungres_push"`;
@@ -2149,56 +3754,62 @@ async function runPush(config2, opts = {}) {
     if (rows.length > 0) {
       prevSnapshot = typeof rows[0].snapshot === "string" ? JSON.parse(rows[0].snapshot) : rows[0].snapshot;
     }
-    const currentSnapshot = Object.fromEntries(schemas2.map((s) => [s.config.name, s.config]));
+    const currentSnapshot = Object.fromEntries(schemas2.map((schemaEntry) => [schemaEntry.config.name, schemaEntry.config]));
     const diff = diffSchemas(prevSnapshot, currentSnapshot);
     if (diff.statements.length === 0) {
-      console.log(`
-No schema changes detected. Database is up to date.`);
+      ms.stop("Up to date.");
+      log.success(import_picocolors5.default.green("No schema changes detected. Database is up to date."));
+      outro("Done.");
       return;
     }
-    console.log(`
-Changes to apply:`);
-    for (const s of diff.summary)
-      console.log(`  + ${s}`);
+    ms.stop(`Computed ${diff.statements.length} statements.`);
+    log.message(import_picocolors5.default.bold("Changes to apply:"));
+    for (const change of diff.summary) {
+      if (change.startsWith("CREATE") || change.startsWith("ALTER TABLE") && change.includes("ADD")) {
+        log.success(import_picocolors5.default.green(`  + ${change}`));
+      } else if (change.startsWith("DROP") || change.startsWith("ALTER TABLE") && change.includes("DROP")) {
+        log.error(import_picocolors5.default.red(`  - ${change}`));
+      } else {
+        log.info(import_picocolors5.default.blue(`  ~ ${change}`));
+      }
+    }
     if (diff.warnings && diff.warnings.length > 0) {
-      console.warn(`
-  \u26A0\uFE0F  WARNING: Data Loss Detected!`);
+      log.warn(import_picocolors5.default.bgRed(import_picocolors5.default.white(" \u26A0\uFE0F DATA LOSS DETECTED ")));
       for (const w of diff.warnings)
-        console.warn(`    ! ${w}`);
-      console.warn(`
-  These changes will be immediately executed against the database!`);
+        log.warn(import_picocolors5.default.red(`  ! ${w}`));
+      log.warn(import_picocolors5.default.yellow("These changes will be immediately executed against the database!"));
     }
     if (!opts.force) {
-      process.stdout.write(`
-Are you sure you want to push these changes? Type YES to continue: `);
-      const answer = await readLine();
-      if (answer.trim().toLowerCase() !== "yes") {
-        console.log("Aborted.");
+      const confirm2 = await confirm({
+        message: "Are you sure you want to push these changes?",
+        initialValue: true
+      });
+      if (isCancel(confirm2) || !confirm2) {
+        outro(import_picocolors5.default.gray("Push aborted."));
         return;
       }
     }
-    console.log(`
-Pushing changes...`);
+    const exSpinner = spinner();
+    exSpinner.start("Pushing changes...");
     for (const stmt of diff.statements) {
       if (config2.verbose) {
-        console.log(`-- ${stmt}`);
+        log.info(import_picocolors5.default.gray(`-- ${stmt}`));
       }
       await sql2.unsafe(stmt);
     }
     await sql2.unsafe(`INSERT INTO ${qualifiedPush} (snapshot) VALUES ($1);`, [JSON.stringify(currentSnapshot)]);
-    console.log(`
-Push complete.`);
+    exSpinner.stop(import_picocolors5.default.green("Changes applied successfully."));
+    outro(import_picocolors5.default.cyan("\u2728 Push complete."));
+  } catch (err) {
+    log.error(import_picocolors5.default.red(`Push failed: ${err.message}`));
+    outro("Failed.");
   } finally {
     await sql2.end();
   }
 }
-async function readLine() {
-  const buf = Buffer.alloc(256);
-  const n = fs.readSync(0, buf, 0, 256, null);
-  return buf.subarray(0, n).toString().trim();
-}
 
 // src/commands/refresh.ts
+var import_picocolors6 = __toESM(require_picocolors(), 1);
 async function runRefresh(config2) {
   const schemas2 = await loadSchemas(config2.schema);
   if (schemas2.length === 0) {
@@ -2212,55 +3823,210 @@ async function runRefresh(config2) {
     for (const entry of schemas2) {
       const ddl = `TRUNCATE TABLE "${entry.config.name}" CASCADE;`;
       await sql2.unsafe(ddl);
-      console.log(colorize(`  \u2713 truncated ${entry.config.name}`, "green"));
+      console.log(import_picocolors6.default.green(`  \u2713 truncated ${entry.config.name}`));
+    }
+    console.log(import_picocolors6.default.green(`
+Refresh complete. All tables are now empty.`));
+  } finally {
+    await sql2.end();
+  }
+}
+
+// src/commands/rollback.ts
+import { join as join6, resolve as resolve5 } from "path";
+var import_picocolors7 = __toESM(require_picocolors(), 1);
+async function runRollback(config2) {
+  intro(import_picocolors7.default.bgCyan(import_picocolors7.default.black(" @bungres/kit rollback ")));
+  const migrationsDir = resolve5(config2.out);
+  const sql2 = new Bun.SQL(config2.dbUrl);
+  const table2 = config2.migrationsTable;
+  const schema = config2.migrationsSchema;
+  const qualifiedTable = `"${schema}"."${table2}"`;
+  const s = spinner();
+  s.start("Checking applied migrations...");
+  try {
+    const applied = await sql2.unsafe(`SELECT name FROM ${qualifiedTable} ORDER BY name DESC LIMIT 1`);
+    if (applied.length === 0) {
+      s.stop("No migrations to rollback.");
+      log.warn(import_picocolors7.default.yellow("No applied migrations found in the database."));
+      outro("Done.");
+      return;
     }
-    console.log(colorize(`
-Refresh complete. All tables are now empty.`, "green"));
+    const lastMigration = applied[0].name;
+    s.stop(`Found migration to rollback: ${import_picocolors7.default.cyan(lastMigration)}`);
+    const shouldRollback = await confirm({
+      message: `Are you sure you want to rollback ${import_picocolors7.default.cyan(lastMigration)}?`,
+      initialValue: true
+    });
+    if (isCancel(shouldRollback) || !shouldRollback) {
+      outro(import_picocolors7.default.gray("Rollback cancelled."));
+      return;
+    }
+    const ms = spinner();
+    ms.start(`Rolling back ${lastMigration}...`);
+    const content = await Bun.file(join6(migrationsDir, lastMigration)).text();
+    let downContent = "";
+    const downMatch = content.match(/-- ==== DOWN ====([\s\S]*)/i);
+    if (downMatch) {
+      downContent = downMatch[1].trim();
+    } else {
+      ms.stop("Failed.");
+      log.error(import_picocolors7.default.red(`No '-- ==== DOWN ====' section found in ${lastMigration}. Cannot rollback safely.`));
+      outro("Failed.");
+      return;
+    }
+    if (!downContent) {
+      log.warn(import_picocolors7.default.yellow(`Down section is empty in ${lastMigration}. Nothing to execute.`));
+    }
+    if (config2.verbose) {
+      log.info(import_picocolors7.default.gray(`-- ${lastMigration} (DOWN) --
+${downContent}
+`));
+    }
+    await sql2.transaction(async (txSql) => {
+      if (downContent) {
+        const statements = config2.breakpoints ? downContent.split(/-->statement-breakpoint/g).flatMap((chunk) => chunk.split(";").map((s2) => s2.trim()).filter(Boolean)) : downContent.split(";").map((s2) => s2.trim()).filter(Boolean);
+        for (const stmt of statements) {
+          await txSql.unsafe(stmt + ";");
+        }
+      }
+      await txSql.unsafe(`DELETE FROM ${qualifiedTable} WHERE name = $1`, [lastMigration]);
+    });
+    ms.stop(import_picocolors7.default.green(`\u2713 Rolled back ${lastMigration}`));
+    outro(import_picocolors7.default.cyan("\u2728 Rollback successful."));
+  } catch (err) {
+    log.error(import_picocolors7.default.red(`Rollback failed: ${err.message}`));
+    outro("Failed.");
   } finally {
     await sql2.end();
   }
 }
 
 // src/commands/seed.ts
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
+var import_picocolors8 = __toESM(require_picocolors(), 1);
 async function runSeed(config2) {
-  if (!config2.seed) {
-    console.log(colorize(`No seed file configured in bungres.config.ts`, "yellow"));
+  intro(import_picocolors8.default.bgCyan(import_picocolors8.default.black(" @bungres/kit seed ")));
+  if (config2.seed) {
+    const seedPath = resolve6(process.cwd(), config2.seed);
+    const file = Bun.file(seedPath);
+    if (await file.exists()) {
+      const s2 = spinner();
+      s2.start(`Running seeder: ${config2.seed}...`);
+      const proc = Bun.spawn(["bun", "run", seedPath], {
+        cwd: process.cwd(),
+        stdout: "inherit",
+        stderr: "inherit",
+        env: { ...Bun.env, DATABASE_URL: config2.dbUrl }
+      });
+      const exitCode = await proc.exited;
+      if (exitCode === 0) {
+        s2.stop("Seed complete.");
+        outro(import_picocolors8.default.cyan("\u2728 Seeding successful."));
+      } else {
+        s2.stop("Seed failed.");
+        log.error(import_picocolors8.default.red(`Seed failed with exit code ${exitCode}.`));
+        outro("Failed.");
+        process.exit(exitCode);
+      }
+      return;
+    }
+  }
+  log.info(import_picocolors8.default.blue("No custom seed script found. Initiating Auto-Seeder..."));
+  let faker;
+  try {
+    const fakerModule = await import("@faker-js/faker");
+    faker = fakerModule.faker;
+  } catch (err) {
+    log.error(import_picocolors8.default.red("Auto-seeder requires @faker-js/faker."));
+    log.message(`Please install it: ${import_picocolors8.default.green("bun add -d @faker-js/faker")}`);
+    outro("Failed.");
     return;
   }
-  const seedPath = resolve5(process.cwd(), config2.seed);
-  const file = Bun.file(seedPath);
-  if (!await file.exists()) {
-    console.error(colorize(`Seed file not found at ${seedPath}`, "red"));
-    process.exit(1);
+  const s = spinner();
+  s.start("Loading schemas for auto-seeding...");
+  const schemas2 = await loadSchemas(config2.schema);
+  if (schemas2.length === 0) {
+    s.stop("No schemas.");
+    outro("Nothing to seed.");
+    return;
   }
-  console.log(colorize(`
-Running seeder: ${config2.seed}...`, "cyan"));
-  const proc = Bun.spawn(["bun", "run", seedPath], {
-    cwd: process.cwd(),
-    stdout: "inherit",
-    stderr: "inherit",
-    env: { ...Bun.env, DATABASE_URL: config2.dbUrl }
-  });
-  const exitCode = await proc.exited;
-  if (exitCode === 0) {
-    console.log(`
-Seed complete.`);
-  } else {
-    console.error(`
-Seed failed with exit code ${exitCode}.`);
-    process.exit(exitCode);
+  const tableConfigs = schemas2.map((s2) => s2.config);
+  const sorted = topoSortConfigs(tableConfigs);
+  s.stop(`Loaded ${sorted.length} tables in topological order.`);
+  const sql2 = new Bun.SQL(config2.dbUrl);
+  const insertedData = {};
+  try {
+    for (const table2 of sorted) {
+      const ms = spinner();
+      ms.start(`Seeding ${table2.name}...`);
+      const rowsToInsert = 10;
+      const rows = [];
+      for (let i2 = 0;i2 < rowsToInsert; i2++) {
+        const row = {};
+        for (const [colName2, col2] of Object.entries(table2.columns)) {
+          if (col2.references) {
+            const parentTable = col2.references.table;
+            const parentRows = insertedData[parentTable];
+            if (parentRows && parentRows.length > 0) {
+              const parentRow = parentRows[Math.floor(Math.random() * parentRows.length)];
+              row[col2.name] = parentRow[col2.references.column];
+              continue;
+            }
+          }
+          if (col2.dataType === "uuid")
+            row[col2.name] = faker.string.uuid();
+          else if (col2.dataType === "varchar" || col2.dataType === "text")
+            row[col2.name] = faker.lorem.word();
+          else if (col2.dataType === "integer")
+            row[col2.name] = faker.number.int({ min: 1, max: 1000 });
+          else if (col2.dataType === "boolean")
+            row[col2.name] = faker.datatype.boolean();
+          else if (col2.dataType === "timestamptz" || col2.dataType === "timestamp")
+            row[col2.name] = faker.date.recent().toISOString();
+          else if (col2.dataType === "jsonb" || col2.dataType === "json")
+            row[col2.name] = JSON.stringify({ key: faker.lorem.word() });
+          else
+            row[col2.name] = null;
+        }
+        rows.push(row);
+      }
+      const insertedRows = await sql2.transaction(async (tx) => {
+        const results = [];
+        for (const row of rows) {
+          const keys = Object.keys(row).map((k) => `"${k}"`);
+          const values = Object.values(row);
+          const placeholders = values.map((_2, i2) => `$${i2 + 1}`);
+          const q = `INSERT INTO "${table2.schema || "public"}"."${table2.name}" (${keys.join(", ")}) VALUES (${placeholders.join(", ")}) RETURNING *`;
+          const res = await tx.unsafe(q, values);
+          results.push(res[0]);
+        }
+        return results;
+      });
+      insertedData[table2.name] = insertedRows;
+      ms.stop(import_picocolors8.default.green(`\u2713 Seeded ${rowsToInsert} rows into ${table2.name}`));
+    }
+    outro(import_picocolors8.default.cyan("\u2728 Auto-seeding complete."));
+  } catch (err) {
+    log.error(import_picocolors8.default.red(`Auto-seeding failed: ${err.message}`));
+    outro("Failed.");
+  } finally {
+    await sql2.end();
   }
 }
 
 // src/commands/status.ts
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
+var import_picocolors9 = __toESM(require_picocolors(), 1);
 async function runStatus(config2) {
-  const migrationsDir = resolve6(config2.out);
+  intro(import_picocolors9.default.bgCyan(import_picocolors9.default.black(" @bungres/kit status ")));
+  const migrationsDir = resolve7(config2.out);
   const sql2 = new Bun.SQL(config2.dbUrl);
   const table2 = config2.migrationsTable;
   const schema = config2.migrationsSchema;
   const qualifiedTable = `"${schema}"."${table2}"`;
+  const s = spinner();
+  s.start("Checking migration status...");
   try {
     const tableCheck = await sql2.unsafe(`SELECT EXISTS (
         SELECT 1 FROM information_schema.tables
@@ -2274,33 +4040,247 @@ async function runStatus(config2) {
     }
     files.sort();
     if (files.length === 0) {
-      console.log(colorize("No migration files found. Run `bungres generate` first.", "yellow"));
+      s.stop("No files found.");
+      log.warn(import_picocolors9.default.yellow("No migration files found."));
+      log.info(`Run ${import_picocolors9.default.green("bungres generate")} first.`);
+      outro("Done.");
       return;
     }
     let appliedSet = new Set;
     if (trackingExists) {
       const applied = await sql2.unsafe(`SELECT name FROM ${qualifiedTable} ORDER BY applied_at`);
-      appliedSet = new Set(applied.map((r) => r.name));
+      appliedSet = new Set(applied.map((r2) => r2.name));
     }
-    console.log(colorize(`
-Migration status:
-`, "cyan"));
+    s.stop("Status check complete.");
+    log.message(import_picocolors9.default.bold("Migration status:"));
     let pendingCount = 0;
     for (const file of files) {
       const isApplied = appliedSet.has(file);
-      const status = isApplied ? colorize("\u2713 applied ", "green") : colorize("\u2717 pending ", "yellow");
-      if (!isApplied)
+      if (isApplied) {
+        log.success(`${import_picocolors9.default.green("\u2713 applied ")} ${file}`);
+      } else {
         pendingCount++;
-      console.log(`  ${status}  ${file}`);
+        log.warn(`${import_picocolors9.default.yellow("\u2717 pending ")} ${file}`);
+      }
     }
-    console.log(`
-${colorize(appliedSet.size.toString(), "green")} applied, ${colorize(pendingCount.toString(), "yellow")} pending.
-`);
+    log.info(`${import_picocolors9.default.green(appliedSet.size.toString())} applied, ${import_picocolors9.default.yellow(pendingCount.toString())} pending.`);
+    outro("Done.");
+  } catch (err) {
+    log.error(import_picocolors9.default.red(`Status check failed: ${err.message}`));
+    outro("Failed.");
   } finally {
     await sql2.end();
   }
 }
 
+// src/commands/studio.ts
+var import_picocolors10 = __toESM(require_picocolors(), 1);
+
+// src/commands/template.ts
+var indexHtml = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Bungres Studio</title>
+  
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+  <link href="https://fonts.googleapis.com/css2?family=Fira+Code:wght@400;500&display=swap" rel="stylesheet">
+
+  <script src="https://unpkg.com/htmx.org@2.0.0" defer></script>
+  <script defer src="https://cdn.jsdelivr.net/npm/alpinejs@3.x.x/dist/cdn.min.js"></script>
+  <script src="https://cdn.tailwindcss.com"></script>
+  
+  <script>
+    tailwind.config = {
+      darkMode: "class",
+      theme: {
+        extend: {
+          fontFamily: {
+            sans: ['Outfit', 'sans-serif'],
+            mono: ['"Fira Code"', 'monospace'],
+          },
+          colors: {
+            background: 'var(--background)',
+            foreground: 'var(--foreground)',
+            card: 'var(--card)',
+            'card-foreground': 'var(--card-foreground)',
+            popover: 'var(--popover)',
+            'popover-foreground': 'var(--popover-foreground)',
+            primary: 'var(--primary)',
+            'primary-foreground': 'var(--primary-foreground)',
+            secondary: 'var(--secondary)',
+            'secondary-foreground': 'var(--secondary-foreground)',
+            muted: 'var(--muted)',
+            'muted-foreground': 'var(--muted-foreground)',
+            accent: 'var(--accent)',
+            'accent-foreground': 'var(--accent-foreground)',
+            destructive: 'var(--destructive)',
+            border: 'var(--border)',
+            input: 'var(--input)',
+            ring: 'var(--ring)',
+            sidebar: {
+              DEFAULT: 'var(--sidebar)',
+              foreground: 'var(--sidebar-foreground)',
+              primary: 'var(--sidebar-primary)',
+              'primary-foreground': 'var(--sidebar-primary-foreground)',
+              accent: 'var(--sidebar-accent)',
+              'accent-foreground': 'var(--sidebar-accent-foreground)',
+              border: 'var(--sidebar-border)',
+              ring: 'var(--sidebar-ring)',
+            }
+          }
+        }
+      }
+    }
+  </script>
+
+  <style>
+    :root {
+      --background: oklch(1 0 0);
+      --foreground: oklch(0.148 0.004 228.8);
+      --card: oklch(1 0 0);
+      --card-foreground: oklch(0.148 0.004 228.8);
+      --popover: oklch(1 0 0);
+      --popover-foreground: oklch(0.148 0.004 228.8);
+      --primary: oklch(0.508 0.118 165.612);
+      --primary-foreground: oklch(0.979 0.021 166.113);
+      --secondary: oklch(0.967 0.001 286.375);
+      --secondary-foreground: oklch(0.21 0.006 285.885);
+      --muted: oklch(0.963 0.002 197.1);
+      --muted-foreground: oklch(0.56 0.021 213.5);
+      --accent: oklch(0.963 0.002 197.1);
+      --accent-foreground: oklch(0.218 0.008 223.9);
+      --destructive: oklch(0.577 0.245 27.325);
+      --border: oklch(0.925 0.005 214.3);
+      --input: oklch(0.925 0.005 214.3);
+      --ring: oklch(0.723 0.014 214.4);
+      --chart-1: oklch(0.845 0.143 164.978);
+      --chart-2: oklch(0.696 0.17 162.48);
+      --chart-3: oklch(0.596 0.145 163.225);
+      --chart-4: oklch(0.508 0.118 165.612);
+      --chart-5: oklch(0.432 0.095 166.913);
+      --radius: 0.625rem;
+      --sidebar: oklch(0.987 0.002 197.1);
+      --sidebar-foreground: oklch(0.148 0.004 228.8);
+      --sidebar-primary: oklch(0.596 0.145 163.225);
+      --sidebar-primary-foreground: oklch(0.979 0.021 166.113);
+      --sidebar-accent: oklch(0.963 0.002 197.1);
+      --sidebar-accent-foreground: oklch(0.218 0.008 223.9);
+      --sidebar-border: oklch(0.925 0.005 214.3);
+      --sidebar-ring: oklch(0.723 0.014 214.4);
+    }
+
+    .dark {
+      --background: oklch(0.148 0.004 228.8);
+      --foreground: oklch(0.987 0.002 197.1);
+      --card: oklch(0.218 0.008 223.9);
+      --card-foreground: oklch(0.987 0.002 197.1);
+      --popover: oklch(0.218 0.008 223.9);
+      --popover-foreground: oklch(0.987 0.002 197.1);
+      --primary: oklch(0.432 0.095 166.913);
+      --primary-foreground: oklch(0.979 0.021 166.113);
+      --secondary: oklch(0.274 0.006 286.033);
+      --secondary-foreground: oklch(0.985 0 0);
+      --muted: oklch(0.275 0.011 216.9);
+      --muted-foreground: oklch(0.723 0.014 214.4);
+      --accent: oklch(0.275 0.011 216.9);
+      --accent-foreground: oklch(0.987 0.002 197.1);
+      --destructive: oklch(0.704 0.191 22.216);
+      --border: oklch(1 0 0 / 10%);
+      --input: oklch(1 0 0 / 15%);
+      --ring: oklch(0.56 0.021 213.5);
+      --chart-1: oklch(0.845 0.143 164.978);
+      --chart-2: oklch(0.696 0.17 162.48);
+      --chart-3: oklch(0.596 0.145 163.225);
+      --chart-4: oklch(0.508 0.118 165.612);
+      --chart-5: oklch(0.432 0.095 166.913);
+      --sidebar: oklch(0.218 0.008 223.9);
+      --sidebar-foreground: oklch(0.987 0.002 197.1);
+      --sidebar-primary: oklch(0.696 0.17 162.48);
+      --sidebar-primary-foreground: oklch(0.262 0.051 172.552);
+      --sidebar-accent: oklch(0.275 0.011 216.9);
+      --sidebar-accent-foreground: oklch(0.987 0.002 197.1);
+      --sidebar-border: oklch(1 0 0 / 10%);
+      --sidebar-ring: oklch(0.56 0.021 213.5);
+    }
+
+    ::-webkit-scrollbar { width: 6px; height: 6px; }
+    ::-webkit-scrollbar-track { background: transparent; }
+    ::-webkit-scrollbar-thumb { background: var(--border); border-radius: 4px; }
+    ::-webkit-scrollbar-thumb:hover { background: var(--muted-foreground); }
+    ::-webkit-scrollbar-corner { background: transparent; }
+    [x-cloak] { display: none !important; }
+    .htmx-indicator { opacity: 0; transition: opacity 200ms ease-in; }
+    .htmx-request .htmx-indicator { opacity: 1; }
+    .htmx-request.htmx-indicator { opacity: 1; }
+  </style>
+</head>
+<body class="dark bg-background text-foreground font-sans h-screen flex overflow-hidden selection:bg-primary/30">
+  <div x-data="{ currentTable: null, pageSize: 25 }" class="flex h-screen w-full">
+    <aside class="w-64 bg-sidebar border-r border-sidebar-border flex flex-col z-20 shrink-0 text-sidebar-foreground">
+      <div class="p-4 border-b border-sidebar-border flex items-center gap-3 bg-sidebar">
+        <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="text-primary">
+          <ellipse cx="12" cy="5" rx="9" ry="3"></ellipse>
+          <path d="M21 12c0 1.66-4 3-9 3s-9-1.34-9-3"></path>
+          <path d="M3 5v14c0 1.66 4 3 9 3s9-1.34 9-3V5"></path>
+        </svg>
+        <h1 class="text-sm font-semibold tracking-tight m-0">Bungres Studio</h1>
+      </div>
+      <div class="flex-1 overflow-y-auto p-2" hx-get="/htmx/sidebar" hx-trigger="load">
+        <div class="p-4 text-xs text-muted-foreground animate-pulse text-center">Loading schemas...</div>
+      </div>
+    </aside>
+    <main class="flex-1 flex flex-col relative w-[calc(100vw-16rem)]">
+      <header class="h-14 px-4 border-b border-border flex items-center justify-between bg-card z-10 shrink-0 text-card-foreground">
+        <h2 class="text-sm font-semibold tracking-tight flex items-center gap-2">
+          <template x-if="currentTable">
+            <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" class="text-primary">
+              <rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect>
+              <line x1="3" y1="9" x2="21" y2="9"></line>
+              <line x1="9" y1="21" x2="9" y2="9"></line>
+            </svg>
+          </template>
+          <template x-if="!currentTable">
+            <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" class="text-muted-foreground">
+              <rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect>
+              <line x1="3" y1="9" x2="21" y2="9"></line>
+              <line x1="9" y1="21" x2="9" y2="9"></line>
+            </svg>
+          </template>
+          <span x-text="currentTable ? currentTable : 'Select a table'"></span>
+        </h2>
+        <button x-bind:disabled="!currentTable" class="bg-card border border-border text-card-foreground px-3 py-1.5 rounded-md text-xs font-medium cursor-pointer transition-all hover:bg-accent hover:text-accent-foreground active:scale-95 disabled:opacity-50 disabled:cursor-not-allowed flex items-center gap-1.5 group" x-on:click="$dispatch('refresh-table')">
+          <svg class="w-4 h-4 group-hover:rotate-180 transition-transform duration-500" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+            <polyline points="23 4 23 10 17 10"></polyline>
+            <polyline points="1 20 1 14 7 14"></polyline>
+            <path d="M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"></path>
+          </svg>
+          Refresh
+        </button>
+      </header>
+      <div class="flex-1 overflow-auto relative z-[1] text-left bg-background">
+        <div id="data-container" class="h-full w-full flex flex-col" x-on:refresh-table.window="if(currentTable) htmx.ajax('GET', '/htmx/tables/' + currentTable + '?limit=' + pageSize, {target: '#data-container'})">
+          <div class="flex flex-col items-center justify-center h-full w-full text-muted-foreground animate-[fadeIn_0.5s_ease-out]">
+            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" class="w-16 h-16 mb-4 text-muted">
+              <path d="M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z"></path>
+              <polyline points="14 2 14 8 20 8"></polyline>
+            </svg>
+            <h3 class="text-foreground m-0 mb-2 text-lg">No Table Selected</h3>
+            <p class="text-sm">Choose a table from the sidebar to view its data</p>
+          </div>
+        </div>
+      </div>
+    </main>
+  </div>
+  <script>
+    document.addEventListener('alpine:init', () => {})
+  </script>
+</body>
+</html>`;
+
 // src/commands/studio.ts
 async function runStudio(config2) {
   const schemas2 = await loadSchemas(config2.schema);
@@ -2398,804 +4378,181 @@ async function runStudio(config2) {
           return new Response("Invalid request", { status: 400 });
         }
       }
-      if (req.method === "GET" && url.pathname === "/") {
-        return new Response(htmlTemplate, {
-          headers: { "Content-Type": "text/html" }
-        });
-      }
-      return new Response("Not found", { status: 404 });
-    }
-  });
-  console.log(colorize("=========================================", "cyan"));
-  console.log(colorize(`\uD83D\uDC18 Bungres Studio is running!`, "cyan"));
-  console.log(colorize(`   Local: http://localhost:${server.port}`, "green"));
-  console.log(colorize("=========================================", "cyan"));
-}
-var htmlTemplate = `
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Bungres Studio</title>
-  <link href="https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;500;600;700&display=swap" rel="stylesheet">
-  <style>
-    :root {
-      --bg-color: #09090b;
-      --panel-bg: #18181b;
-      --border-color: #27272a;
-      --text-main: #fafafa;
-      --text-muted: #a1a1aa;
-      --accent-color: #8b5cf6;
-      --accent-hover: #7c3aed;
-      --header-bg: #09090b;
-      --row-hover: #27272a;
-      --input-bg: #18181b;
-      --muted-bg: #27272a;
-      
-      --type-number: #f472b6;
-      --type-string: #60a5fa;
-      --type-boolean: #34d399;
-      --type-date: #c084fc;
-      --type-json: #fbbf24;
-      --type-null: #71717a;
-    }
-
-    * { box-sizing: border-box; }
-    
-    body {
-      margin: 0;
-      padding: 0;
-      font-family: 'Outfit', -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
-      background-color: var(--bg-color);
-      color: var(--text-main);
-      display: flex;
-      height: 100vh;
-      overflow: hidden;
-    }
-
-    /* Sidebar */
-    .sidebar {
-      width: 240px;
-      background-color: var(--panel-bg);
-      border-right: 1px solid var(--border-color);
-      display: flex;
-      flex-direction: column;
-      z-index: 20;
-    }
-
-    .sidebar-header {
-      padding: 16px;
-      border-bottom: 1px solid var(--border-color);
-      display: flex;
-      align-items: center;
-      gap: 8px;
-      background-color: var(--panel-bg);
-    }
-
-    .sidebar-header h1 {
-      margin: 0;
-      font-size: 14px;
-      font-weight: 600;
-      color: var(--text-main);
-      letter-spacing: -0.25px;
-    }
-
-    .sidebar-header svg {
-      color: var(--accent-color);
-    }
-
-    .table-list {
-      flex: 1;
-      overflow-y: auto;
-      padding: 8px;
-      list-style: none;
-      margin: 0;
-    }
-
-    .table-list::-webkit-scrollbar {
-      width: 6px;
-    }
-    .table-list::-webkit-scrollbar-thumb {
-      background: #3f3f46;
-      border-radius: 4px;
-    }
-
-    .table-item {
-      padding: 8px 12px;
-      cursor: pointer;
-      font-size: 13px;
-      font-weight: 500;
-      color: var(--text-muted);
-      border-radius: 6px;
-      transition: all 0.15s ease;
-      display: flex;
-      align-items: center;
-      gap: 8px;
-      margin-bottom: 2px;
-      border: 1px solid transparent;
-    }
-
-    .table-item:hover {
-      background-color: var(--muted-bg);
-      color: var(--text-main);
-    }
-
-    .table-item.active {
-      background-color: var(--accent-color);
-      color: #fff;
-      border-color: var(--accent-color);
-    }
-
-    .table-item svg {
-      flex-shrink: 0;
-    }
-    .table-item.active svg {
-      color: #fff;
-    }
-
-    /* Main Content */
-    .main {
-      flex: 1;
-      display: flex;
-      flex-direction: column;
-      position: relative;
-    }
-
-    .main-header {
-      height: 56px;
-      padding: 0 16px;
-      border-bottom: 1px solid var(--border-color);
-      display: flex;
-      align-items: center;
-      justify-content: space-between;
-      background-color: var(--header-bg);
-      z-index: 10;
-    }
-
-    .main-header h2 {
-      margin: 0;
-      font-size: 14px;
-      font-weight: 600;
-      color: var(--text-main);
-      letter-spacing: -0.25px;
-      display: flex;
-      align-items: center;
-      gap: 8px;
-    }
-
-    .btn {
-      background-color: var(--input-bg);
-      border: 1px solid var(--border-color);
-      color: var(--text-main);
-      padding: 6px 12px;
-      border-radius: 6px;
-      font-size: 13px;
-      font-weight: 500;
-      font-family: 'Outfit', sans-serif;
-      cursor: pointer;
-      transition: all 0.15s ease;
-      display: flex;
-      align-items: center;
-      gap: 6px;
-    }
-
-    .btn:hover:not(:disabled) {
-      background-color: var(--muted-bg);
-    }
-    
-    .btn:active:not(:disabled) {
-      transform: translateY(1px);
-    }
-
-    .btn:disabled {
-      opacity: 0.5;
-      cursor: not-allowed;
-    }
-
-    .content-area {
-      flex: 1;
-      overflow: auto;
-      padding: 0;
-      position: relative;
-      z-index: 1;
-      text-align: left;
-    }
-
-    /* Data Table */
-    .data-grid-container {
-      background-color: var(--bg-color);
-      border: 1px solid var(--border-color);
-      border-radius: 0;
-      overflow: hidden;
-      height: 100%;
-      width: 100%;
-      display: flex;
-      flex-direction: column;
-    }
-    
-    .data-grid-container > .table-wrapper {
-      flex: 1;
-      overflow: auto;
-      min-height: 0;
-    }
-    
-    .data-grid-container::-webkit-scrollbar {
-      width: 8px;
-      height: 8px;
-    }
-    .data-grid-container::-webkit-scrollbar-corner {
-      background: transparent;
-    }
-    .data-grid-container::-webkit-scrollbar-thumb {
-      background: #3f3f46;
-      border-radius: 4px;
-    }
-
-
-    table {
-      width: auto;
-      border-collapse: separate;
-      border-spacing: 0;
-      text-align: left;
-      font-size: 14px;
-      table-layout: auto;
-    }
-
-    th {
-      background-color: var(--panel-bg);
-      color: var(--text-main);
-      font-weight: 500;
-      font-size: 12px;
-      padding: 10px 16px;
-      border-bottom: 1px solid var(--border-color);
-      border-right: 1px solid var(--border-color);
-      white-space: nowrap;
-      position: sticky;
-      top: 0;
-      z-index: 10;
-    }
-
-    .col-header {
-      display: flex;
-      flex-direction: column;
-      gap: 2px;
-    }
-    
-    .col-name {
-      font-weight: 600;
-      font-size: 13px;
-      display: flex;
-      align-items: center;
-      gap: 6px;
-    }
-
-    .pk-badge {
-      font-size: 10px;
-      background: rgba(251, 191, 36, 0.15);
-      color: #fbbf24;
-      padding: 2px 5px;
-      border-radius: 4px;
-      font-weight: 500;
-      letter-spacing: 0.25px;
-      border: 1px solid rgba(251, 191, 36, 0.3);
-    }
-
-    .fk-badge {
-      font-size: 10px;
-      background: rgba(96, 165, 250, 0.15);
-      color: #60a5fa;
-      padding: 2px 5px;
-      border-radius: 4px;
-      font-weight: 500;
-      letter-spacing: 0.25px;
-      border: 1px solid rgba(96, 165, 250, 0.3);
-    }
-    
-    .col-type {
-      font-size: 11px;
-      color: var(--text-muted);
-      font-family: 'JetBrains Mono', 'Fira Code', monospace;
-      text-transform: uppercase;
-    }
-
-    td {
-      padding: 10px 16px;
-      border-bottom: 1px solid var(--border-color);
-      border-right: 1px solid var(--border-color);
-      color: var(--text-main);
-      max-width: 300px;
-      overflow: hidden;
-      text-overflow: ellipsis;
-      white-space: nowrap;
-      transition: background-color 0.15s ease;
-      font-size: 13px;
-    }
-    
-
-
-    tr:hover td {
-      background-color: var(--row-hover);
-    }
-
-    .type-number { color: var(--type-number); }
-    .type-string { color: var(--type-string); }
-    .type-boolean { color: var(--type-boolean); }
-    .type-date { color: var(--type-date); }
-    .type-json { color: var(--type-json); font-family: monospace; }
-    .type-null { color: var(--type-null); font-style: italic; }
-    
-    .cell-value {
-      font-family: 'JetBrains Mono', 'Fira Code', monospace;
-      font-size: 13px;
-    }
-
-    .empty-state {
-      display: flex;
-      flex-direction: column;
-      align-items: center;
-      justify-content: center;
-      height: 100%;
-      width: 100%;
-      color: var(--text-muted);
-      animation: fadeIn 0.5s ease-out;
-    }
-    
-    .empty-state svg {
-      margin-bottom: 16px;
-      color: #3f3f46;
-      width: 64px;
-      height: 64px;
-    }
-    
-    .empty-state h3 {
-      color: var(--text-main);
-      margin: 0 0 8px 0;
-      font-size: 18px;
-    }
-    
-    @keyframes fadeIn {
-      from { opacity: 0; transform: translateY(10px); }
-      to { opacity: 1; transform: translateY(0); }
-    }
-    
-    @keyframes spin {
-      from { transform: rotate(0deg); }
-      to { transform: rotate(360deg); }
-    }
-    .spinning {
-      animation: spin 1s linear infinite;
-    }
-
-    /* Pagination */
-    .pagination {
-      display: flex;
-      align-items: center;
-      justify-content: space-between;
-      padding: 12px 16px;
-      background-color: var(--panel-bg);
-      border-top: 1px solid var(--border-color);
-      font-size: 13px;
-      color: var(--text-muted);
-      width: fit-content;
-      min-width: 100%;
-      flex-shrink: 0;
-    }
-
-    .pagination-info {
-      display: flex;
-      align-items: center;
-      gap: 12px;
-    }
-
-    .pagination-controls {
-      display: flex;
-      align-items: center;
-      gap: 6px;
-    }
-
-    .pagination-btn {
-      background-color: var(--input-bg);
-      border: 1px solid var(--border-color);
-      color: var(--text-main);
-      padding: 6px 12px;
-      border-radius: 6px;
-      cursor: pointer;
-      font-size: 13px;
-      transition: all 0.15s ease;
-    }
-
-    .pagination-btn:hover:not(:disabled) {
-      background-color: var(--muted-bg);
-    }
-
-    .pagination-btn:disabled {
-      opacity: 0.5;
-      cursor: not-allowed;
-    }
-
-    .pagination-btn.active {
-      background-color: var(--accent-color);
-      border-color: var(--accent-color);
-    }
-
-    .page-input {
-      background-color: var(--input-bg);
-      border: 1px solid var(--border-color);
-      color: var(--text-main);
-      padding: 6px 8px;
-      border-radius: 6px;
-      width: 50px;
-      text-align: center;
-      font-size: 13px;
-    }
-
-    .page-size-select {
-      background-color: var(--input-bg);
-      border: 1px solid var(--border-color);
-      color: var(--text-main);
-      padding: 6px 8px;
-      border-radius: 6px;
-      font-size: 13px;
-      cursor: pointer;
-    }
-
-    .page-size-select:hover {
-      background-color: var(--muted-bg);
-    }
-  </style>
-</head>
-<body>
-
-  <div class="sidebar">
-    <div class="sidebar-header">
-      <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-        <ellipse cx="12" cy="5" rx="9" ry="3"></ellipse>
-        <path d="M21 12c0 1.66-4 3-9 3s-9-1.34-9-3"></path>
-        <path d="M3 5v14c0 1.66 4 3 9 3s9-1.34 9-3V5"></path>
-      </svg>
-      <h1>Bungres Studio</h1>
-    </div>
-    <ul class="table-list" id="table-list">
-      <!-- Populated by JS -->
-    </ul>
-  </div>
-
-  <div class="main">
-    <div class="main-header">
-      <h2 id="current-table-name">
-        <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" style="color: var(--text-muted);">
-          <rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect>
-          <line x1="3" y1="9" x2="21" y2="9"></line>
-          <line x1="9" y1="21" x2="9" y2="9"></line>
-        </svg>
-        Select a table
-      </h2>
-      <button id="refresh-btn" class="btn" disabled>
-        <svg id="refresh-icon" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-          <polyline points="23 4 23 10 17 10"></polyline>
-          <polyline points="1 20 1 14 7 14"></polyline>
-          <path d="M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"></path>
-        </svg>
-        Refresh
-      </button>
-    </div>
-    <div class="content-area">
-      <div id="data-container" class="empty-state">
-        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
-          <path d="M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z"></path>
-          <polyline points="14 2 14 8 20 8"></polyline>
-        </svg>
-        <h3>No Table Selected</h3>
-        <p>Choose a table from the sidebar to view its data</p>
-      </div>
-    </div>
-  </div>
-
-  <script>
-    let currentTable = null;
-    let tablesData = [];
-    let tableSchemas = {};
-    let currentPage = 1;
-    let totalPages = 1;
-    let totalRecords = 0;
-    let pageSize = 25;
-
-    // Format values for the data grid
-    function formatValue(val) {
-      if (val === null || val === undefined) return 'null';
-      
-      if (typeof val === 'object') {
-        if (val instanceof Date) {
-          return val.toISOString();
-        }
-        // Handle JSON objects
-        const safeJson = JSON.stringify(val)
-          .replace(/&/g, "&amp;")
-          .replace(/</g, "&lt;")
-          .replace(/>/g, "&gt;");
-        return safeJson;
-      }
-      
-      if (typeof val === 'string') {
-        // Escape HTML to prevent XSS
-        const safeStr = String(val)
-          .replace(/&/g, "&amp;")
-          .replace(/</g, "&lt;")
-          .replace(/>/g, "&gt;");
-        return safeStr;
-      }
-      
-      return String(val);
-    }
-
-    async function loadTables() {
-      try {
-        const res = await fetch('/api/tables');
-        tablesData = await res.json();
-        
-        const list = document.getElementById('table-list');
-        list.innerHTML = '';
-        tableSchemas = {};
-        
-        tablesData.forEach(t => {
-          tableSchemas[t.name] = t;
-          const li = document.createElement('li');
-          li.className = 'table-item';
-          li.innerHTML = \`
-            <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-              <rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect>
-              <line x1="3" y1="9" x2="21" y2="9"></line>
-              <line x1="9" y1="21" x2="9" y2="9"></line>
-            </svg>
-            \${t.name}
-          \`;
-          li.onclick = () => selectTable(t.name);
-          list.appendChild(li);
+      if (req.method === "GET" && url.pathname === "/htmx/sidebar") {
+        let html = '<ul class="flex flex-col gap-0.5 p-2 m-0 list-none">';
+        schemas2.forEach((s) => {
+          const tableName = s.config.name;
+          html += `
+            <li>
+              <button 
+                hx-get="/htmx/tables/${tableName}?page=1&limit=25"
+                hx-target="#data-container"
+                @click="currentTable = '${tableName}'; pageSize = 25"
+                :class="currentTable === '${tableName}' ? 'bg-primary text-primary-foreground' : 'text-muted-foreground hover:bg-sidebar-accent hover:text-sidebar-accent-foreground'"
+                class="w-full text-left px-3 py-2 rounded-md text-sm font-medium flex items-center gap-2 transition-colors focus:outline-none"
+              >
+                <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                  <rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect>
+                  <line x1="3" y1="9" x2="21" y2="9"></line>
+                  <line x1="9" y1="21" x2="9" y2="9"></line>
+                </svg>
+                ${tableName}
+              </button>
+            </li>
+          `;
         });
-      } catch (e) {
-        console.error("Failed to load tables", e);
-      }
-    }
-
-    async function selectTable(name, page = 1) {
-      currentTable = name;
-      currentPage = page;
-      
-      // Update UI active state
-      document.querySelectorAll('.table-item').forEach(el => {
-        if (el.textContent.trim() === name) el.classList.add('active');
-        else el.classList.remove('active');
-      });
-      
-      document.getElementById('current-table-name').innerHTML = \`
-        <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" style="color: var(--accent-color);">
-          <rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect>
-          <line x1="3" y1="9" x2="21" y2="9"></line>
-          <line x1="9" y1="21" x2="9" y2="9"></line>
-        </svg>
-        \${name}
-      \`;
-      document.getElementById('refresh-btn').disabled = false;
-      
-      const container = document.getElementById('data-container');
-      const existingTable = container.querySelector('.data-grid-container');
-      
-      if (existingTable) {
-        // Show loading overlay instead of replacing content
-        existingTable.style.opacity = '0.5';
-        existingTable.style.pointerEvents = 'none';
-      } else {
-        container.innerHTML = \`
-          <div class="empty-state">
-            <svg class="spinning" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-              <line x1="12" y1="2" x2="12" y2="6"></line>
-              <line x1="12" y1="18" x2="12" y2="22"></line>
-              <line x1="4.93" y1="4.93" x2="7.76" y2="7.76"></line>
-              <line x1="16.24" y1="16.24" x2="19.07" y2="19.07"></line>
-              <line x1="2" y1="12" x2="6" y2="12"></line>
-              <line x1="18" y1="12" x2="22" y2="12"></line>
-              <line x1="4.93" y1="19.07" x2="7.76" y2="16.24"></line>
-              <line x1="16.24" y1="7.76" x2="19.07" y2="4.93"></line>
-            </svg>
-            <p>Loading data...</p>
-          </div>
-        \`;
+        html += "</ul>";
+        return new Response(html, { headers: { "Content-Type": "text/html" } });
       }
-      
-      try {
-        const res = await fetch(\`/api/tables/\${name}/data?page=\${page}&limit=\${pageSize}\`);
-        if (!res.ok) throw new Error(await res.text());
-        const response = await res.json();
-        
-        const rows = response.data || response;
-        totalRecords = response.total || 0;
-        totalPages = response.totalPages || 1;
-        
-        const tableSchema = tableSchemas[name];
-        
-        if (rows.length === 0) {
-          container.innerHTML = \`
-            <div class="empty-state">
-              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
-                <circle cx="12" cy="12" r="10"></circle>
-                <line x1="12" y1="8" x2="12" y2="12"></line>
-                <line x1="12" y1="16" x2="12.01" y2="16"></line>
-              </svg>
-              <h3>Table is Empty</h3>
-              <p>No records found in "\${name}"</p>
-            </div>
-          \`;
-          return;
-        }
-
-        // Use all columns from the actual data to ensure foreign keys and all data are shown
-        let columns = [];
-        const allKeys = new Set();
-        rows.forEach(row => {
-          Object.keys(row).forEach(key => allKeys.add(key));
-        });
-        
-        // Try to get type info from schema if available
-        const schemaColMap = {};
-        if (tableSchema && tableSchema.columns && tableSchema.columns.length > 0) {
-          tableSchema.columns.forEach(col => {
-            schemaColMap[col.name] = col;
-          });
+      if (req.method === "GET" && url.pathname.startsWith("/htmx/tables/")) {
+        const tableName = url.pathname.split("/")[3];
+        const schema = schemas2.find((s) => s.config.name === tableName);
+        if (!schema) {
+          return new Response(`<div class="p-4 text-red-500">Table not found</div>`, { status: 404, headers: { "Content-Type": "text/html" } });
         }
-        
-        columns = Array.from(allKeys).map(key => {
-          const schemaCol = schemaColMap[key];
-          let type = 'text';
-          
-          // First try to get type from schema
-          if (schemaCol && schemaCol.type) {
-            type = schemaCol.type;
-          } else if (rows[0] && rows[0][key] !== undefined) {
-            // Fallback to type detection from actual value
-            const val = rows[0][key];
-            if (typeof val === 'number') type = 'integer';
-            else if (typeof val === 'boolean') type = 'boolean';
-            else if (val instanceof Date) type = 'timestamptz';
-            else if (typeof val === 'string' && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val)) type = 'uuid';
-            else type = 'text';
-          }
-          
-          return {
-            name: key,
-            type,
-            primaryKey: schemaCol ? schemaCol.primaryKey : false,
-            foreignKey: schemaCol ? schemaCol.foreignKey : null
+        try {
+          const page = parseInt(url.searchParams.get("page") || "1", 10);
+          const limit = parseInt(url.searchParams.get("limit") || "25", 10);
+          const offset = (page - 1) * limit;
+          const countResult = await db2.select({ count: schema.table }).from(schema.table);
+          const total = Array.isArray(countResult) ? countResult.length : 0;
+          const totalPages = Math.ceil(total / limit) || 1;
+          const data = await db2.select().from(schema.table).limit(limit).offset(offset);
+          const formatValue = (val) => {
+            if (val === null || val === undefined)
+              return '<span class="italic text-muted-foreground">null</span>';
+            if (typeof val === "number")
+              return `<span class="text-foreground">${val}</span>`;
+            if (typeof val === "boolean")
+              return `<span class="text-foreground">${val}</span>`;
+            if (val instanceof Date)
+              return `<span class="text-foreground">${val.toISOString()}</span>`;
+            if (typeof val === "object")
+              return `<span class="text-foreground font-mono text-xs">${JSON.stringify(val).replace(/&/g, "&amp;").replace(/</g, "&lt;")}</span>`;
+            return `<span class="text-foreground">${String(val).replace(/&/g, "&amp;").replace(/</g, "&lt;")}</span>`;
           };
-        });
-        
-        let html = '<div class="data-grid-container"><div class="table-wrapper"><table><thead><tr>';
-        columns.forEach(col => {
-          html += \`
-            <th>
-              <div class="col-header">
-                <div class="col-name">
-                  \${col.name}
-                  \${col.primaryKey ? '<span class="pk-badge">PK</span>' : ''}
-                  \${col.foreignKey ? '<span class="fk-badge">FK</span>' : ''}
+          if (data.length === 0) {
+            return new Response(`
+              <div class="flex flex-col items-center justify-center h-full w-full text-muted-foreground animate-[fadeIn_0.5s_ease-out]">
+                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" class="w-16 h-16 mb-4 text-muted">
+                  <circle cx="12" cy="12" r="10"></circle>
+                  <line x1="12" y1="8" x2="12" y2="12"></line>
+                  <line x1="12" y1="16" x2="12.01" y2="16"></line>
+                </svg>
+                <h3 class="text-foreground m-0 mb-2 text-lg">Table is Empty</h3>
+                <p class="text-sm">No records found in "${tableName}"</p>
+              </div>
+            `, { headers: { "Content-Type": "text/html" } });
+          }
+          const columns2 = Object.keys(data[0] || {});
+          let html = '<div class="flex flex-col h-full w-full bg-background">';
+          html += '<div class="flex-1 overflow-auto">';
+          html += '<table class="text-left border-collapse text-sm whitespace-nowrap">';
+          html += "<thead><tr>";
+          columns2.forEach((col2) => {
+            const colConfig = schema.config.columns ? schema.config.columns[col2] : null;
+            let typeLabel = colConfig ? colConfig.dataType : "unknown";
+            let indexLabel = "";
+            if (colConfig?.primaryKey) {
+              indexLabel += '<span class="ml-1 text-[10px] bg-emerald-500/20 text-emerald-500 px-1 rounded uppercase" title="Primary Key">PK</span>';
+            }
+            if (colConfig?.unique) {
+              indexLabel += '<span class="ml-1 text-[10px] bg-amber-500/20 text-amber-500 px-1 rounded uppercase" title="Unique">UQ</span>';
+            }
+            if (colConfig?.references) {
+              indexLabel += '<span class="ml-1 text-[10px] bg-yellow-500/20 text-yellow-500 px-1 rounded uppercase" title="Foreign Key">FK</span>';
+            }
+            if (schema.config.indexes) {
+              const isIndexed = schema.config.indexes.some((idx) => idx.columns.includes(col2));
+              if (isIndexed) {
+                indexLabel += '<span class="ml-1 text-[10px] bg-blue-500/20 text-blue-500 px-1 rounded uppercase" title="Indexed">IDX</span>';
+              }
+            }
+            html += `<th class="bg-card border-b border-r border-border px-4 py-2.5 font-medium text-muted-foreground sticky top-0 z-10">
+              <div class="flex flex-col gap-0.5">
+                <span class="text-foreground">${col2}</span>
+                <div class="flex items-center flex-wrap gap-1 mt-0.5">
+                  <span class="text-[10px] font-mono text-muted-foreground/70 mr-1">${typeLabel}</span>
+                  ${indexLabel}
                 </div>
-                <div class="col-type">\${col.type}</div>
               </div>
-            </th>
-          \`;
-        });
-        html += '</tr></thead><tbody>';
-        
-        rows.forEach(row => {
-          html += '<tr>';
-          columns.forEach(col => {
-            html += \`<td>\${formatValue(row[col.name])}</td>\`;
+            </th>`;
           });
-          html += '</tr>';
-        });
-        
-        html += '</tbody></table>';
-        
-        // Add pagination inside the table wrapper to match table width
-        html += renderPagination();
-        
-        html += '</div></div>';
-        container.innerHTML = html;
-        
-        // Fade in the new content
-        const newTable = container.querySelector('.data-grid-container');
-        if (newTable) {
-          newTable.style.opacity = '0';
-          requestAnimationFrame(() => {
-            newTable.style.transition = 'opacity 0.15s ease';
-            newTable.style.opacity = '1';
+          html += "</tr></thead><tbody>";
+          data.forEach((row) => {
+            html += '<tr class="hover:bg-muted/50 transition-colors">';
+            columns2.forEach((col2) => {
+              html += `<td class="border-b border-r border-border px-4 py-2 max-w-[300px] overflow-hidden text-ellipsis">${formatValue(row[col2])}</td>`;
+            });
+            html += "</tr>";
           });
+          html += "</tbody></table></div>";
+          const startRecord = (page - 1) * limit + 1;
+          const endRecord = Math.min(page * limit, total);
+          html += `
+            <div class="flex items-center justify-between px-4 py-3 bg-card border-t border-border text-xs text-muted-foreground shrink-0 sticky bottom-0 z-10 w-full">
+              <div class="flex items-center gap-4">
+                <span>${total} records</span>
+                <span>${startRecord}-${endRecord}</span>
+              </div>
+              <div class="flex items-center gap-2">
+                <select 
+                  name="limit" 
+                  class="bg-background border border-border text-foreground px-2 py-1.5 rounded-md focus:outline-none focus:ring-1 focus:ring-ring cursor-pointer"
+                  @change="pageSize = $event.target.value; htmx.ajax('GET', '/htmx/tables/${tableName}?page=1&limit=' + pageSize, {target: '#data-container'})"
+                >
+                  <option value="10" ${limit === 10 ? "selected" : ""}>10</option>
+                  <option value="25" ${limit === 25 ? "selected" : ""}>25</option>
+                  <option value="50" ${limit === 50 ? "selected" : ""}>50</option>
+                  <option value="100" ${limit === 100 ? "selected" : ""}>100</option>
+                </select>
+                
+                <button 
+                  ${page <= 1 ? "disabled" : ""}
+                  hx-get="/htmx/tables/${tableName}?page=${page - 1}&limit=${limit}"
+                  hx-target="#data-container"
+                  class="bg-background border border-border text-foreground px-3 py-1.5 rounded-md hover:bg-accent hover:text-accent-foreground disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
+                >&larr;</button>
+                
+                <span class="min-w-[40px] text-center">${page} / ${totalPages}</span>
+                
+                <button 
+                  ${page >= totalPages ? "disabled" : ""}
+                  hx-get="/htmx/tables/${tableName}?page=${page + 1}&limit=${limit}"
+                  hx-target="#data-container"
+                  class="bg-background border border-border text-foreground px-3 py-1.5 rounded-md hover:bg-accent hover:text-accent-foreground disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
+                >&rarr;</button>
+              </div>
+            </div>
+          `;
+          html += "</div>";
+          return new Response(html, { headers: { "Content-Type": "text/html" } });
+        } catch (e) {
+          return new Response(`
+            <div class="p-6">
+              <div class="bg-red-500/10 border border-red-500/20 text-red-400 p-4 rounded-lg">
+                <h3 class="font-semibold mb-1">Error Loading Data</h3>
+                <p class="text-sm opacity-80">${e.message}</p>
+              </div>
+            </div>
+          `, { headers: { "Content-Type": "text/html" } });
         }
-        
-      } catch (e) {
-        container.innerHTML = \`
-          <div class="empty-state">
-            <svg viewBox="0 0 24 24" fill="none" stroke="#ef4444" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
-              <circle cx="12" cy="12" r="10"></circle>
-              <line x1="12" y1="8" x2="12" y2="12"></line>
-              <line x1="12" y1="16" x2="12.01" y2="16"></line>
-            </svg>
-            <h3 style="color: #ef4444;">Error Loading Data</h3>
-            <p>\${e.message}</p>
-          </div>
-        \`;
       }
-    }
-
-    function renderPagination() {
-      const startRecord = (currentPage - 1) * pageSize + 1;
-      const endRecord = Math.min(currentPage * pageSize, totalRecords);
-      
-      let html = '<div class="pagination">';
-      html += '<div class="pagination-info">';
-      html += \`<span>\${totalRecords} records</span>\`;
-      html += \`<span>\${startRecord}-\${endRecord}</span>\`;
-      html += '</div>';
-      
-      html += '<div class="pagination-controls">';
-      
-      // Page size selector
-      html += '<select class="page-size-select" onchange="changePageSize(this.value)">';
-      [10, 25, 50, 100].forEach(size => {
-        html += \`<option value="\${size}" \${pageSize === size ? 'selected' : ''}>\${size}</option>\`;
-      });
-      html += '</select>';
-      
-      // Previous button
-      html += \`<button class="pagination-btn" onclick="changePage(\${currentPage - 1})" \${currentPage === 1 ? 'disabled' : ''}>\u2190</button>\`;
-      
-      // Page indicator
-      html += \`<span style="min-width: 60px; text-align: center;">\${currentPage} / \${totalPages}</span>\`;
-      
-      // Next button
-      html += \`<button class="pagination-btn" onclick="changePage(\${currentPage + 1})" \${currentPage === totalPages ? 'disabled' : ''}>\u2192</button>\`;
-      
-      html += '</div>';
-      html += '</div>';
-      
-      return html;
-    }
-
-    function changePageSize(newSize) {
-      pageSize = parseInt(newSize, 10);
-      currentPage = 1;
-      selectTable(currentTable, currentPage);
-    }
-
-    function changePage(page) {
-      if (page < 1 || page > totalPages) return;
-      selectTable(currentTable, page);
-    }
-
-    document.getElementById('refresh-btn').addEventListener('click', async () => {
-      if (!currentTable) return;
-      
-      const icon = document.getElementById('refresh-icon');
-      icon.classList.add('spinning');
-      
-      try {
-        await selectTable(currentTable);
-      } catch (e) {
-        console.error("Failed to refresh data", e);
-      } finally {
-        setTimeout(() => { icon.classList.remove('spinning'); }, 500);
+      if (req.method === "GET" && url.pathname === "/") {
+        return new Response(indexHtml, {
+          headers: { "Content-Type": "text/html" }
+        });
       }
-    });
-
-    // Init
-    loadTables();
-  </script>
-</body>
-</html>
-`;
+      return new Response("Not found", { status: 404 });
+    }
+  });
+  intro(import_picocolors10.default.bgCyan(import_picocolors10.default.black(" \uD83D\uDC18 Bungres Studio ")));
+  log.success(`Studio is running at ${import_picocolors10.default.green(`http://localhost:${server.port}`)}`);
+  outro(import_picocolors10.default.gray("Press Ctrl+C to stop"));
+}
 
 // src/commands/tusky.ts
-import * as readline from "readline";
+var import_picocolors11 = __toESM(require_picocolors(), 1);
 async function runTusky(config) {
   const schemas = await loadSchemas(config.schema);
   const schemaObj = {};
@@ -3203,40 +4560,23 @@ async function runTusky(config) {
     schemaObj[s.exportName] = s.table;
   }
   const db = bungres({ url: config.dbUrl, schema: schemaObj });
-  console.log("=========================================");
-  console.log("\uD83D\uDC18 Welcome to Bungres REPL (Tusky)");
-  console.log("=========================================");
-  console.log(`
-Database connection established.`);
-  console.log(`
-Pre-loaded Context:`);
-  console.log("  - db      (Bungres Database Client)");
-  for (const s of schemas) {
-    console.log(`  - ${s.exportName} (Table)`);
-  }
-  console.log(`
-Example query: await db.select().from(users)`);
-  console.log(`Type .exit to quit.
-`);
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    prompt: "bungres> "
-  });
+  intro(import_picocolors11.default.bgCyan(import_picocolors11.default.black(" \uD83D\uDC18 Bungres REPL (Tusky) ")));
+  log.success(import_picocolors11.default.green("Database connection established."));
+  note(`Example: ${import_picocolors11.default.cyan("db.select().from(users);")}
+Exit:    ${import_picocolors11.default.cyan("exit")}`, "Commands");
   globalThis.db = db;
   for (const s of schemas) {
     globalThis[s.exportName] = s.table;
   }
-  rl.prompt();
-  rl.on("line", async (line) => {
+  process.stdout.write("bungres> ");
+  for await (const line of console) {
     const input = line.trim();
-    if (input === ".exit") {
-      rl.close();
-      return;
+    if (["exit", ".exit", "quit", ".quit", "exit()", "quit()"].includes(input.toLowerCase())) {
+      break;
     }
     if (!input) {
-      rl.prompt();
-      return;
+      process.stdout.write("bungres> ");
+      continue;
     }
     try {
       let code = input;
@@ -3245,22 +4585,32 @@ Example query: await db.select().from(users)`);
         console.log(`(Running as raw SQL: await db.raw(\`${input}\`))`);
         code = `(async () => { return await db.raw(\`${input}\`); })()`;
       } else if (input.includes("await ")) {
-        code = `(async () => { return ${input}; })()`;
+        code = `(async () => { return await ${input}; })()`;
       }
+      const start = performance.now();
       const result = await eval(code);
-      console.log(result);
+      const end = performance.now();
+      const duration = (end - start).toFixed(2);
+      if (Array.isArray(result) && result.length > 0 && typeof result[0] === "object") {
+        console.table(result);
+      } else {
+        console.log(result);
+      }
+      console.log(`
+(Execution time: ${duration}ms)`);
     } catch (err) {
       console.error(err.message || err);
     }
-    rl.prompt();
-  });
-  rl.on("close", () => {
-    process.exit(0);
-  });
+    process.stdout.write("bungres> ");
+  }
+  process.exit(0);
 }
 
+// src/cli.ts
+var import_picocolors12 = __toESM(require_picocolors(), 1);
+
 // src/config.ts
-import { join as join6, resolve as resolve7 } from "path";
+import { join as join7, resolve as resolve8 } from "path";
 var CONFIG_FILES = [
   "bungres.config.ts",
   "bungres.config.js",
@@ -3270,9 +4620,9 @@ var CONFIG_FILES = [
 async function loadConfig(cwd = process.cwd()) {
   let userConfig = {};
   for (const file of CONFIG_FILES) {
-    const configPath = join6(cwd, file);
+    const configPath = join7(cwd, file);
     if (await Bun.file(configPath).exists()) {
-      const mod = await import(resolve7(configPath));
+      const mod = await import(resolve8(configPath));
       userConfig = mod.default ?? mod;
       break;
     }
@@ -3334,7 +4684,7 @@ async function ensureDatabase2(dbUrl) {
 // package.json
 var package_default = {
   name: "@bungres/kit",
-  version: "0.6.1",
+  version: "0.7.0",
   description: "CLI toolkit for @bungres/orm \u2014 migrate, push, generate, pull",
   license: "MIT",
   engines: {
@@ -3384,7 +4734,9 @@ var package_default = {
     test: "bun test"
   },
   dependencies: {
-    "@bungres/orm": "workspace:*"
+    "@bungres/orm": "^0.6.0",
+    "@clack/prompts": "^1.7.0",
+    picocolors: "^1.1.1"
   },
   devDependencies: {
     "bun-types": "latest",
@@ -3395,15 +4747,16 @@ var package_default = {
 // src/cli.ts
 var VERSION = package_default.version;
 var HELP = `
-${colorize("\uD83D\uDC18 Bungres ORM CLI", "cyan")} v${VERSION}
+${import_picocolors12.default.cyan("\uD83D\uDC18 Bungres ORM CLI")} v${VERSION}
 
-${colorize("Usage:", "yellow")}
+${import_picocolors12.default.yellow("Usage:")}
   bungres <command> [options]
 
-${colorize("Commands:", "yellow")}
+${import_picocolors12.default.yellow("Commands:")}
   init          Initialize bungres project with config file and db folder structure
   generate      Generate SQL migration files from your schema definitions
   migrate       Run pending migration files against the database
+  rollback      Revert the last applied migration
   push          Apply schema directly to the DB (no migration files, dev mode)
   pull          Introspect the database and generate TypeScript schema
   status        Show applied vs. pending migrations
@@ -3414,17 +4767,18 @@ ${colorize("Commands:", "yellow")}
   tusky         Boot up a Node REPL connected to the database with schema loaded
   drop          Drop all tables defined in the schema (dev only)
 
-${colorize("Options:", "yellow")}
+${import_picocolors12.default.yellow("Options:")}
   --config      Path to config file (default: bungres.config.ts)
   --verbose     Enable verbose SQL logging
   --force       Skip confirmation prompts (use with drop)
   --version     Show version
   --help        Show this help
 
-${colorize("Examples:", "yellow")}
+${import_picocolors12.default.yellow("Examples:")}
   bungres init
   bungres generate
   bungres migrate
+  bungres rollback
   bungres push
   bungres pull
   bungres status
@@ -3454,7 +4808,7 @@ async function main() {
   const config2 = await loadConfig(process.cwd());
   if (flags.verbose)
     config2.verbose = true;
-  if (command && ["migrate", "push", "drop", "status", "fresh", "refresh"].includes(command)) {
+  if (command && ["migrate", "rollback", "push", "drop", "status", "fresh", "refresh"].includes(command)) {
     await ensureDatabase2(config2.dbUrl);
   }
   switch (command) {
@@ -3464,6 +4818,9 @@ async function main() {
     case "migrate":
       await runMigrate(config2);
       break;
+    case "rollback":
+      await runRollback(config2);
+      break;
     case "push":
       await runPush(config2, { force: !!flags.force });
       break;
@@ -3500,14 +4857,14 @@ async function main() {
 }
 function parseFlags(args) {
   const flags = {};
-  for (let i = 0;i < args.length; i++) {
-    const arg = args[i];
+  for (let i2 = 0;i2 < args.length; i2++) {
+    const arg = args[i2];
     if (arg?.startsWith("--")) {
       const key = arg.slice(2);
-      const next = args[i + 1];
+      const next = args[i2 + 1];
       if (next && !next.startsWith("--")) {
         flags[key] = next;
-        i++;
+        i2++;
       } else {
         flags[key] = true;
       }