@korajs/cli 0.1.0

package/dist/bin.cjs

@@ -0,0 +1,2170 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/bin.ts
+var import_citty5 = require("citty");
+
+// src/commands/create/create-command.ts
+var import_node_child_process2 = require("child_process");
+var import_node_fs = require("fs");
+var import_node_path3 = require("path");
+var import_node_url2 = require("url");
+var import_citty = require("citty");
+
+// src/errors.ts
+var import_core = require("@korajs/core");
+var ProjectExistsError = class extends import_core.KoraError {
+  constructor(directory) {
+    super(
+      `Directory "${directory}" already exists. Choose a different name or remove the existing directory.`,
+      "PROJECT_EXISTS",
+      { directory }
+    );
+    this.directory = directory;
+    this.name = "ProjectExistsError";
+  }
+  directory;
+};
+var SchemaNotFoundError = class extends import_core.KoraError {
+  constructor(searchedPaths) {
+    super(
+      `Could not find a schema file. Searched: ${searchedPaths.join(", ")}. Create a schema file using defineSchema() from @korajs/core.`,
+      "SCHEMA_NOT_FOUND",
+      { searchedPaths }
+    );
+    this.searchedPaths = searchedPaths;
+    this.name = "SchemaNotFoundError";
+  }
+  searchedPaths;
+};
+var InvalidProjectError = class extends import_core.KoraError {
+  constructor(directory) {
+    super(
+      `"${directory}" is not a valid Kora project. No package.json with a kora dependency found. Run this command from inside a Kora project.`,
+      "INVALID_PROJECT",
+      { directory }
+    );
+    this.directory = directory;
+    this.name = "InvalidProjectError";
+  }
+  directory;
+};
+var DevServerError = class extends import_core.KoraError {
+  constructor(binary, searchPath) {
+    super(
+      `Could not find required binary "${binary}" at ${searchPath}. Install project dependencies and try again.`,
+      "DEV_SERVER_ERROR",
+      { binary, searchPath }
+    );
+    this.binary = binary;
+    this.searchPath = searchPath;
+    this.name = "DevServerError";
+  }
+  binary;
+  searchPath;
+};
+
+// src/types.ts
+var PACKAGE_MANAGERS = ["pnpm", "npm", "yarn", "bun"];
+var TEMPLATES = ["react-basic", "react-sync"];
+var TEMPLATE_INFO = [
+  {
+    name: "react-basic",
+    label: "React (basic)",
+    description: "Local-only React app with Kora \u2014 no sync server"
+  },
+  {
+    name: "react-sync",
+    label: "React (with sync)",
+    description: "React app with Kora sync server included"
+  }
+];
+
+// src/utils/fs-helpers.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+async function directoryExists(path) {
+  try {
+    await (0, import_promises.access)(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findProjectRoot(startDir) {
+  let current = (0, import_node_path.resolve)(startDir ?? process.cwd());
+  for (; ; ) {
+    const pkgPath = (0, import_node_path.join)(current, "package.json");
+    try {
+      const content = await (0, import_promises.readFile)(pkgPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (isKoraProject(pkg)) {
+        return current;
+      }
+    } catch {
+    }
+    const parent = (0, import_node_path.dirname)(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+async function findSchemaFile(projectRoot) {
+  const candidates = [
+    (0, import_node_path.join)(projectRoot, "src", "schema.ts"),
+    (0, import_node_path.join)(projectRoot, "schema.ts"),
+    (0, import_node_path.join)(projectRoot, "src", "schema.js"),
+    (0, import_node_path.join)(projectRoot, "schema.js")
+  ];
+  for (const candidate of candidates) {
+    try {
+      await (0, import_promises.access)(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+async function resolveProjectBinary(projectRoot, binaryName) {
+  const binaryPath = (0, import_node_path.join)(projectRoot, "node_modules", ".bin", binaryName);
+  try {
+    await (0, import_promises.access)(binaryPath);
+    return binaryPath;
+  } catch {
+    return null;
+  }
+}
+function isKoraProject(pkg) {
+  if (typeof pkg !== "object" || pkg === null) return false;
+  const record = pkg;
+  return hasKoraDep(record.dependencies) || hasKoraDep(record.devDependencies);
+}
+function hasKoraDep(deps) {
+  if (typeof deps !== "object" || deps === null) return false;
+  return Object.keys(deps).some((key) => key === "kora" || key.startsWith("@korajs/"));
+}
+
+// src/utils/logger.ts
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var CYAN = "\x1B[36m";
+function createLogger(options) {
+  const colorDisabled = options?.noColor === true || process.env.NO_COLOR !== void 0 || !process.stdout.isTTY;
+  function color(code, text) {
+    return colorDisabled ? text : `${code}${text}${RESET}`;
+  }
+  return {
+    info(message) {
+      console.log(color(CYAN, message));
+    },
+    success(message) {
+      console.log(color(GREEN, `  \u2713 ${message}`));
+    },
+    warn(message) {
+      console.warn(color(YELLOW, `  \u26A0 ${message}`));
+    },
+    error(message) {
+      console.error(color(RED, `  \u2717 ${message}`));
+    },
+    step(message) {
+      console.log(color(DIM, `  ${message}`));
+    },
+    blank() {
+      console.log();
+    },
+    banner() {
+      console.log();
+      console.log(
+        color(BOLD + CYAN, "  Kora.js") + color(DIM, " \u2014 Offline-first application framework")
+      );
+      console.log();
+    }
+  };
+}
+
+// src/utils/package-manager.ts
+var import_node_child_process = require("child_process");
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent;
+  if (!userAgent) return "npm";
+  if (userAgent.startsWith("pnpm/")) return "pnpm";
+  if (userAgent.startsWith("yarn/")) return "yarn";
+  if (userAgent.startsWith("bun/")) return "bun";
+  return "npm";
+}
+function getInstallCommand(pm) {
+  return pm === "yarn" ? "yarn" : `${pm} install`;
+}
+function getRunDevCommand(pm) {
+  if (pm === "npm") return "npm run dev";
+  return `${pm} dev`;
+}
+
+// src/utils/prompt.ts
+var import_node_readline = require("readline");
+function promptText(message, defaultValue, options) {
+  return new Promise((resolve7) => {
+    const rl = createReadline(options);
+    const suffix = defaultValue !== void 0 ? ` (${defaultValue})` : "";
+    rl.question(`  ? ${message}${suffix}: `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      resolve7(trimmed || defaultValue || "");
+    });
+  });
+}
+function promptSelect(message, choices, options) {
+  return new Promise((resolve7) => {
+    const rl = createReadline(options);
+    const out = options?.output ?? process.stdout;
+    out.write(`  ? ${message}
+`);
+    for (let i = 0; i < choices.length; i++) {
+      const choice = choices[i];
+      if (choice) {
+        out.write(`    ${i + 1}) ${choice.label}
+`);
+      }
+    }
+    const ask = () => {
+      rl.question("  > ", (answer) => {
+        const index = Number.parseInt(answer.trim(), 10) - 1;
+        const selected = choices[index];
+        if (selected) {
+          rl.close();
+          resolve7(selected.value);
+        } else {
+          out.write(`  Please enter a number between 1 and ${choices.length}
+`);
+          ask();
+        }
+      });
+    };
+    ask();
+  });
+}
+function promptConfirm(message, defaultValue = false, options) {
+  return new Promise((resolve7) => {
+    const rl = createReadline(options);
+    const suffix = defaultValue ? "Y/n" : "y/N";
+    const ask = () => {
+      rl.question(`  ? ${message} (${suffix}): `, (answer) => {
+        const normalized = answer.trim().toLowerCase();
+        if (normalized.length === 0) {
+          rl.close();
+          resolve7(defaultValue);
+          return;
+        }
+        if (normalized === "y" || normalized === "yes") {
+          rl.close();
+          resolve7(true);
+          return;
+        }
+        if (normalized === "n" || normalized === "no") {
+          rl.close();
+          resolve7(false);
+          return;
+        }
+        (options?.output ?? process.stdout).write("  Please answer with y or n\n");
+        ask();
+      });
+    };
+    ask();
+  });
+}
+function createReadline(options) {
+  return (0, import_node_readline.createInterface)({
+    input: options?.input ?? process.stdin,
+    output: options?.output ?? process.stdout
+  });
+}
+
+// src/commands/create/template-engine.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+var import_node_url = require("url");
+var import_meta = {};
+function substituteVariables(template, context) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
+    const value = context[key];
+    return value !== void 0 ? value : `{{${key}}}`;
+  });
+}
+function getTemplatePath(templateName) {
+  const currentDir = (0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+  return (0, import_node_path2.resolve)(currentDir, "..", "..", "..", "templates", templateName);
+}
+async function scaffoldTemplate(templateName, targetDir, context) {
+  const templateDir = getTemplatePath(templateName);
+  const vars = {
+    projectName: context.projectName,
+    packageManager: context.packageManager,
+    koraVersion: context.koraVersion
+  };
+  await copyDirectory(templateDir, targetDir, vars);
+}
+async function copyDirectory(src, dest, vars) {
+  await (0, import_promises2.mkdir)(dest, { recursive: true });
+  const entries = await (0, import_promises2.readdir)(src);
+  for (const entry of entries) {
+    const srcPath = (0, import_node_path2.join)(src, entry);
+    const srcStat = await (0, import_promises2.stat)(srcPath);
+    if (srcStat.isDirectory()) {
+      await copyDirectory(srcPath, (0, import_node_path2.join)(dest, entry), vars);
+    } else if (entry.endsWith(".hbs")) {
+      const content = await (0, import_promises2.readFile)(srcPath, "utf-8");
+      const outputName = entry.slice(0, -4);
+      await (0, import_promises2.writeFile)((0, import_node_path2.join)(dest, outputName), substituteVariables(content, vars), "utf-8");
+    } else {
+      await (0, import_promises2.copyFile)(srcPath, (0, import_node_path2.join)(dest, entry));
+    }
+  }
+}
+
+// src/commands/create/create-command.ts
+var import_meta2 = {};
+var createCommand = (0, import_citty.defineCommand)({
+  meta: {
+    name: "create",
+    description: "Create a new Kora application"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Project directory name",
+      required: false
+    },
+    template: {
+      type: "string",
+      description: "Project template (react-basic, react-sync)"
+    },
+    pm: {
+      type: "string",
+      description: "Package manager (pnpm, npm, yarn, bun)"
+    },
+    "skip-install": {
+      type: "boolean",
+      description: "Skip installing dependencies",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const logger = createLogger();
+    logger.banner();
+    const projectName = args.name || await promptText("Project name", "my-kora-app");
+    if (!projectName) {
+      logger.error("Project name is required");
+      process.exitCode = 1;
+      return;
+    }
+    let template;
+    if (args.template && isValidTemplate(args.template)) {
+      template = args.template;
+    } else {
+      template = await promptSelect(
+        "Select a template:",
+        TEMPLATE_INFO.map((t) => ({ label: `${t.label} \u2014 ${t.description}`, value: t.name }))
+      );
+    }
+    let pm;
+    if (args.pm && isValidPackageManager(args.pm)) {
+      pm = args.pm;
+    } else {
+      const detected = detectPackageManager();
+      pm = await promptSelect(
+        "Package manager:",
+        PACKAGE_MANAGERS.map((p) => ({
+          label: p === detected ? `${p} (detected)` : p,
+          value: p
+        }))
+      );
+    }
+    const targetDir = (0, import_node_path3.resolve)(process.cwd(), projectName);
+    if (await directoryExists(targetDir)) {
+      throw new ProjectExistsError(projectName);
+    }
+    const koraVersion = resolveKoraVersion();
+    logger.step(`Creating ${projectName} with ${template} template...`);
+    await scaffoldTemplate(template, targetDir, {
+      projectName,
+      packageManager: pm,
+      koraVersion
+    });
+    logger.success("Project scaffolded");
+    if (!args["skip-install"]) {
+      logger.step("Installing dependencies...");
+      try {
+        (0, import_node_child_process2.execSync)(getInstallCommand(pm), { cwd: targetDir, stdio: "inherit" });
+        logger.success("Dependencies installed");
+      } catch {
+        logger.warn("Failed to install dependencies. Run install manually.");
+      }
+    }
+    logger.blank();
+    logger.info("Done! Next steps:");
+    logger.blank();
+    logger.step(`  cd ${projectName}`);
+    logger.step(`  ${getRunDevCommand(pm)}`);
+    logger.blank();
+  }
+});
+function isValidTemplate(value) {
+  return TEMPLATES.includes(value);
+}
+function isValidPackageManager(value) {
+  return PACKAGE_MANAGERS.includes(value);
+}
+function resolveKoraVersion() {
+  try {
+    const cliDir = (0, import_node_path3.resolve)((0, import_node_path3.dirname)((0, import_node_url2.fileURLToPath)(import_meta2.url)), "..", "..", "..");
+    const pkg = JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path3.resolve)(cliDir, "package.json"), "utf-8"));
+    return pkg.version === "0.0.0" ? "latest" : `^${pkg.version}`;
+  } catch {
+    return "latest";
+  }
+}
+
+// src/commands/dev/dev-command.ts
+var import_promises4 = require("fs/promises");
+var import_node_path5 = require("path");
+var import_node_path6 = require("path");
+var import_citty2 = require("citty");
+
+// src/commands/dev/kora-config.ts
+var import_node_child_process3 = require("child_process");
+var import_promises3 = require("fs/promises");
+var import_node_path4 = require("path");
+var import_node_url3 = require("url");
+var CONFIG_CANDIDATES = [
+  "kora.config.ts",
+  "kora.config.mts",
+  "kora.config.cts",
+  "kora.config.js",
+  "kora.config.mjs",
+  "kora.config.cjs"
+];
+async function loadKoraConfig(projectRoot) {
+  const configPath = await findKoraConfigFile(projectRoot);
+  if (!configPath) return null;
+  const ext = (0, import_node_path4.extname)(configPath);
+  if (ext === ".ts" || ext === ".mts" || ext === ".cts") {
+    const loaded2 = await loadTypeScriptConfig(configPath, projectRoot);
+    return toConfigObject(loaded2);
+  }
+  const loaded = await import((0, import_node_url3.pathToFileURL)(configPath).href);
+  return toConfigObject(loaded);
+}
+async function findKoraConfigFile(projectRoot) {
+  for (const file of CONFIG_CANDIDATES) {
+    const candidate = (0, import_node_path4.join)(projectRoot, file);
+    try {
+      await (0, import_promises3.access)(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+async function loadTypeScriptConfig(configPath, projectRoot) {
+  const tsxBinary = await resolveProjectBinary(projectRoot, "tsx");
+  if (!tsxBinary) {
+    throw new Error(
+      `Found TypeScript config at ${configPath}, but "tsx" is not installed in this project. Install tsx or use kora.config.js.`
+    );
+  }
+  const script = [
+    "import { pathToFileURL } from 'node:url'",
+    "const configPath = process.argv[process.argv.length - 1]",
+    "const mod = await import(pathToFileURL(configPath).href)",
+    "const value = mod.default ?? mod",
+    "process.stdout.write(JSON.stringify(value))"
+  ].join(";");
+  const output = await runCommand(tsxBinary, ["--eval", script, configPath], projectRoot);
+  try {
+    return JSON.parse(output);
+  } catch {
+    throw new Error(`Failed to parse ${configPath} output as JSON.`);
+  }
+}
+async function runCommand(command, args, cwd) {
+  return await new Promise((resolve7, reject) => {
+    const child = (0, import_node_child_process3.spawn)(command, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf-8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve7(stdout.trim());
+        return;
+      }
+      reject(new Error(`Failed to load kora config (exit ${code ?? "unknown"}): ${stderr.trim()}`));
+    });
+  });
+}
+function toConfigObject(mod) {
+  if (typeof mod !== "object" || mod === null) {
+    throw new Error("kora config must export an object.");
+  }
+  const value = mod.default ?? mod;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("kora config must export an object.");
+  }
+  return value;
+}
+
+// src/commands/dev/process-manager.ts
+var import_node_child_process4 = require("child_process");
+var ProcessManager = class {
+  processes = /* @__PURE__ */ new Map();
+  spawn(config) {
+    const options = {
+      cwd: config.cwd,
+      env: { ...process.env, ...config.env },
+      stdio: ["ignore", "pipe", "pipe"]
+    };
+    const child = (0, import_node_child_process4.spawn)(config.command, config.args, options);
+    let resolveExit;
+    const runningProcess = {
+      child,
+      exitPromise: new Promise((resolve7) => {
+        resolveExit = resolve7;
+      }),
+      stdoutBuffer: "",
+      stderrBuffer: ""
+    };
+    this.processes.set(config.label, runningProcess);
+    child.stdout?.on("data", (chunk) => {
+      runningProcess.stdoutBuffer = this.writeChunk(
+        config.label,
+        runningProcess.stdoutBuffer,
+        chunk,
+        false
+      );
+    });
+    child.stderr?.on("data", (chunk) => {
+      runningProcess.stderrBuffer = this.writeChunk(
+        config.label,
+        runningProcess.stderrBuffer,
+        chunk,
+        true
+      );
+    });
+    child.on("exit", (code, signal) => {
+      this.flushBuffer(config.label, runningProcess.stdoutBuffer, false);
+      this.flushBuffer(config.label, runningProcess.stderrBuffer, true);
+      this.processes.delete(config.label);
+      config.onExit?.(code, signal);
+      resolveExit?.();
+    });
+  }
+  hasRunning() {
+    return this.processes.size > 0;
+  }
+  async shutdownAll() {
+    const running = Array.from(this.processes.values());
+    if (running.length === 0) return;
+    for (const processEntry of running) {
+      processEntry.child.kill("SIGTERM");
+    }
+    await Promise.race([Promise.all(running.map((entry) => entry.exitPromise)), delay(5e3)]);
+    const remaining = Array.from(this.processes.values());
+    if (remaining.length === 0) return;
+    for (const processEntry of remaining) {
+      processEntry.child.kill("SIGKILL");
+    }
+    await Promise.all(remaining.map((entry) => entry.exitPromise));
+  }
+  writeChunk(label, buffer, chunk, isError) {
+    const combined = `${buffer}${chunk.toString("utf-8")}`;
+    const lines = combined.split(/\r?\n/);
+    const remaining = lines.pop() ?? "";
+    for (const line of lines) {
+      this.writeLine(label, line, isError);
+    }
+    return remaining;
+  }
+  flushBuffer(label, buffer, isError) {
+    if (!buffer) return;
+    this.writeLine(label, buffer, isError);
+  }
+  writeLine(label, line, isError) {
+    const stream = isError ? process.stderr : process.stdout;
+    stream.write(`[${label}] ${line}
+`);
+  }
+};
+function delay(ms) {
+  return new Promise((resolve7) => {
+    setTimeout(resolve7, ms);
+  });
+}
+
+// src/commands/dev/schema-watcher.ts
+var import_node_child_process5 = require("child_process");
+var import_node_fs2 = require("fs");
+var SchemaWatcher = class {
+  constructor(config) {
+    this.config = config;
+    this.debounceMs = config.debounceMs ?? 300;
+  }
+  config;
+  debounceMs;
+  watcher = null;
+  debounceTimer = null;
+  start() {
+    if (this.watcher) return;
+    this.watcher = (0, import_node_fs2.watch)(this.config.schemaPath, () => {
+      this.scheduleRegeneration();
+    });
+    this.watcher.on("error", (error) => {
+      this.config.onError?.(toError(error));
+    });
+  }
+  stop() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    this.watcher?.close();
+    this.watcher = null;
+  }
+  async regenerate() {
+    const koraBinary = await resolveProjectBinary(this.config.projectRoot, "kora");
+    if (!koraBinary) {
+      throw new Error('Could not find project binary "kora" in node_modules/.bin.');
+    }
+    const tsxBinary = await resolveProjectBinary(this.config.projectRoot, "tsx");
+    if (!tsxBinary) {
+      process.stderr.write('[kora] Could not find "tsx" binary. Falling back to node.\n');
+    }
+    const command = tsxBinary ?? process.execPath;
+    const args = [koraBinary, "generate", "types", "--schema", this.config.schemaPath];
+    await spawnCommand(command, args, this.config.projectRoot);
+    this.config.onRegenerate?.();
+  }
+  scheduleRegeneration() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = null;
+      void this.regenerate().catch((error) => {
+        this.config.onError?.(toError(error));
+      });
+    }, this.debounceMs);
+  }
+};
+async function spawnCommand(command, args, cwd) {
+  await new Promise((resolve7, reject) => {
+    const child = (0, import_node_child_process5.spawn)(command, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env
+    });
+    child.stdout?.on("data", (chunk) => {
+      writePrefixedLines(chunk, false);
+    });
+    child.stderr?.on("data", (chunk) => {
+      writePrefixedLines(chunk, true);
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve7();
+        return;
+      }
+      reject(new Error(`Type generation exited with code ${code ?? "unknown"}.`));
+    });
+  });
+}
+function writePrefixedLines(chunk, isError) {
+  const text = chunk.toString("utf-8");
+  const lines = text.split(/\r?\n/).filter((line) => line.length > 0);
+  const stream = isError ? process.stderr : process.stdout;
+  for (const line of lines) {
+    stream.write(`[kora] ${line}
+`);
+  }
+}
+function toError(error) {
+  if (error instanceof Error) return error;
+  return new Error(String(error));
+}
+
+// src/commands/dev/dev-command.ts
+var devCommand = (0, import_citty2.defineCommand)({
+  meta: {
+    name: "dev",
+    description: "Start the Kora development environment"
+  },
+  args: {
+    port: {
+      type: "string",
+      description: "Vite dev server port"
+    },
+    "sync-port": {
+      type: "string",
+      description: "Kora sync server port"
+    },
+    "no-sync": {
+      type: "boolean",
+      description: "Disable sync server startup",
+      default: false
+    },
+    "no-watch": {
+      type: "boolean",
+      description: "Disable schema file watching",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const logger = createLogger();
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot) {
+      throw new InvalidProjectError(process.cwd());
+    }
+    const config = await loadKoraConfig(projectRoot);
+    const vitePort = typeof args.port === "string" ? args.port : String(config?.dev?.port ?? 5173);
+    const syncPortFromConfig = typeof config?.dev?.sync === "object" && typeof config.dev.sync.port === "number" ? config.dev.sync.port : 3001;
+    const syncPort = typeof args["sync-port"] === "string" ? args["sync-port"] : String(syncPortFromConfig);
+    const configSyncEnabled = config?.dev?.sync === void 0 || config.dev.sync === true || typeof config.dev.sync === "object" && config.dev.sync.enabled !== false;
+    const configWatchEnabled = config?.dev?.watch === void 0 || config.dev.watch === true || typeof config.dev.watch === "object" && config.dev.watch.enabled !== false;
+    const watchDebounceMs = typeof config?.dev?.watch === "object" && typeof config.dev.watch.debounceMs === "number" ? config.dev.watch.debounceMs : 300;
+    const viteBinary = await resolveProjectBinary(projectRoot, "vite");
+    if (!viteBinary) {
+      throw new DevServerError("vite", (0, import_node_path5.join)(projectRoot, "node_modules", ".bin", "vite"));
+    }
+    const syncServerFile = await findSyncServerFile(projectRoot);
+    let managedSyncStore = normalizeManagedSyncStore(config, projectRoot);
+    const postgresEnvRequested = isPostgresEnvRequested(config);
+    const syncAllowed = args["no-sync"] !== true && configSyncEnabled;
+    let shouldStartSync = syncAllowed && (syncServerFile !== null || managedSyncStore !== null);
+    let syncBinary = null;
+    if (shouldStartSync && syncServerFile !== null) {
+      syncBinary = await resolveProjectBinary(projectRoot, "tsx");
+      if (!syncBinary) {
+        logger.warn('Sync server detected, but local "tsx" binary was not found. Skipping sync.');
+      }
+    }
+    if (shouldStartSync && syncServerFile === null && managedSyncStore) {
+      const hasServerPackage = await fileExists(
+        (0, import_node_path5.join)(projectRoot, "node_modules", "@kora", "server", "package.json")
+      );
+      if (!hasServerPackage) {
+        logger.warn(
+          "Managed sync is configured, but @korajs/server is not installed. Install it or add server.ts."
+        );
+        managedSyncStore = null;
+        shouldStartSync = syncAllowed && (syncServerFile !== null || managedSyncStore !== null);
+      }
+    }
+    if (syncAllowed && syncServerFile === null && managedSyncStore === null && postgresEnvRequested) {
+      logger.warn(
+        "Managed postgres sync requested but no connection string found. Set dev.sync.store.connectionString or DATABASE_URL."
+      );
+    }
+    let configuredSchemaPath = null;
+    if (typeof config?.schema === "string") {
+      const candidate = (0, import_node_path6.resolve)(projectRoot, config.schema);
+      if (await fileExists(candidate)) {
+        configuredSchemaPath = candidate;
+      } else {
+        logger.warn(`Configured schema file not found: ${candidate}. Falling back to auto-detection.`);
+      }
+    }
+    const schemaPath = configuredSchemaPath ?? await findSchemaFile(projectRoot);
+    const watchEnabled = args["no-watch"] !== true && configWatchEnabled && schemaPath !== null;
+    const processManager = new ProcessManager();
+    let schemaWatcher = null;
+    let shuttingDown = false;
+    let resolveFinished;
+    const finished = new Promise((resolve7) => {
+      resolveFinished = resolve7;
+    });
+    const onManagedProcessExit = () => {
+      if (!processManager.hasRunning() && !shuttingDown) {
+        resolveFinished?.();
+      }
+    };
+    const shutdown = async () => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      schemaWatcher?.stop();
+      await processManager.shutdownAll();
+      resolveFinished?.();
+    };
+    const onSigInt = () => {
+      void shutdown();
+    };
+    const onSigTerm = () => {
+      void shutdown();
+    };
+    process.on("SIGINT", onSigInt);
+    process.on("SIGTERM", onSigTerm);
+    logger.banner();
+    logger.info("Starting development environment:");
+    logger.blank();
+    logger.step(`  Vite dev server on port ${vitePort}`);
+    if (shouldStartSync && syncBinary && syncServerFile) {
+      logger.step(`  Sync server on port ${syncPort}`);
+    } else if (shouldStartSync && syncServerFile === null && managedSyncStore !== null) {
+      logger.step(`  Managed sync server on port ${syncPort} (${managedSyncStore.type})`);
+    } else if (syncAllowed && syncServerFile === null) {
+      logger.step("  Sync server configured but no server.ts/server.js or managed store found");
+    } else if (!syncAllowed) {
+      logger.step("  Sync server disabled via --no-sync");
+    }
+    if (watchEnabled && schemaPath) {
+      logger.step(`  Schema watcher enabled (${schemaPath})`);
+    } else if (args["no-watch"] === true) {
+      logger.step("  Schema watcher disabled via --no-watch");
+    } else {
+      logger.step("  Schema watcher disabled (schema.ts not found)");
+    }
+    logger.blank();
+    processManager.spawn({
+      label: "vite",
+      command: viteBinary,
+      args: ["--port", String(vitePort)],
+      cwd: projectRoot,
+      onExit: onManagedProcessExit
+    });
+    if (shouldStartSync && syncBinary && syncServerFile) {
+      processManager.spawn({
+        label: "sync",
+        command: syncBinary,
+        args: [syncServerFile],
+        cwd: projectRoot,
+        env: {
+          PORT: String(syncPort),
+          KORA_SYNC_PORT: String(syncPort)
+        },
+        onExit: onManagedProcessExit
+      });
+    }
+    if (shouldStartSync && syncServerFile === null && managedSyncStore !== null) {
+      processManager.spawn({
+        label: "sync",
+        command: process.execPath,
+        args: ["--input-type=module", "--eval", MANAGED_SYNC_BOOTSTRAP_SCRIPT],
+        cwd: projectRoot,
+        env: {
+          KORA_DEV_SYNC_CONFIG: JSON.stringify({
+            port: Number(syncPort),
+            store: managedSyncStore
+          })
+        },
+        onExit: onManagedProcessExit
+      });
+    }
+    if (watchEnabled && schemaPath) {
+      schemaWatcher = new SchemaWatcher({
+        schemaPath,
+        projectRoot,
+        debounceMs: watchDebounceMs,
+        onRegenerate: () => {
+          logger.success("Regenerated types from schema changes");
+        },
+        onError: (error) => {
+          logger.error(`Schema watcher error: ${error.message}`);
+        }
+      });
+      schemaWatcher.start();
+    }
+    await finished;
+    process.off("SIGINT", onSigInt);
+    process.off("SIGTERM", onSigTerm);
+  }
+});
+async function findSyncServerFile(projectRoot) {
+  const candidates = [(0, import_node_path5.join)(projectRoot, "server.ts"), (0, import_node_path5.join)(projectRoot, "server.js")];
+  for (const candidate of candidates) {
+    try {
+      await (0, import_promises4.access)(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+async function fileExists(path) {
+  try {
+    await (0, import_promises4.access)(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeManagedSyncStore(config, projectRoot) {
+  const sync = config?.dev?.sync;
+  if (typeof sync !== "object" || sync === null) return null;
+  const store = sync.store;
+  if (store === void 0) return { type: "memory" };
+  if (store === "memory") return { type: "memory" };
+  if (store === "sqlite") return { type: "sqlite", filename: (0, import_node_path5.join)(projectRoot, "kora-sync.db") };
+  if (store === "postgres") {
+    const connectionString = process.env.DATABASE_URL;
+    if (!connectionString) return null;
+    return { type: "postgres", connectionString };
+  }
+  if (typeof store === "object" && store !== null) {
+    if (store.type === "memory") return { type: "memory" };
+    if (store.type === "sqlite") {
+      const filename = typeof store.filename === "string" && store.filename.length > 0 ? (0, import_node_path6.resolve)(projectRoot, store.filename) : (0, import_node_path5.join)(projectRoot, "kora-sync.db");
+      return { type: "sqlite", filename };
+    }
+    if (store.type === "postgres" && typeof store.connectionString === "string") {
+      return { type: "postgres", connectionString: store.connectionString };
+    }
+  }
+  return null;
+}
+function isPostgresEnvRequested(config) {
+  const sync = config?.dev?.sync;
+  if (typeof sync !== "object" || sync === null) return false;
+  if (sync.store === "postgres") return true;
+  if (typeof sync.store === "object" && sync.store !== null && sync.store.type === "postgres") return true;
+  return false;
+}
+var MANAGED_SYNC_BOOTSTRAP_SCRIPT = `
+const config = JSON.parse(process.env.KORA_DEV_SYNC_CONFIG ?? '{}');
+const {
+  createKoraServer,
+  MemoryServerStore,
+  createSqliteServerStore,
+  createPostgresServerStore,
+} = await import('@korajs/server');
+const storeConfig = config.store ?? { type: 'memory' };
+let store;
+if (storeConfig.type === 'memory') {
+  store = new MemoryServerStore();
+} else if (storeConfig.type === 'sqlite') {
+  const filename = typeof storeConfig.filename === 'string' && storeConfig.filename.length > 0
+    ? storeConfig.filename
+    : './kora-sync.db';
+  store = createSqliteServerStore({ filename });
+} else if (storeConfig.type === 'postgres') {
+  if (typeof storeConfig.connectionString !== 'string' || storeConfig.connectionString.length === 0) {
+    throw new Error('Managed postgres sync requires a connectionString');
+  }
+  store = await createPostgresServerStore({
+    connectionString: storeConfig.connectionString,
+  });
+} else {
+  throw new Error('Unsupported managed sync store type: ' + String(storeConfig.type));
+}
+const server = createKoraServer({ store, port: Number(config.port ?? 3001) });
+const shutdown = async () => {
+  try {
+    await server.stop();
+  } catch {
+  }
+  process.exit(0);
+};
+process.on('SIGINT', () => {
+  void shutdown();
+});
+process.on('SIGTERM', () => {
+  void shutdown();
+});
+await server.start();
+process.stdout.write('Managed sync server running on ws://localhost:' + String(config.port ?? 3001) + '\\n');
+await new Promise(() => {});
+`;
+
+// src/commands/generate/generate-command.ts
+var import_promises5 = require("fs/promises");
+var import_node_path7 = require("path");
+var import_citty3 = require("citty");
+
+// src/commands/generate/type-generator.ts
+function generateTypes(schema) {
+  const lines = [
+    "// Auto-generated by @korajs/cli \u2014 do not edit manually",
+    `// Generated from schema version ${String(schema.version)}`,
+    ""
+  ];
+  const collectionNames = Object.keys(schema.collections);
+  if (collectionNames.length === 0) {
+    return lines.join("\n");
+  }
+  for (const [name, collection] of Object.entries(schema.collections)) {
+    const pascal = toPascalCase(name);
+    const fields = collection.fields;
+    lines.push(`export interface ${pascal}Record {`);
+    lines.push("	readonly id: string");
+    for (const [fieldName, descriptor] of Object.entries(fields)) {
+      const tsType = fieldKindToTypeScript(descriptor);
+      const optional = !descriptor.required && !descriptor.auto ? "?" : "";
+      lines.push(`	readonly ${fieldName}${optional}: ${tsType}`);
+    }
+    lines.push("}");
+    lines.push("");
+    lines.push(`export interface ${pascal}InsertInput {`);
+    for (const [fieldName, descriptor] of Object.entries(fields)) {
+      if (descriptor.auto) continue;
+      const tsType = fieldKindToTypeScript(descriptor);
+      const optional = !descriptor.required || descriptor.defaultValue !== void 0 ? "?" : "";
+      lines.push(`	${fieldName}${optional}: ${tsType}`);
+    }
+    lines.push("}");
+    lines.push("");
+    lines.push(`export interface ${pascal}UpdateInput {`);
+    for (const [fieldName, descriptor] of Object.entries(fields)) {
+      if (descriptor.auto) continue;
+      const tsType = fieldKindToTypeScript(descriptor);
+      lines.push(`	${fieldName}?: ${tsType}`);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function fieldKindToTypeScript(descriptor) {
+  switch (descriptor.kind) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "timestamp":
+      return "number";
+    case "richtext":
+      return "string";
+    case "enum": {
+      if (descriptor.enumValues && descriptor.enumValues.length > 0) {
+        return descriptor.enumValues.map((v) => `'${v}'`).join(" | ");
+      }
+      return "string";
+    }
+    case "array": {
+      const itemType = itemKindToTypeScript(descriptor.itemKind);
+      return `Array<${itemType}>`;
+    }
+    default:
+      return "unknown";
+  }
+}
+function itemKindToTypeScript(kind) {
+  switch (kind) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "timestamp":
+      return "number";
+    case "richtext":
+      return "string";
+    case "enum":
+      return "string";
+    case "array":
+      return "unknown[]";
+    default:
+      return "unknown";
+  }
+}
+function toPascalCase(name) {
+  return name.split(/[_-]/).map((part) => {
+    if (part.length === 0) return "";
+    const first = part[0];
+    return first ? first.toUpperCase() + part.slice(1) : "";
+  }).join("");
+}
+
+// src/commands/generate/generate-command.ts
+var generateCommand = (0, import_citty3.defineCommand)({
+  meta: {
+    name: "generate",
+    description: "Generate code from your Kora schema"
+  },
+  subCommands: {
+    types: (0, import_citty3.defineCommand)({
+      meta: {
+        name: "types",
+        description: "Generate TypeScript types from your schema"
+      },
+      args: {
+        schema: {
+          type: "string",
+          description: "Path to schema file"
+        },
+        output: {
+          type: "string",
+          description: "Output file path",
+          default: "kora/generated/types.ts"
+        }
+      },
+      async run({ args }) {
+        const logger = createLogger();
+        const projectRoot = await findProjectRoot();
+        if (!projectRoot) {
+          throw new InvalidProjectError(process.cwd());
+        }
+        let schemaPath;
+        if (args.schema && typeof args.schema === "string") {
+          schemaPath = (0, import_node_path7.resolve)(args.schema);
+        } else {
+          const found = await findSchemaFile(projectRoot);
+          if (!found) {
+            throw new SchemaNotFoundError([
+              "src/schema.ts",
+              "schema.ts",
+              "src/schema.js",
+              "schema.js"
+            ]);
+          }
+          schemaPath = found;
+        }
+        logger.step(`Reading schema from ${schemaPath}...`);
+        const schemaModule = await import(schemaPath);
+        const schema = extractSchema(schemaModule);
+        if (!schema) {
+          logger.error("Schema file must export a SchemaDefinition as the default export.");
+          process.exitCode = 1;
+          return;
+        }
+        const output = generateTypes(schema);
+        const outputFile = typeof args.output === "string" ? args.output : "kora/generated/types.ts";
+        const outputPath = (0, import_node_path7.resolve)(projectRoot, outputFile);
+        await (0, import_promises5.mkdir)((0, import_node_path7.dirname)(outputPath), { recursive: true });
+        await (0, import_promises5.writeFile)(outputPath, output, "utf-8");
+        logger.success(`Generated types at ${outputPath}`);
+      }
+    })
+  }
+});
+function extractSchema(mod) {
+  if (typeof mod !== "object" || mod === null) return null;
+  const record = mod;
+  const candidate = record.default ?? record;
+  if (isSchemaDefinition(candidate)) return candidate;
+  return null;
+}
+function isSchemaDefinition(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const obj = value;
+  return typeof obj.version === "number" && typeof obj.collections === "object" && obj.collections !== null;
+}
+
+// src/commands/migrate/migrate-command.ts
+var import_promises6 = require("fs/promises");
+var import_node_path9 = require("path");
+var import_citty4 = require("citty");
+
+// src/commands/migrate/migration-generator.ts
+var import_core2 = require("@korajs/core");
+
+// src/commands/migrate/schema-differ.ts
+function diffSchemas(previous, current) {
+  const changes = [];
+  const previousCollections = new Set(Object.keys(previous.collections));
+  const currentCollections = new Set(Object.keys(current.collections));
+  for (const collection of currentCollections) {
+    if (!previousCollections.has(collection)) {
+      changes.push({ type: "collection-added", collection });
+    }
+  }
+  for (const collection of previousCollections) {
+    if (!currentCollections.has(collection)) {
+      changes.push({ type: "collection-removed", collection });
+    }
+  }
+  for (const collection of currentCollections) {
+    if (!previousCollections.has(collection)) continue;
+    const previousDef = previous.collections[collection];
+    const currentDef = current.collections[collection];
+    if (!previousDef || !currentDef) continue;
+    const previousFields = previousDef.fields;
+    const currentFields = currentDef.fields;
+    for (const [fieldName, currentField] of Object.entries(currentFields)) {
+      const previousField = previousFields[fieldName];
+      if (!previousField) {
+        changes.push({
+          type: "field-added",
+          collection,
+          field: fieldName,
+          descriptor: currentField
+        });
+        continue;
+      }
+      if (!fieldDescriptorsEqual(previousField, currentField)) {
+        changes.push({
+          type: "field-changed",
+          collection,
+          field: fieldName,
+          before: previousField,
+          after: currentField
+        });
+      }
+    }
+    for (const [fieldName, previousField] of Object.entries(previousFields)) {
+      if (!(fieldName in currentFields)) {
+        changes.push({
+          type: "field-removed",
+          collection,
+          field: fieldName,
+          descriptor: previousField
+        });
+      }
+    }
+    const previousIndexes = new Set(previousDef.indexes);
+    const currentIndexes = new Set(currentDef.indexes);
+    for (const index of currentIndexes) {
+      if (!previousIndexes.has(index)) {
+        changes.push({ type: "index-added", collection, index });
+      }
+    }
+    for (const index of previousIndexes) {
+      if (!currentIndexes.has(index)) {
+        changes.push({ type: "index-removed", collection, index });
+      }
+    }
+  }
+  changes.sort(compareChanges);
+  return {
+    fromVersion: previous.version,
+    toVersion: current.version,
+    changes,
+    hasChanges: changes.length > 0,
+    hasBreakingChanges: changes.some(isBreakingChange)
+  };
+}
+function getChangedCollections(diff) {
+  const collections = /* @__PURE__ */ new Set();
+  for (const change of diff.changes) {
+    collections.add(change.collection);
+  }
+  return [...collections].sort();
+}
+function isBreakingChange(change) {
+  if (change.type === "collection-removed" || change.type === "field-removed") return true;
+  if (change.type === "field-changed") {
+    if (change.before.kind !== change.after.kind) return true;
+    if (change.before.itemKind !== change.after.itemKind) return true;
+    if (serializeEnum(change.before.enumValues) !== serializeEnum(change.after.enumValues)) return true;
+    if (change.before.required !== change.after.required && change.after.required) return true;
+    return false;
+  }
+  if (change.type === "field-added") {
+    const descriptor = change.descriptor;
+    return descriptor.required && descriptor.defaultValue === void 0 && !descriptor.auto;
+  }
+  return false;
+}
+function fieldDescriptorsEqual(left, right) {
+  return left.kind === right.kind && left.required === right.required && left.defaultValue === right.defaultValue && left.auto === right.auto && left.itemKind === right.itemKind && serializeEnum(left.enumValues) === serializeEnum(right.enumValues);
+}
+function serializeEnum(values) {
+  if (!values) return "";
+  return values.join("|");
+}
+function compareChanges(left, right) {
+  if (left.collection < right.collection) return -1;
+  if (left.collection > right.collection) return 1;
+  if (left.type < right.type) return -1;
+  if (left.type > right.type) return 1;
+  const leftKey = "field" in left ? left.field : "index" in left ? left.index : "";
+  const rightKey = "field" in right ? right.field : "index" in right ? right.index : "";
+  if (leftKey < rightKey) return -1;
+  if (leftKey > rightKey) return 1;
+  return 0;
+}
+
+// src/commands/migrate/migration-generator.ts
+function generateMigration(previous, current, diff) {
+  const up = [];
+  const down = [];
+  for (const change of diff.changes) {
+    if (change.type === "collection-added") {
+      const collectionDef = current.collections[change.collection];
+      if (!collectionDef) continue;
+      up.push(...(0, import_core2.generateSQL)(change.collection, collectionDef));
+      down.push(...dropCollectionStatements(change.collection));
+    }
+    if (change.type === "collection-removed") {
+      const collectionDef = previous.collections[change.collection];
+      up.push(...dropCollectionStatements(change.collection));
+      if (collectionDef) {
+        down.push(...(0, import_core2.generateSQL)(change.collection, collectionDef));
+      }
+    }
+  }
+  const changedCollections = getChangedCollections(diff).filter(
+    (collection) => collection in previous.collections && collection in current.collections && diff.changes.some(
+      (change) => change.collection === collection && (change.type === "field-added" || change.type === "field-removed" || change.type === "field-changed" || change.type === "index-added" || change.type === "index-removed")
+    )
+  );
+  for (const collection of changedCollections) {
+    const previousDef = previous.collections[collection];
+    const currentDef = current.collections[collection];
+    if (!previousDef || !currentDef) continue;
+    validateRebuildSafety(collection, previousDef, currentDef);
+    up.push(...generateRebuildStatements(collection, previousDef, currentDef));
+    down.push(...generateRebuildStatements(collection, currentDef, previousDef));
+  }
+  down.reverse();
+  return {
+    up,
+    down,
+    summary: diff.changes.map(formatChange),
+    containsBreakingChanges: diff.hasBreakingChanges
+  };
+}
+function generateRebuildStatements(collection, from, to) {
+  const table = quoteIdentifier(collection);
+  const tempTable = quoteIdentifier(`_kora_mig_${collection}_new`);
+  const targetColumns = [
+    "id TEXT PRIMARY KEY NOT NULL",
+    ...Object.entries(to.fields).map(([field, descriptor]) => columnDefinition(field, descriptor)),
+    "_created_at INTEGER NOT NULL",
+    "_updated_at INTEGER NOT NULL",
+    "_deleted INTEGER NOT NULL DEFAULT 0"
+  ];
+  const statements = [];
+  statements.push(`CREATE TABLE ${tempTable} (
+  ${targetColumns.join(",\n  ")}
+)`);
+  const toFields = Object.keys(to.fields);
+  const columns = ["id", ...toFields, "_created_at", "_updated_at", "_deleted"];
+  const selectExpressions = columns.map(
+    (column) => projectionForColumn(column, from.fields, to.fields[column] ?? null)
+  );
+  statements.push(
+    `INSERT INTO ${tempTable} (${columns.map(quoteIdentifier).join(", ")}) SELECT ${selectExpressions.join(", ")} FROM ${table}`
+  );
+  statements.push(`DROP TABLE ${table}`);
+  statements.push(`ALTER TABLE ${tempTable} RENAME TO ${table}`);
+  for (const indexField of to.indexes) {
+    statements.push(
+      `CREATE INDEX IF NOT EXISTS idx_${collection}_${indexField} ON ${table} (${quoteIdentifier(indexField)})`
+    );
+  }
+  return statements;
+}
+function validateRebuildSafety(collection, from, to) {
+  for (const [fieldName, descriptor] of Object.entries(to.fields)) {
+    if (fieldName in from.fields) continue;
+    if (descriptor.required && descriptor.defaultValue === void 0 && !descriptor.auto) {
+      throw new Error(
+        `Cannot auto-migrate collection "${collection}": added required field "${fieldName}" has no default value.`
+      );
+    }
+  }
+  for (const [fieldName, targetDescriptor] of Object.entries(to.fields)) {
+    const sourceDescriptor = from.fields[fieldName];
+    if (!sourceDescriptor) continue;
+    if (canTransformField(sourceDescriptor, targetDescriptor)) continue;
+    if (targetDescriptor.required && targetDescriptor.defaultValue === void 0 && !targetDescriptor.auto) {
+      throw new Error(
+        `Cannot auto-migrate collection "${collection}": changed required field "${fieldName}" from ${sourceDescriptor.kind} to ${targetDescriptor.kind} without a safe transform/default.`
+      );
+    }
+  }
+}
+function projectionForColumn(column, fromFields, targetDescriptor) {
+  if (column === "id" || column === "_created_at" || column === "_updated_at" || column === "_deleted") {
+    return quoteIdentifier(column);
+  }
+  const sourceDescriptor = fromFields[column];
+  if (sourceDescriptor && targetDescriptor) {
+    return projectionForFieldTransform(column, sourceDescriptor, targetDescriptor);
+  }
+  if (sourceDescriptor) {
+    return quoteIdentifier(column);
+  }
+  if (!targetDescriptor) {
+    return "NULL";
+  }
+  if (targetDescriptor.auto && targetDescriptor.kind === "timestamp") {
+    return "CAST(strftime('%s','now') AS INTEGER) * 1000";
+  }
+  if (targetDescriptor.defaultValue !== void 0) {
+    return sqlLiteral(targetDescriptor.defaultValue);
+  }
+  return "NULL";
+}
+function projectionForFieldTransform(column, source, target) {
+  const sourceColumn = quoteIdentifier(column);
+  if (source.kind === target.kind && source.itemKind === target.itemKind) {
+    if (target.kind === "enum" && target.enumValues && target.enumValues.length > 0) {
+      const allowed = target.enumValues.map((value) => sqlLiteral(value)).join(", ");
+      const fallback = target.defaultValue !== void 0 ? sqlLiteral(target.defaultValue) : sourceColumn;
+      return `CASE WHEN ${sourceColumn} IN (${allowed}) THEN ${sourceColumn} ELSE ${fallback} END`;
+    }
+    return sourceColumn;
+  }
+  if (target.kind === "string") {
+    return `CAST(${sourceColumn} AS TEXT)`;
+  }
+  if (target.kind === "number" || target.kind === "timestamp") {
+    if (source.kind === "string" || source.kind === "enum" || source.kind === "number" || source.kind === "timestamp" || source.kind === "boolean") {
+      const castType = target.kind === "number" ? "REAL" : "INTEGER";
+      return `CASE WHEN ${sourceColumn} IS NULL THEN NULL ELSE CAST(${sourceColumn} AS ${castType}) END`;
+    }
+  }
+  if (target.kind === "boolean") {
+    if (source.kind === "number" || source.kind === "timestamp" || source.kind === "boolean") {
+      return `CASE WHEN ${sourceColumn} IS NULL THEN NULL WHEN CAST(${sourceColumn} AS REAL) = 0 THEN 0 ELSE 1 END`;
+    }
+    if (source.kind === "string" || source.kind === "enum") {
+      return `CASE WHEN ${sourceColumn} IS NULL THEN NULL WHEN LOWER(TRIM(CAST(${sourceColumn} AS TEXT))) IN ('1','true','t','yes','y','on') THEN 1 WHEN LOWER(TRIM(CAST(${sourceColumn} AS TEXT))) IN ('0','false','f','no','n','off') THEN 0 ELSE ${projectionFallback(target)} END`;
+    }
+  }
+  if (target.kind === "enum" && target.enumValues && target.enumValues.length > 0) {
+    if (source.kind === "string" || source.kind === "enum") {
+      const allowed = target.enumValues.map((value) => sqlLiteral(value)).join(", ");
+      return `CASE WHEN ${sourceColumn} IN (${allowed}) THEN ${sourceColumn} ELSE ${projectionFallback(target)} END`;
+    }
+  }
+  if (target.kind === "array" && source.kind === "array" && source.itemKind === target.itemKind) {
+    return sourceColumn;
+  }
+  if (target.auto && target.kind === "timestamp") {
+    return "CAST(strftime('%s','now') AS INTEGER) * 1000";
+  }
+  return projectionFallback(target);
+}
+function canTransformField(source, target) {
+  if (source.kind === target.kind && source.itemKind === target.itemKind) {
+    return true;
+  }
+  if (target.kind === "string") {
+    return true;
+  }
+  if (target.kind === "number" || target.kind === "timestamp") {
+    return source.kind === "string" || source.kind === "enum" || source.kind === "number" || source.kind === "timestamp" || source.kind === "boolean";
+  }
+  if (target.kind === "boolean") {
+    return source.kind === "number" || source.kind === "timestamp" || source.kind === "boolean" || source.kind === "string" || source.kind === "enum";
+  }
+  if (target.kind === "enum") {
+    return source.kind === "string" || source.kind === "enum";
+  }
+  if (target.kind === "array") {
+    return source.kind === "array" && source.itemKind === target.itemKind;
+  }
+  if (target.kind === "richtext") {
+    return source.kind === "richtext";
+  }
+  return false;
+}
+function projectionFallback(target) {
+  if (target.auto && target.kind === "timestamp") {
+    return "CAST(strftime('%s','now') AS INTEGER) * 1000";
+  }
+  if (target.defaultValue !== void 0) {
+    return sqlLiteral(target.defaultValue);
+  }
+  return "NULL";
+}
+function dropCollectionStatements(collection) {
+  const table = quoteIdentifier(collection);
+  const opsTable = quoteIdentifier(`_kora_ops_${collection}`);
+  return [`DROP TABLE IF EXISTS ${table}`, `DROP TABLE IF EXISTS ${opsTable}`];
+}
+function columnDefinition(fieldName, descriptor) {
+  const sqlType = mapFieldType(descriptor);
+  const parts = [quoteIdentifier(fieldName), sqlType];
+  if (descriptor.required && descriptor.defaultValue === void 0 && !descriptor.auto) {
+    parts.push("NOT NULL");
+  }
+  if (descriptor.defaultValue !== void 0) {
+    parts.push(`DEFAULT ${sqlLiteral(descriptor.defaultValue)}`);
+  }
+  if (descriptor.kind === "enum" && descriptor.enumValues) {
+    const values = descriptor.enumValues.map((value) => sqlLiteral(value)).join(", ");
+    parts.push(`CHECK (${quoteIdentifier(fieldName)} IN (${values}))`);
+  }
+  return parts.join(" ");
+}
+function mapFieldType(descriptor) {
+  switch (descriptor.kind) {
+    case "string":
+      return "TEXT";
+    case "number":
+      return "REAL";
+    case "boolean":
+      return "INTEGER";
+    case "enum":
+      return "TEXT";
+    case "timestamp":
+      return "INTEGER";
+    case "array":
+      return "TEXT";
+    case "richtext":
+      return "BLOB";
+  }
+}
+function sqlLiteral(value) {
+  if (value === null) return "NULL";
+  if (typeof value === "number") return String(value);
+  if (typeof value === "boolean") return value ? "1" : "0";
+  if (typeof value === "string") return `'${value.replaceAll("'", "''")}'`;
+  return `'${JSON.stringify(value).replaceAll("'", "''")}'`;
+}
+function quoteIdentifier(identifier) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(identifier)) {
+    throw new Error(`Invalid SQL identifier: ${identifier}`);
+  }
+  return identifier;
+}
+function formatChange(change) {
+  switch (change.type) {
+    case "collection-added":
+      return `+ collection ${change.collection}`;
+    case "collection-removed":
+      return `- collection ${change.collection}`;
+    case "field-added":
+      return `+ ${change.collection}.${change.field}`;
+    case "field-removed":
+      return `- ${change.collection}.${change.field}`;
+    case "field-changed":
+      return `~ ${change.collection}.${change.field}`;
+    case "index-added":
+      return `+ index ${change.collection}.${change.index}`;
+    case "index-removed":
+      return `- index ${change.collection}.${change.index}`;
+  }
+}
+
+// src/commands/migrate/migration-runner.ts
+var import_meta3 = {};
+var MigrationApplyError = class extends Error {
+  constructor(message, backend, report) {
+    super(message);
+    this.backend = backend;
+    this.report = report;
+    this.name = "MigrationApplyError";
+  }
+  backend;
+  report;
+};
+async function runMigration(options) {
+  const report = { backends: [] };
+  const migrationId = options.migrationId ?? `migration-${Date.now()}`;
+  const fromVersion = options.fromVersion ?? 0;
+  const toVersion = options.toVersion ?? 0;
+  if (options.sqlitePath) {
+    try {
+      const sqliteReport = await runSqliteMigration(
+        options.sqlitePath,
+        options.upStatements,
+        migrationId,
+        fromVersion,
+        toVersion,
+        options.projectRoot,
+        options.sqliteDriver
+      );
+      report.backends.push(sqliteReport);
+    } catch (error) {
+      throw new MigrationApplyError(error.message, "sqlite", report);
+    }
+  }
+  if (options.postgresConnectionString) {
+    try {
+      const postgresReport = await runPostgresMigration(
+        options.postgresConnectionString,
+        options.upStatements,
+        migrationId,
+        fromVersion,
+        toVersion,
+        options.postgresClientFactory
+      );
+      report.backends.push(postgresReport);
+    } catch (error) {
+      throw new MigrationApplyError(error.message, "postgres", report);
+    }
+  }
+  return report;
+}
+async function runSqliteMigration(path, statements, migrationId, fromVersion, toVersion, projectRoot, driverOverride) {
+  const driver = driverOverride ?? await loadSqliteDriver(projectRoot);
+  const db = driver.open(path);
+  let statementsApplied = 0;
+  try {
+    db.exec("BEGIN");
+    db.exec(
+      "CREATE TABLE IF NOT EXISTS _kora_migrations (id TEXT PRIMARY KEY NOT NULL, from_version INTEGER NOT NULL, to_version INTEGER NOT NULL, applied_at INTEGER NOT NULL)"
+    );
+    const alreadyApplied = typeof db.isMigrationApplied === "function" ? db.isMigrationApplied(migrationId) : false;
+    if (alreadyApplied) {
+      db.exec("COMMIT");
+      return {
+        backend: "sqlite",
+        statementsApplied: 0,
+        historyRecorded: true,
+        skipped: true
+      };
+    }
+    for (const statement of statements) {
+      db.exec(statement);
+      statementsApplied++;
+    }
+    db.exec(
+      `INSERT OR REPLACE INTO _kora_migrations (id, from_version, to_version, applied_at) VALUES (${sqlLiteral2(migrationId)}, ${fromVersion}, ${toVersion}, ${Date.now()})`
+    );
+    db.exec("COMMIT");
+    return {
+      backend: "sqlite",
+      statementsApplied,
+      historyRecorded: true,
+      skipped: false
+    };
+  } catch (error) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {
+    }
+    throw error;
+  } finally {
+    if (typeof db.close === "function") {
+      db.close();
+    }
+  }
+}
+async function loadSqliteDriver(projectRoot) {
+  try {
+    const { createRequire } = await import("module");
+    const requireFrom = createRequire(
+      projectRoot ? `${projectRoot}/package.json` : import_meta3.url
+    );
+    const Database = requireFrom("better-sqlite3");
+    return {
+      open(path) {
+        const db = new Database(path);
+        return {
+          exec(sql) {
+            db.exec(sql);
+          },
+          isMigrationApplied(id) {
+            const row = db.prepare("SELECT COUNT(*) AS count FROM _kora_migrations WHERE id = ?").get(id);
+            return (row?.count ?? 0) > 0;
+          },
+          close() {
+            db.close();
+          }
+        };
+      }
+    };
+  } catch {
+    throw new Error(
+      'SQLite migration apply requires the "better-sqlite3" package in the target project dependencies.'
+    );
+  }
+}
+async function runPostgresMigration(connectionString, statements, migrationId, fromVersion, toVersion, clientFactoryOverride) {
+  const sql = typeof clientFactoryOverride === "function" ? clientFactoryOverride(connectionString) : (await loadPostgresModule()).default(connectionString);
+  let statementsApplied = 0;
+  try {
+    await sql.unsafe("BEGIN");
+    await sql.unsafe(
+      "CREATE TABLE IF NOT EXISTS _kora_migrations (id TEXT PRIMARY KEY, from_version INTEGER NOT NULL, to_version INTEGER NOT NULL, applied_at BIGINT NOT NULL)"
+    );
+    const existing = await sql.unsafe(
+      `SELECT COUNT(*)::int AS count FROM _kora_migrations WHERE id = ${sqlLiteral2(migrationId)}`
+    );
+    if ((existing[0]?.count ?? 0) > 0) {
+      await sql.unsafe("COMMIT");
+      return {
+        backend: "postgres",
+        statementsApplied: 0,
+        historyRecorded: true,
+        skipped: true
+      };
+    }
+    for (const statement of statements) {
+      await sql.unsafe(statement);
+      statementsApplied++;
+    }
+    await sql.unsafe(
+      `INSERT INTO _kora_migrations (id, from_version, to_version, applied_at) VALUES (${sqlLiteral2(migrationId)}, ${fromVersion}, ${toVersion}, ${Date.now()}) ON CONFLICT (id) DO UPDATE SET from_version = EXCLUDED.from_version, to_version = EXCLUDED.to_version, applied_at = EXCLUDED.applied_at`
+    );
+    await sql.unsafe("COMMIT");
+    return {
+      backend: "postgres",
+      statementsApplied,
+      historyRecorded: true,
+      skipped: false
+    };
+  } catch (error) {
+    try {
+      await sql.unsafe("ROLLBACK");
+    } catch {
+    }
+    throw error;
+  } finally {
+    if (typeof sql.end === "function") {
+      await sql.end();
+    }
+  }
+}
+function sqlLiteral2(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+async function loadPostgresModule() {
+  try {
+    const dynamicImport = new Function("specifier", "return import(specifier)");
+    const mod = await dynamicImport("postgres");
+    if (typeof mod === "object" && mod !== null && "default" in mod) {
+      return mod;
+    }
+    throw new Error("Invalid postgres module");
+  } catch {
+    throw new Error(
+      'PostgreSQL migration apply requires the "postgres" package in the target project dependencies.'
+    );
+  }
+}
+
+// src/commands/migrate/schema-loader.ts
+var import_node_child_process6 = require("child_process");
+var import_node_path8 = require("path");
+var import_node_url4 = require("url");
+async function loadSchemaDefinition(schemaPath, projectRoot) {
+  const ext = (0, import_node_path8.extname)(schemaPath);
+  const moduleValue = ext === ".ts" || ext === ".mts" || ext === ".cts" ? await loadTypeScriptModule(schemaPath, projectRoot) : await import(`${(0, import_node_url4.pathToFileURL)(schemaPath).href}?t=${Date.now()}-${Math.random()}`);
+  return extractSchema2(moduleValue);
+}
+function extractSchema2(value) {
+  if (typeof value !== "object" || value === null) {
+    throw new Error("Schema module must export an object.");
+  }
+  const moduleRecord = value;
+  const candidate = moduleRecord.default ?? moduleRecord;
+  if (!isSchemaDefinition2(candidate)) {
+    throw new Error("Schema module must export a valid SchemaDefinition as default export.");
+  }
+  return candidate;
+}
+function isSchemaDefinition2(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const object = value;
+  return typeof object.version === "number" && typeof object.collections === "object" && object.collections !== null && typeof object.relations === "object" && object.relations !== null;
+}
+async function loadTypeScriptModule(schemaPath, projectRoot) {
+  const tsxBinary = await resolveProjectBinary(projectRoot, "tsx");
+  if (!tsxBinary) {
+    throw new Error(
+      `Schema file is TypeScript (${schemaPath}) but local "tsx" was not found. Install tsx in the project.`
+    );
+  }
+  const script = [
+    "import { pathToFileURL } from 'node:url'",
+    "const modulePath = process.argv[process.argv.length - 1]",
+    "const mod = await import(pathToFileURL(modulePath).href)",
+    "const value = mod.default ?? mod",
+    "process.stdout.write(JSON.stringify(value))"
+  ].join(";");
+  const output = await runCommand2(tsxBinary, ["--eval", script, schemaPath], projectRoot);
+  try {
+    return JSON.parse(output);
+  } catch {
+    throw new Error(`Failed to parse schema module output for ${schemaPath}`);
+  }
+}
+async function runCommand2(command, args, cwd) {
+  return await new Promise((resolve7, reject) => {
+    const child = (0, import_node_child_process6.spawn)(command, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf-8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve7(stdout.trim());
+        return;
+      }
+      reject(
+        new Error(`Failed to load TypeScript schema (exit ${code ?? "unknown"}): ${stderr.trim()}`)
+      );
+    });
+  });
+}
+
+// src/commands/migrate/migrate-command.ts
+var SNAPSHOT_PATH = "kora/schema.snapshot.json";
+var MIGRATIONS_DIR = "kora/migrations";
+var migrateCommand = (0, import_citty4.defineCommand)({
+  meta: {
+    name: "migrate",
+    description: "Detect schema changes and generate/apply migrations"
+  },
+  args: {
+    apply: {
+      type: "boolean",
+      description: "Apply migration to configured database backends",
+      default: false
+    },
+    schema: {
+      type: "string",
+      description: "Path to schema file"
+    },
+    db: {
+      type: "string",
+      description: "SQLite database path for --apply (overrides config)"
+    },
+    "output-dir": {
+      type: "string",
+      description: "Migration output directory",
+      default: MIGRATIONS_DIR
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview migration changes without writing files",
+      default: false
+    },
+    force: {
+      type: "boolean",
+      description: "Skip breaking-change confirmation prompts",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const logger = createLogger();
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot) {
+      throw new InvalidProjectError(process.cwd());
+    }
+    const config = await loadKoraConfig(projectRoot);
+    const resolvedSchemaPath = typeof args.schema === "string" ? (0, import_node_path9.resolve)(projectRoot, args.schema) : typeof config?.schema === "string" ? (0, import_node_path9.resolve)(projectRoot, config.schema) : await findSchemaFile(projectRoot);
+    if (!resolvedSchemaPath) {
+      throw new SchemaNotFoundError(["src/schema.ts", "schema.ts", "src/schema.js", "schema.js"]);
+    }
+    const currentSchema = await loadSchemaDefinition(resolvedSchemaPath, projectRoot);
+    const snapshotFile = (0, import_node_path9.join)(projectRoot, SNAPSHOT_PATH);
+    const previousSchema = await readSchemaSnapshot(snapshotFile);
+    if (!previousSchema) {
+      if (args["dry-run"] === true) {
+        logger.info("No schema snapshot found. Dry run: baseline snapshot would be created.");
+        return;
+      }
+      await writeSchemaSnapshot(snapshotFile, currentSchema);
+      logger.success(`Initialized schema snapshot at ${snapshotFile}`);
+      logger.step("Run `kora migrate` again after schema changes to generate migrations.");
+      return;
+    }
+    const diff = diffSchemas(previousSchema, currentSchema);
+    const outputDir = typeof args["output-dir"] === "string" ? (0, import_node_path9.resolve)(projectRoot, args["output-dir"]) : (0, import_node_path9.resolve)(projectRoot, MIGRATIONS_DIR);
+    if (!diff.hasChanges) {
+      logger.success("No schema changes detected.");
+      if (args.apply === true) {
+        const sqlitePath = resolveSqliteApplyPath(args.db, projectRoot, config);
+        const postgresConnectionString = resolvePostgresConnectionString(config);
+        const pending = await listMigrationManifests(outputDir);
+        if (pending.length === 0) {
+          logger.step("No migration files found to apply.");
+          return;
+        }
+        for (const manifest of pending) {
+          const report = await runMigration({
+            upStatements: manifest.up,
+            migrationId: manifest.id,
+            fromVersion: manifest.fromVersion,
+            toVersion: manifest.toVersion,
+            sqlitePath,
+            postgresConnectionString,
+            projectRoot
+          });
+          for (const backend of report.backends) {
+            logger.step(
+              `  ${manifest.id} -> ${backend.backend}: applied=${backend.statementsApplied}, skipped=${backend.skipped}`
+            );
+          }
+        }
+      }
+      return;
+    }
+    const generated = generateMigration(previousSchema, currentSchema, diff);
+    logger.banner();
+    logger.info(`Detected schema change: v${diff.fromVersion} \u2192 v${diff.toVersion}`);
+    logger.blank();
+    logger.info("Changes:");
+    for (const line of generated.summary) {
+      logger.step(`  ${line}`);
+    }
+    if (diff.hasBreakingChanges && args["dry-run"] !== true) {
+      logger.blank();
+      logger.warn("Breaking schema changes detected.");
+      const shouldContinue = await confirmBreakingChanges(args.force === true);
+      if (!shouldContinue) {
+        logger.warn("Migration generation aborted.");
+        return;
+      }
+    }
+    if (args["dry-run"] === true) {
+      logger.blank();
+      logger.warn("Dry run enabled: no files written, no migrations applied.");
+      return;
+    }
+    await (0, import_promises6.mkdir)(outputDir, { recursive: true });
+    const migrationPath = await writeMigrationFile(outputDir, diff.fromVersion, diff.toVersion, generated);
+    await writeSchemaSnapshot(snapshotFile, currentSchema);
+    logger.blank();
+    logger.success(`Generated migration: ${migrationPath}`);
+    if (args.apply === true) {
+      const sqlitePath = resolveSqliteApplyPath(args.db, projectRoot, config);
+      const postgresConnectionString = resolvePostgresConnectionString(config);
+      const pending = await listMigrationManifests(outputDir);
+      for (const manifest of pending) {
+        const report = await runMigration({
+          upStatements: manifest.up,
+          migrationId: manifest.id,
+          fromVersion: manifest.fromVersion,
+          toVersion: manifest.toVersion,
+          sqlitePath,
+          postgresConnectionString,
+          projectRoot
+        });
+        for (const backend of report.backends) {
+          logger.step(
+            `  ${manifest.id} -> ${backend.backend}: applied=${backend.statementsApplied}, skipped=${backend.skipped}, history=${backend.historyRecorded}`
+          );
+        }
+      }
+      logger.success("Applied pending migrations successfully.");
+    }
+  }
+});
+async function readSchemaSnapshot(path) {
+  try {
+    const content = await (0, import_promises6.readFile)(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function confirmBreakingChanges(force) {
+  if (force) {
+    return true;
+  }
+  if (!isInteractiveTerminal()) {
+    throw new Error(
+      "Breaking schema changes require confirmation. Re-run with --force to continue or --dry-run to preview."
+    );
+  }
+  return await promptConfirm("Continue and generate a breaking migration?", false);
+}
+function isInteractiveTerminal() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+async function writeSchemaSnapshot(path, schema) {
+  await (0, import_promises6.mkdir)((0, import_node_path9.dirname)(path), { recursive: true });
+  await (0, import_promises6.writeFile)(path, `${JSON.stringify(schema, null, 2)}
+`, "utf-8");
+}
+async function writeMigrationFile(outputDir, fromVersion, toVersion, generated) {
+  const existing = await (0, import_promises6.readdir)(outputDir).catch(() => []);
+  const sequence = existing.filter((file) => /^\d{3}-/.test(file)).length + 1;
+  const filename = `${String(sequence).padStart(3, "0")}-v${fromVersion}-to-v${toVersion}.ts`;
+  const path = (0, import_node_path9.join)(outputDir, filename);
+  const migrationId = filename.replace(/\.ts$/, "");
+  const fileContent = [
+    `export const up = ${JSON.stringify(generated.up, null, 2)} as const`,
+    "",
+    `export const down = ${JSON.stringify(generated.down, null, 2)} as const`,
+    "",
+    `export const summary = ${JSON.stringify(generated.summary, null, 2)} as const`,
+    "",
+    `export const containsBreakingChanges = ${generated.containsBreakingChanges}`,
+    ""
+  ].join("\n");
+  await (0, import_promises6.writeFile)(path, fileContent, "utf-8");
+  await writeMigrationManifest((0, import_node_path9.join)(outputDir, `${migrationId}.json`), {
+    id: migrationId,
+    fromVersion,
+    toVersion,
+    up: generated.up,
+    down: generated.down,
+    summary: generated.summary,
+    containsBreakingChanges: generated.containsBreakingChanges
+  });
+  return path;
+}
+async function writeMigrationManifest(path, manifest) {
+  await (0, import_promises6.writeFile)(path, `${JSON.stringify(manifest, null, 2)}
+`, "utf-8");
+}
+async function listMigrationManifests(outputDir) {
+  const files = await (0, import_promises6.readdir)(outputDir).catch(() => []);
+  const migrationFiles = files.filter((file) => /^\d{3}-.*\.ts$/.test(file)).sort((left, right) => left.localeCompare(right));
+  const manifests = [];
+  for (const file of migrationFiles) {
+    const id = file.replace(/\.ts$/, "");
+    const manifestPath = (0, import_node_path9.join)(outputDir, `${id}.json`);
+    const jsonManifest = await readMigrationManifest(manifestPath);
+    if (jsonManifest) {
+      manifests.push({ ...jsonManifest, id });
+      continue;
+    }
+    const migrationPath = (0, import_node_path9.join)(outputDir, file);
+    const sourceManifest = await readMigrationManifestFromSource(migrationPath, id);
+    manifests.push(sourceManifest);
+  }
+  return manifests;
+}
+async function readMigrationManifest(path) {
+  try {
+    const content = await (0, import_promises6.readFile)(path, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function readMigrationManifestFromSource(path, id) {
+  const content = await (0, import_promises6.readFile)(path, "utf-8");
+  const versions = parseVersionsFromMigrationId(id);
+  return {
+    id,
+    fromVersion: versions.fromVersion,
+    toVersion: versions.toVersion,
+    up: parseStringArrayExport(content, "up"),
+    down: parseStringArrayExport(content, "down"),
+    summary: parseStringArrayExport(content, "summary"),
+    containsBreakingChanges: parseBooleanExport(content, "containsBreakingChanges")
+  };
+}
+function parseVersionsFromMigrationId(id) {
+  const match = id.match(/-v(\d+)-to-v(\d+)$/);
+  if (!match) {
+    throw new Error(`Migration id "${id}" does not include a vX-to-vY version suffix.`);
+  }
+  return {
+    fromVersion: Number.parseInt(match[1], 10),
+    toVersion: Number.parseInt(match[2], 10)
+  };
+}
+function parseStringArrayExport(source, exportName) {
+  const expression = parseExportExpression(source, exportName);
+  const parsed = JSON.parse(expression);
+  if (!Array.isArray(parsed) || parsed.some((item) => typeof item !== "string")) {
+    throw new Error(`Migration export "${exportName}" must be a string array.`);
+  }
+  return parsed;
+}
+function parseBooleanExport(source, exportName) {
+  const expression = parseLiteralExport(source, exportName);
+  if (expression === "true") return true;
+  if (expression === "false") return false;
+  throw new Error(`Migration export "${exportName}" must be a boolean literal.`);
+}
+function parseExportExpression(source, exportName) {
+  const escapedName = exportName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`export const ${escapedName} = ([\\s\\S]*?) as const`);
+  const match = source.match(regex);
+  if (!match || !match[1]) {
+    throw new Error(`Failed to read migration export "${exportName}".`);
+  }
+  return match[1].trim();
+}
+function parseLiteralExport(source, exportName) {
+  const escapedName = exportName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`export const ${escapedName} = ([^
+\r]+)`);
+  const match = source.match(regex);
+  if (!match || !match[1]) {
+    throw new Error(`Failed to read migration export "${exportName}".`);
+  }
+  return match[1].trim();
+}
+function resolveSqliteApplyPath(dbArg, projectRoot, config) {
+  if (typeof dbArg === "string") {
+    return (0, import_node_path9.resolve)(projectRoot, dbArg);
+  }
+  const sync = config?.dev?.sync;
+  if (typeof sync === "object" && sync !== null) {
+    if (sync.store === "sqlite") {
+      return (0, import_node_path9.join)(projectRoot, "kora-sync.db");
+    }
+    if (typeof sync.store === "object" && sync.store !== null && sync.store.type === "sqlite") {
+      if (typeof sync.store.filename === "string" && sync.store.filename.length > 0) {
+        return (0, import_node_path9.resolve)(projectRoot, sync.store.filename);
+      }
+      return (0, import_node_path9.join)(projectRoot, "kora-sync.db");
+    }
+  }
+  return void 0;
+}
+function resolvePostgresConnectionString(config) {
+  const sync = config?.dev?.sync;
+  if (typeof sync !== "object" || sync === null) return void 0;
+  if (sync.store === "postgres") {
+    return process.env.DATABASE_URL;
+  }
+  if (typeof sync.store === "object" && sync.store !== null && sync.store.type === "postgres") {
+    return sync.store.connectionString;
+  }
+  return void 0;
+}
+
+// src/bin.ts
+var main = (0, import_citty5.defineCommand)({
+  meta: {
+    name: "kora",
+    description: "Kora.js \u2014 Offline-first application framework"
+  },
+  subCommands: {
+    create: createCommand,
+    dev: devCommand,
+    generate: generateCommand,
+    migrate: migrateCommand
+  }
+});
+(0, import_citty5.runMain)(main);
+//# sourceMappingURL=bin.cjs.map