@korajs/cli 0.0.0-canary-20261008174129

package/dist/bin.js

@@ -0,0 +1,3150 @@
+#!/usr/bin/env node
+import {
+  agentsCommand,
+  deployCommand,
+  generateTypes
+} from "./chunk-TVIRMDER.js";
+import {
+  createCommand
+} from "./chunk-BURFQVMV.js";
+import {
+  DevServerError,
+  InvalidProjectError,
+  SchemaNotFoundError,
+  createLogger,
+  promptConfirm
+} from "./chunk-7Y4J2GXP.js";
+import {
+  loadSchemaDefinition
+} from "./chunk-6C4BHSRA.js";
+import {
+  findProjectRoot,
+  findSchemaFile,
+  hasTsxInstalled,
+  resolveProjectBinaryEntryPoint
+} from "./chunk-5NI2FEQL.js";
+
+// src/bin.ts
+import { defineCommand as defineCommand10, runMain } from "citty";
+
+// src/commands/backup/backup-command.ts
+import { readFile, writeFile } from "fs/promises";
+import "path";
+import { defineCommand } from "citty";
+var DEFAULT_SYNC_PORT = 3001;
+var backupCommand = defineCommand({
+  meta: {
+    name: "backup",
+    description: "Backup and restore Kora sync server data"
+  },
+  subCommands: {
+    create: defineCommand({
+      meta: {
+        name: "create",
+        description: "Create a backup of the sync server"
+      },
+      args: {
+        url: {
+          type: "string",
+          description: "Sync server URL (default: http://localhost:3001)",
+          default: `http://localhost:${DEFAULT_SYNC_PORT}`
+        },
+        out: {
+          type: "string",
+          description: "Output file path (default: kora-backup-<timestamp>.kora)"
+        },
+        token: {
+          type: "string",
+          description: "Backup token (defaults to KORA_BACKUP_TOKEN or KORA_ADMIN_TOKEN)"
+        }
+      },
+      async run({ args }) {
+        const logger = createLogger();
+        const url = typeof args.url === "string" ? args.url : `http://localhost:${DEFAULT_SYNC_PORT}`;
+        const outFile = typeof args.out === "string" ? args.out : `kora-backup-${Date.now()}.kora`;
+        const token = typeof args.token === "string" ? args.token : process.env.KORA_BACKUP_TOKEN ?? process.env.KORA_ADMIN_TOKEN;
+        logger.banner();
+        logger.info(`Exporting backup from ${url}...`);
+        try {
+          const backupUrl = `${url.replace(/\/$/, "")}/__kora/backup/export`;
+          const response = await fetch(backupUrl, {
+            method: "POST",
+            headers: token ? { Authorization: `Bearer ${token}` } : void 0
+          });
+          if (!response.ok) {
+            const error = await response.json().catch(() => ({ message: response.statusText }));
+            throw new Error(
+              `Backup failed: ${error.message ?? response.statusText}`
+            );
+          }
+          const buffer = await response.arrayBuffer();
+          await writeFile(outFile, new Uint8Array(buffer));
+          const size = (buffer.byteLength / 1024).toFixed(1);
+          logger.success(`Backup saved to ${outFile} (${size} KB)`);
+        } catch (error) {
+          logger.error("Backup failed");
+          if (error instanceof Error) logger.error(error.message);
+          logger.blank();
+          logger.step("Make sure the Kora sync server is running.");
+          process.exit(1);
+        }
+      }
+    }),
+    restore: defineCommand({
+      meta: {
+        name: "restore",
+        description: "Restore a backup to the sync server"
+      },
+      args: {
+        file: {
+          type: "string",
+          description: "Backup file path",
+          required: true
+        },
+        url: {
+          type: "string",
+          description: "Sync server URL (default: http://localhost:3001)",
+          default: `http://localhost:${DEFAULT_SYNC_PORT}`
+        },
+        merge: {
+          type: "boolean",
+          description: "Merge with existing data instead of replacing",
+          default: false
+        },
+        token: {
+          type: "string",
+          description: "Backup token (defaults to KORA_BACKUP_TOKEN or KORA_ADMIN_TOKEN)"
+        }
+      },
+      async run({ args }) {
+        const logger = createLogger();
+        const filePath = typeof args.file === "string" ? args.file : "";
+        const url = typeof args.url === "string" ? args.url : `http://localhost:${DEFAULT_SYNC_PORT}`;
+        const merge = args.merge === true;
+        const token = typeof args.token === "string" ? args.token : process.env.KORA_BACKUP_TOKEN ?? process.env.KORA_ADMIN_TOKEN;
+        logger.banner();
+        logger.info(`Restoring backup from ${filePath} to ${url}...`);
+        try {
+          const data = await readFile(filePath);
+          const restoreUrl = `${url.replace(/\/$/, "")}/__kora/backup/import?merge=${merge}`;
+          const response = await fetch(restoreUrl, {
+            method: "POST",
+            headers: token ? { Authorization: `Bearer ${token}` } : void 0,
+            body: data
+          });
+          if (!response.ok) {
+            const error = await response.json().catch(() => ({ message: response.statusText }));
+            throw new Error(
+              `Restore failed: ${error.message ?? response.statusText}`
+            );
+          }
+          const result = await response.json();
+          if (result.success) {
+            logger.success(
+              `Restored ${result.operationsRestored} operations${result.duration ? ` in ${result.duration}ms` : ""}`
+            );
+          } else {
+            logger.error("Restore completed with errors");
+          }
+        } catch (error) {
+          logger.error("Restore failed");
+          if (error instanceof Error) logger.error(error.message);
+          process.exit(1);
+        }
+      }
+    }),
+    info: defineCommand({
+      meta: {
+        name: "info",
+        description: "Show backup file information"
+      },
+      args: {
+        file: {
+          type: "string",
+          description: "Backup file path",
+          required: true
+        }
+      },
+      async run({ args }) {
+        const logger = createLogger();
+        const filePath = typeof args.file === "string" ? args.file : "";
+        try {
+          const data = await readFile(filePath);
+          const { readBackupManifest } = await import("@korajs/store");
+          const manifest = readBackupManifest(
+            new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+          );
+          logger.banner();
+          logger.info(`Backup: ${filePath}`);
+          logger.blank();
+          logger.step(`Created:     ${new Date(manifest.createdAt).toISOString()}`);
+          logger.step(`Node ID:     ${manifest.nodeId}`);
+          logger.step(`Schema:      v${manifest.schemaVersion}`);
+          logger.step(`Operations:  ${manifest.operationCount.toLocaleString()}`);
+          logger.step(`Collections: ${manifest.collections.join(", ") || "(none)"}`);
+          logger.step(`Checksum:    ${manifest.checksum.slice(0, 16)}...`);
+          logger.blank();
+          logger.step(`Format version: ${manifest.version}`);
+        } catch (error) {
+          logger.error("Failed to read backup file");
+          if (error instanceof Error) logger.error(error.message);
+          process.exit(1);
+        }
+      }
+    })
+  }
+});
+
+// src/commands/compact/compact-command.ts
+import { resolve } from "path";
+import { defineCommand as defineCommand2 } from "citty";
+
+// src/commands/dev/kora-config.ts
+import { spawn } from "child_process";
+import { access } from "fs/promises";
+import { extname, join as join2 } from "path";
+import { pathToFileURL } from "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 = extname(configPath);
+  if (ext === ".ts" || ext === ".mts" || ext === ".cts") {
+    const loaded2 = await loadTypeScriptConfig(configPath, projectRoot);
+    return toConfigObject(loaded2);
+  }
+  const loaded = await import(pathToFileURL(configPath).href);
+  return toConfigObject(loaded);
+}
+async function findKoraConfigFile(projectRoot) {
+  for (const file of CONFIG_CANDIDATES) {
+    const candidate = join2(projectRoot, file);
+    try {
+      await access(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+async function loadTypeScriptConfig(configPath, projectRoot) {
+  if (!await hasTsxInstalled(projectRoot)) {
+    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 = "const configPath = process.argv[process.argv.length - 1];import('node:url').then(u => import(u.pathToFileURL(configPath).href)).then(mod => { const v = mod.default ?? mod; process.stdout.write(JSON.stringify(v)) }).catch(e => { process.stderr.write(String(e)); process.exit(1) })";
+  const output = await runCommand(
+    process.execPath,
+    ["--import", "tsx", "--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 = 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/compact/compact-command.ts
+var compactCommand = defineCommand2({
+  meta: {
+    name: "compact",
+    description: "Compact the local Kora operation log after server ack"
+  },
+  args: {
+    db: {
+      type: "string",
+      description: "Path to the local SQLite database (required)"
+    },
+    schema: {
+      type: "string",
+      description: "Path to schema file"
+    },
+    strategy: {
+      type: "string",
+      description: "Compaction strategy: after-ack | after-days | never",
+      default: "after-ack"
+    },
+    days: {
+      type: "string",
+      description: "Age threshold when strategy is after-days",
+      default: "30"
+    }
+  },
+  async run({ args }) {
+    const logger = createLogger();
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot) {
+      throw new InvalidProjectError(process.cwd());
+    }
+    const dbPath = typeof args.db === "string" ? resolve(projectRoot, args.db) : void 0;
+    if (!dbPath) {
+      throw new Error("Missing --db <path> to the local SQLite database file.");
+    }
+    const config = await loadKoraConfig(projectRoot);
+    const schemaPath = typeof args.schema === "string" ? resolve(projectRoot, args.schema) : typeof config?.schema === "string" ? resolve(projectRoot, config.schema) : void 0;
+    if (!schemaPath) {
+      throw new Error("Could not resolve schema path. Pass --schema <path>.");
+    }
+    const schema = await loadSchemaDefinition(schemaPath, projectRoot);
+    const { BetterSqlite3Adapter } = await import("@korajs/store/better-sqlite3");
+    const { Store } = await import("@korajs/store");
+    const strategyName = typeof args.strategy === "string" ? args.strategy : "after-ack";
+    const days = Number.parseInt(typeof args.days === "string" ? args.days : "30", 10);
+    const store = new Store({
+      schema,
+      adapter: new BetterSqlite3Adapter(dbPath)
+    });
+    await store.open();
+    let result;
+    if (strategyName === "never") {
+      result = await store.compact({ mode: "never" });
+    } else if (strategyName === "after-days") {
+      result = await store.compact({ mode: "after-days", days });
+    } else if (strategyName === "after-ack") {
+      result = await store.compact({ mode: "after-ack" });
+    } else {
+      await store.close();
+      throw new Error(`Unknown strategy "${strategyName}". Use after-ack, after-days, or never.`);
+    }
+    await store.close();
+    logger.banner();
+    logger.success(`Compacted ${result.deletedCount} operation log entries.`);
+    for (const [nodeId, seq] of result.watermark) {
+      logger.step(`  ${nodeId}: seq <= ${seq}`);
+    }
+  }
+});
+
+// src/commands/dev/dev-command.ts
+import { existsSync, readFileSync } from "fs";
+import { access as access2 } from "fs/promises";
+import { join as join4 } from "path";
+import { resolve as resolve2 } from "path";
+import { defineCommand as defineCommand3 } from "citty";
+
+// src/commands/dev/process-manager.ts
+import { spawn as spawnChild } from "child_process";
+var ProcessManager = class {
+  processes = /* @__PURE__ */ new Map();
+  spawn(config) {
+    this.processes.get(config.label)?.child.kill("SIGTERM");
+    const options = {
+      cwd: config.cwd,
+      env: { ...process.env, ...config.env },
+      stdio: ["ignore", "pipe", "pipe"]
+    };
+    const child = spawnChild(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 restart(config) {
+    await this.stop(config.label);
+    this.spawn(config);
+  }
+  async stop(label) {
+    const running = this.processes.get(label);
+    if (!running) return;
+    running.child.kill("SIGTERM");
+    await Promise.race([running.exitPromise, delay(5e3)]);
+    const remaining = this.processes.get(label);
+    if (!remaining) return;
+    remaining.child.kill("SIGKILL");
+    await remaining.exitPromise;
+  }
+  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
+import { spawn as spawn2 } from "child_process";
+import { watch } from "fs";
+import { join as join3 } from "path";
+var SchemaWatcher = class {
+  constructor(config) {
+    this.config = config;
+    this.debounceMs = config.debounceMs ?? 300;
+  }
+  config;
+  debounceMs;
+  watcher = null;
+  debounceTimer = null;
+  schemaVersion = null;
+  start() {
+    if (this.watcher) return;
+    this.watcher = watch(this.config.schemaPath, () => {
+      this.scheduleRegeneration();
+    });
+    this.watcher.on("error", (error) => {
+      this.config.onError?.(toError(error));
+    });
+    void this.refreshSchemaVersion().catch((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 koraBinJs = join3(
+      this.config.projectRoot,
+      "node_modules",
+      "@korajs",
+      "cli",
+      "dist",
+      "bin.js"
+    );
+    const hasTsx = await hasTsxInstalled(this.config.projectRoot);
+    const command = process.execPath;
+    const args = hasTsx ? ["--import", "tsx", koraBinJs, "generate", "types", "--schema", this.config.schemaPath] : [koraBinJs, "generate", "types", "--schema", this.config.schemaPath];
+    await spawnCommand(command, args, this.config.projectRoot);
+    this.config.onRegenerate?.();
+    await this.refreshSchemaVersion();
+  }
+  async refreshSchemaVersion() {
+    const schema = await loadSchemaDefinition(this.config.schemaPath, this.config.projectRoot);
+    const previous = this.schemaVersion;
+    this.schemaVersion = schema.version;
+    if (previous !== null && previous !== schema.version) {
+      this.config.onSchemaVersionChange?.({ previous, next: schema.version });
+    }
+  }
+  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 = spawn2(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 = defineCommand3({
+  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());
+    }
+    loadProjectEnv(projectRoot);
+    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 viteEntryPoint = await resolveProjectBinaryEntryPoint(projectRoot, "vite", "vite");
+    if (!viteEntryPoint) {
+      throw new DevServerError("vite", join4(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 hasTsx = false;
+    if (shouldStartSync && syncServerFile !== null) {
+      hasTsx = await hasTsxInstalled(projectRoot);
+      if (!hasTsx) {
+        logger.warn('Sync server detected, but "tsx" is not installed. Skipping sync.');
+      }
+    }
+    if (shouldStartSync && syncServerFile === null && managedSyncStore) {
+      const hasServerPackage = await fileExists(
+        join4(projectRoot, "node_modules", "@korajs", "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 = resolve2(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 && hasTsx && 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();
+    logger.step(
+      "  Kora DevTools overlay: Ctrl+Shift+K (Cmd+Shift+K on macOS) when devtools is enabled"
+    );
+    processManager.spawn({
+      label: "vite",
+      command: process.execPath,
+      args: [viteEntryPoint, "--port", String(vitePort)],
+      cwd: projectRoot,
+      env: {
+        KORA_DEV: "1"
+      },
+      onExit: onManagedProcessExit
+    });
+    const syncProcessConfig = shouldStartSync && hasTsx && syncServerFile ? {
+      label: "sync",
+      command: process.execPath,
+      args: ["--import", "tsx", syncServerFile],
+      cwd: projectRoot,
+      env: {
+        PORT: String(syncPort),
+        KORA_SYNC_PORT: String(syncPort)
+      },
+      onExit: onManagedProcessExit
+    } : shouldStartSync && syncServerFile === null && managedSyncStore !== null ? {
+      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
+    } : null;
+    if (syncProcessConfig) {
+      processManager.spawn(syncProcessConfig);
+    }
+    if (watchEnabled && schemaPath) {
+      schemaWatcher = new SchemaWatcher({
+        schemaPath,
+        projectRoot,
+        debounceMs: watchDebounceMs,
+        onRegenerate: () => {
+          logger.success("Regenerated types from schema changes");
+        },
+        onSchemaVersionChange: ({ previous, next }) => {
+          if (!syncProcessConfig) {
+            logger.warn(
+              `Schema version changed from ${previous} to ${next}; restart your sync server before clients can sync.`
+            );
+            return;
+          }
+          logger.warn(`Schema version changed from ${previous} to ${next}; restarting sync server.`);
+          void processManager.restart(syncProcessConfig);
+        },
+        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 = [join4(projectRoot, "server.ts"), join4(projectRoot, "server.js")];
+  for (const candidate of candidates) {
+    try {
+      await access2(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+async function fileExists(path) {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function loadProjectEnv(projectRoot, mode = "development") {
+  const files = [".env", ".env.local", `.env.${mode}`, `.env.${mode}.local`];
+  const existingKeys = new Set(Object.keys(process.env));
+  for (const file of files) {
+    const path = join4(projectRoot, file);
+    if (!existsSync(path)) continue;
+    const parsed = parseEnvFile(readFileSync(path, "utf8"));
+    for (const [key, value] of Object.entries(parsed)) {
+      if (!existingKeys.has(key)) {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+function parseEnvFile(contents) {
+  const env = {};
+  for (const rawLine of contents.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const normalized = line.startsWith("export ") ? line.slice("export ".length).trim() : line;
+    const equalsIndex = normalized.indexOf("=");
+    if (equalsIndex <= 0) continue;
+    const key = normalized.slice(0, equalsIndex).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
+    env[key] = parseEnvValue(normalized.slice(equalsIndex + 1).trim());
+  }
+  return env;
+}
+function parseEnvValue(value) {
+  const quote = value[0];
+  if ((quote === '"' || quote === "'") && value[value.length - 1] === quote) {
+    const inner = value.slice(1, -1);
+    return quote === '"' ? inner.replace(/\\n/g, "\n").replace(/\\r/g, "\r") : inner;
+  }
+  const commentIndex = value.search(/\s#/);
+  return (commentIndex >= 0 ? value.slice(0, commentIndex) : value).trim();
+}
+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: join4(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 ? resolve2(projectRoot, store.filename) : join4(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/doctor/doctor-command.ts
+import { defineCommand as defineCommand4 } from "citty";
+
+// src/commands/doctor/doctor-checks.ts
+import { access as access3, readFile as readFile2 } from "fs/promises";
+import { join as join5, resolve as resolve3 } from "path";
+var STATUS_ENDPOINT = "/__kora/status";
+async function runDoctorChecks(options) {
+  const { projectRoot } = options;
+  const results = [];
+  results.push({
+    id: "project-root",
+    title: "Project root",
+    status: "pass",
+    message: projectRoot
+  });
+  const config = await loadKoraConfig(projectRoot);
+  if (!config) {
+    results.push({
+      id: "kora-config",
+      title: "kora.config",
+      status: "warn",
+      message: "No kora.config.* file found.",
+      fix: "Add kora.config.ts with schema path and dev settings (see create-kora-app templates)."
+    });
+  } else {
+    results.push({
+      id: "kora-config",
+      title: "kora.config",
+      status: "pass",
+      message: "Configuration file loaded."
+    });
+  }
+  const schemaPath = await resolveSchemaPath(projectRoot, config?.schema);
+  if (!schemaPath) {
+    results.push({
+      id: "schema",
+      title: "Schema",
+      status: "fail",
+      message: "Could not find schema.ts in src/ or project root.",
+      fix: "Add src/schema.ts or set schema in kora.config.ts."
+    });
+  } else {
+    try {
+      const schema = await loadSchemaDefinition(schemaPath, projectRoot);
+      results.push({
+        id: "schema",
+        title: "Schema",
+        status: "pass",
+        message: `Loaded schema v${schema.version} (${Object.keys(schema.collections).length} collection(s)).`
+      });
+      const workerCheck = await checkWorkerFile(projectRoot);
+      results.push(workerCheck);
+      const depsCheck = await checkDependencies(projectRoot);
+      results.push(depsCheck);
+      results.push(opfsBrowserNote());
+      if (!options.skipNetwork) {
+        const syncUrl = options.syncHttpUrl ?? await resolveSyncHttpUrl(projectRoot, config);
+        const syncChecks = await checkSyncServer(syncUrl, schema);
+        results.push(...syncChecks);
+      } else {
+        results.push({
+          id: "sync-server",
+          title: "Sync server",
+          status: "skip",
+          message: "Network checks skipped."
+        });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      results.push({
+        id: "schema",
+        title: "Schema",
+        status: "fail",
+        message: `Failed to load schema: ${message}`,
+        fix: "Ensure the schema exports defineSchema() as default and TypeScript can be evaluated (install tsx)."
+      });
+    }
+  }
+  return results;
+}
+async function resolveSchemaPath(projectRoot, configSchema) {
+  if (typeof configSchema === "string") {
+    const resolved = resolve3(projectRoot, configSchema);
+    try {
+      await access3(resolved);
+      return resolved;
+    } catch {
+    }
+  }
+  return findSchemaFile(projectRoot);
+}
+async function checkWorkerFile(projectRoot) {
+  const candidates = [
+    join5(projectRoot, "src", "kora-worker.ts"),
+    join5(projectRoot, "src", "kora-worker.js")
+  ];
+  for (const path of candidates) {
+    try {
+      await access3(path);
+      return {
+        id: "worker",
+        title: "SQLite WASM worker",
+        status: "pass",
+        message: `Found ${path.replace(projectRoot, ".")}.`
+      };
+    } catch {
+    }
+  }
+  return {
+    id: "worker",
+    title: "SQLite WASM worker",
+    status: "warn",
+    message: "No src/kora-worker.ts found.",
+    fix: "Add kora-worker.ts and pass store.workerUrl from Vite (?worker&url) in createApp()."
+  };
+}
+async function checkDependencies(projectRoot) {
+  try {
+    const raw = await readFile2(join5(projectRoot, "package.json"), "utf-8");
+    const pkg = JSON.parse(raw);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const hasKora = Boolean(deps.korajs || deps.kora);
+    const hasStore = Boolean(deps["@korajs/store"]);
+    if (hasKora || hasStore) {
+      return {
+        id: "dependencies",
+        title: "Dependencies",
+        status: "pass",
+        message: hasKora ? "korajs is listed in package.json." : "@korajs/store is listed in package.json."
+      };
+    }
+    return {
+      id: "dependencies",
+      title: "Dependencies",
+      status: "fail",
+      message: "No korajs or @korajs/store dependency found.",
+      fix: "Run pnpm add korajs @korajs/react (or your package manager equivalent)."
+    };
+  } catch {
+    return {
+      id: "dependencies",
+      title: "Dependencies",
+      status: "fail",
+      message: "Could not read package.json.",
+      fix: "Run this command from a Kora app directory with a valid package.json."
+    };
+  }
+}
+function opfsBrowserNote() {
+  return {
+    id: "opfs",
+    title: "OPFS persistence",
+    status: "skip",
+    message: "OPFS availability is checked in the browser at runtime. Open the app and confirm no IndexedDB fallback warning in the console.",
+    fix: "Use a Chromium-based browser with storage access; avoid private mode if persistence fails."
+  };
+}
+async function resolveSyncHttpUrl(projectRoot, config) {
+  const envUrl = await readEnvSyncUrl(projectRoot);
+  if (envUrl) {
+    return toSyncStatusHttpBase(envUrl);
+  }
+  const syncPort = typeof config?.dev?.sync === "object" && typeof config.dev.sync.port === "number" ? config.dev.sync.port : 3001;
+  return `http://localhost:${syncPort}`;
+}
+async function readEnvSyncUrl(projectRoot) {
+  for (const file of [".env", ".env.local"]) {
+    const path = join5(projectRoot, file);
+    try {
+      const content = await readFile2(path, "utf-8");
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const match = trimmed.match(/^VITE_SYNC_URL=(.+)$/);
+        if (match?.[1]) {
+          return match[1].trim().replace(/^["']|["']$/g, "");
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function toSyncStatusHttpBase(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol === "ws:") {
+      parsed.protocol = "http:";
+    } else if (parsed.protocol === "wss:") {
+      parsed.protocol = "https:";
+    }
+    parsed.pathname = "";
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed.toString().replace(/\/$/, "");
+  } catch {
+    return "http://localhost:3001";
+  }
+}
+async function checkSyncServer(httpBase, schema) {
+  const statusUrl = `${httpBase.replace(/\/$/, "")}${STATUS_ENDPOINT}`;
+  try {
+    const response = await fetch(statusUrl, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!response.ok) {
+      return [
+        {
+          id: "sync-server",
+          title: "Sync server",
+          status: "fail",
+          message: `GET ${statusUrl} returned ${response.status}.`,
+          fix: "Start the sync server with `kora dev` or `pnpm run dev` in a sync template."
+        }
+      ];
+    }
+    const body = await response.json();
+    const results = [
+      {
+        id: "sync-server",
+        title: "Sync server",
+        status: "pass",
+        message: `Reachable at ${statusUrl} (server v${body.version ?? "unknown"}).`
+      }
+    ];
+    if (typeof body.schemaVersion === "number" && body.schemaVersion !== schema.version) {
+      results.push({
+        id: "schema-version",
+        title: "Schema version",
+        status: "warn",
+        message: `Client schema v${schema.version} differs from server schema v${body.schemaVersion}.`,
+        fix: "Run migrations on the server and client, or align schema.version before syncing."
+      });
+    } else {
+      results.push({
+        id: "schema-version",
+        title: "Schema version",
+        status: "pass",
+        message: `Client and server both use schema v${schema.version}.`
+      });
+    }
+    return results;
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return [
+      {
+        id: "sync-server",
+        title: "Sync server",
+        status: "warn",
+        message: `Could not reach ${statusUrl}: ${detail}`,
+        fix: "Start the sync server, or pass --skip-network for local-only checks."
+      }
+    ];
+  }
+}
+function doctorHasFailures(results) {
+  return results.some((r) => r.status === "fail");
+}
+
+// src/commands/doctor/doctor-command.ts
+var doctorCommand = defineCommand4({
+  meta: {
+    name: "doctor",
+    description: "Check Kora project setup (schema, worker, sync server, versions)"
+  },
+  args: {
+    url: {
+      type: "string",
+      description: "Sync server HTTP base URL for status probe (default: from .env or localhost:3001)"
+    },
+    "skip-network": {
+      type: "boolean",
+      description: "Skip sync server and schema version network checks",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const logger = createLogger();
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot) {
+      throw new InvalidProjectError(process.cwd());
+    }
+    const syncHttpUrl = typeof args.url === "string" ? args.url : void 0;
+    const skipNetwork = args["skip-network"] === true;
+    logger.banner();
+    logger.info(`Checking project at ${projectRoot}`);
+    logger.blank();
+    const results = await runDoctorChecks({
+      projectRoot,
+      syncHttpUrl,
+      skipNetwork
+    });
+    for (const check of results) {
+      const prefix = check.status === "pass" ? "success" : check.status === "warn" ? "warn" : check.status === "fail" ? "error" : "step";
+      logger[prefix](`${check.title}: ${check.message}`);
+      if (check.fix && check.status !== "pass" && check.status !== "skip") {
+        logger.step(`  Fix: ${check.fix}`);
+      }
+    }
+    logger.blank();
+    if (doctorHasFailures(results)) {
+      logger.error("Doctor found blocking issues.");
+      process.exitCode = 1;
+      return;
+    }
+    const warnings = results.filter((r) => r.status === "warn").length;
+    if (warnings > 0) {
+      logger.warn(`Doctor finished with ${warnings} warning(s).`);
+    } else {
+      logger.success("All checks passed.");
+    }
+  }
+});
+
+// src/commands/generate/generate-command.ts
+import { mkdir, writeFile as writeFile2 } from "fs/promises";
+import { dirname, resolve as resolve4 } from "path";
+import { defineCommand as defineCommand5 } from "citty";
+
+// src/commands/generate/hook-generator.ts
+function generateCollectionHooks(schema) {
+  const files = /* @__PURE__ */ new Map();
+  for (const collectionName of Object.keys(schema.collections)) {
+    const pascal = toPascalCase(collectionName);
+    const hookName = `use${pascal}`;
+    const content = [
+      "// Auto-generated by `kora generate hooks` \u2014 safe to edit",
+      `// Schema v${String(schema.version)}`,
+      "",
+      "import { useCollection, useMutation, useQuery } from '@korajs/react'",
+      `import type { ${pascal}InsertInput, ${pascal}Record, ${pascal}UpdateInput } from '../types'`,
+      "",
+      "/**",
+      ` * Collection hook for \`${collectionName}\`.`,
+      " * Add useQuery(...) calls with your QueryBuilder factories.",
+      " */",
+      `export function ${hookName}() {`,
+      `	const ${collectionName} = useCollection('${collectionName}')`,
+      "",
+      `	const insert = useMutation((data: ${pascal}InsertInput) => ${collectionName}.insert(data))`,
+      `	const update = useMutation((id: string, data: ${pascal}UpdateInput) =>`,
+      `		${collectionName}.update(id, data),`,
+      "	)",
+      `	const remove = useMutation((id: string) => ${collectionName}.delete(id))`,
+      "",
+      "	return {",
+      `		${collectionName},`,
+      "		insert,",
+      "		update,",
+      "		remove,",
+      "	}",
+      "}",
+      ""
+    ].join("\n");
+    files.set(`${collectionName}.ts`, content);
+  }
+  const indexLines = [
+    "// Auto-generated by `kora generate hooks`",
+    "",
+    ...Object.keys(schema.collections).map((name) => {
+      const pascal = toPascalCase(name);
+      return `export { use${pascal} } from './${name}'`;
+    }),
+    ""
+  ];
+  files.set("index.ts", indexLines.join("\n"));
+  return files;
+}
+function toPascalCase(value) {
+  return value.split(/[-_]/).filter((part) => part.length > 0).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+
+// src/commands/generate/generate-command.ts
+var generateCommand = defineCommand5({
+  meta: {
+    name: "generate",
+    description: "Generate code from your Kora schema"
+  },
+  subCommands: {
+    types: defineCommand5({
+      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 = resolve4(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 = resolve4(projectRoot, outputFile);
+        await mkdir(dirname(outputPath), { recursive: true });
+        await writeFile2(outputPath, output, "utf-8");
+        logger.success(`Generated types at ${outputPath}`);
+      }
+    }),
+    hooks: defineCommand5({
+      meta: {
+        name: "hooks",
+        description: "Generate per-collection React hook stubs"
+      },
+      args: {
+        schema: {
+          type: "string",
+          description: "Path to schema file"
+        },
+        output: {
+          type: "string",
+          description: "Output directory for hooks",
+          default: "kora/generated/hooks"
+        },
+        types: {
+          type: "string",
+          description: "Relative import path to generated types from hook files",
+          default: "../types"
+        }
+      },
+      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 = resolve4(projectRoot, 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;
+        }
+        const schema = await loadSchemaDefinition(schemaPath, projectRoot);
+        const outputDir = typeof args.output === "string" ? resolve4(projectRoot, args.output) : resolve4(projectRoot, "kora/generated/hooks");
+        const files = generateCollectionHooks(schema);
+        for (const [name, content] of files) {
+          const adjusted = typeof args.types === "string" && args.types !== "../types" ? content.replace("from '../types'", `from '${args.types}'`) : content;
+          const filePath = resolve4(outputDir, name);
+          await mkdir(dirname(filePath), { recursive: true });
+          await writeFile2(filePath, adjusted, "utf-8");
+        }
+        logger.success(`Generated ${String(files.size)} hook file(s) at ${outputDir}`);
+        logger.step("Run `kora generate types` first if ../types is missing.");
+      }
+    })
+  }
+});
+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/logs/logs-command.ts
+import { defineCommand as defineCommand6 } from "citty";
+var DEFAULT_SYNC_PORT2 = 3001;
+var EVENTS_ENDPOINT = "/__kora/events";
+var logsCommand = defineCommand6({
+  meta: {
+    name: "logs",
+    description: "Stream real-time events from a Kora sync server"
+  },
+  args: {
+    url: {
+      type: "string",
+      description: "Sync server URL (default: http://localhost:3001)",
+      default: `http://localhost:${DEFAULT_SYNC_PORT2}`
+    },
+    follow: {
+      type: "boolean",
+      description: "Follow log output (like tail -f)",
+      default: true,
+      alias: "f"
+    },
+    level: {
+      type: "string",
+      description: "Filter by log level (info, warn, error)"
+    },
+    token: {
+      type: "string",
+      description: "Admin token (defaults to KORA_ADMIN_TOKEN)"
+    }
+  },
+  async run({ args }) {
+    const logger = createLogger();
+    const url = typeof args.url === "string" ? args.url : `http://localhost:${DEFAULT_SYNC_PORT2}`;
+    const follow = args.follow !== false;
+    const levelFilter = typeof args.level === "string" ? args.level : null;
+    const token = typeof args.token === "string" ? args.token : process.env.KORA_ADMIN_TOKEN ?? void 0;
+    const eventsUrl = `${url.replace(/\/$/, "")}${EVENTS_ENDPOINT}`;
+    logger.banner();
+    logger.info(`Connecting to ${eventsUrl}...`);
+    logger.blank();
+    try {
+      const response = await fetch(eventsUrl, {
+        headers: token ? { Authorization: `Bearer ${token}` } : void 0
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Failed to connect to ${eventsUrl}: ${response.status} ${response.statusText}`
+        );
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error("Response body is not readable");
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      const processLine = (line) => {
+        if (line.startsWith("event: ")) {
+          return;
+        }
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6);
+          try {
+            const parsed = JSON.parse(data);
+            const level = String(parsed.level ?? "info");
+            if (levelFilter && level !== levelFilter) return;
+            const timestamp = parsed.timestamp ? new Date(parsed.timestamp).toISOString() : "";
+            const event = String(parsed.event ?? "unknown");
+            const nodeId = parsed.nodeId ? ` [${parsed.nodeId}]` : "";
+            const session = parsed.sessionId ? ` <${parsed.sessionId}>` : "";
+            const count = parsed.count ? ` (${parsed.count})` : "";
+            const error = parsed.error ? ` \u2014 ${parsed.error}` : "";
+            const prefix = level === "error" ? "\u2717" : level === "warn" ? "\u26A0" : "\u25CF";
+            const color = level === "error" ? "\x1B[31m" : level === "warn" ? "\x1B[33m" : "\x1B[36m";
+            console.log(
+              `${color}${prefix}${"\x1B[0m"} ${timestamp.slice(11, 23)} ${event}${nodeId}${session}${count}${error}`
+            );
+          } catch {
+          }
+        }
+      };
+      const read = async () => {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            processLine(line.trim());
+          }
+          if (!follow) break;
+        }
+      };
+      await read();
+    } catch (error) {
+      logger.error(`Failed to connect to ${eventsUrl}`);
+      if (error instanceof Error) {
+        logger.error(error.message);
+      }
+      logger.blank();
+      logger.step("Make sure the Kora sync server is running.");
+      logger.step("Start it with: kora dev");
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/migrate/migrate-command.ts
+import { mkdir as mkdir2, readFile as readFile3, readdir, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, join as join6, resolve as resolve5 } from "path";
+import { defineCommand as defineCommand7 } from "citty";
+
+// src/commands/migrate/migration-generator.ts
+import { generateSQL } from "@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;
+    const kept = new Set(change.after.enumValues ?? []);
+    if ((change.before.enumValues ?? []).some((value) => !kept.has(value))) 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/table-evolution-directive.ts
+import {
+  collectionIndexName,
+  isKoraInternalColumn,
+  parseSqliteCheckConstraints,
+  readSqliteTableCatalog,
+  sqlDefaultLiteral,
+  sqliteCheckConstraintDefinition,
+  sqliteCheckReferencesColumn
+} from "@korajs/core/internal";
+var EVOLVE_TABLE_DIRECTIVE = "--kora:evolve-table";
+function evolveFieldSpec(descriptor) {
+  return {
+    kind: descriptor.kind,
+    ...descriptor.itemKind ? { itemKind: descriptor.itemKind } : {},
+    ...descriptor.enumValues ? { enumValues: [...descriptor.enumValues] } : {},
+    ...descriptor.defaultValue !== void 0 ? { default: descriptor.defaultValue } : {},
+    ...descriptor.auto ? { auto: true } : {}
+  };
+}
+function formatEvolveTableDirective(target) {
+  return `${EVOLVE_TABLE_DIRECTIVE} ${JSON.stringify(target)}`;
+}
+function parseEvolveTableDirective(statement) {
+  const trimmed = statement.trimStart();
+  if (!trimmed.startsWith(EVOLVE_TABLE_DIRECTIVE)) return null;
+  const payload = trimmed.slice(EVOLVE_TABLE_DIRECTIVE.length).trim();
+  let parsed;
+  try {
+    parsed = JSON.parse(payload);
+  } catch {
+    parsed = null;
+  }
+  const target = parsed;
+  const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  const isStrings = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+  const isSpec = (value) => isRecord(value) && typeof value.kind === "string";
+  if (!isRecord(target) || typeof target.table !== "string" || !isRecord(target.add) || !Object.values(target.add).every(isSpec) || !isStrings(target.drop) || !isRecord(target.change) || !Object.values(target.change).every(
+    (change) => isRecord(change) && isSpec(change.from) && isSpec(change.to)
+  ) || !isStrings(target.addIndexes) || !isStrings(target.removeIndexes)) {
+    throw new Error(
+      `Malformed migration directive "${statement}": expected ${EVOLVE_TABLE_DIRECTIVE} {"table", "add", "drop", "change", "addIndexes", "removeIndexes"}. Regenerate the migration with \`kora migrate\`.`
+    );
+  }
+  return {
+    table: target.table,
+    add: target.add,
+    drop: [...target.drop],
+    change: target.change,
+    addIndexes: [...target.addIndexes],
+    removeIndexes: [...target.removeIndexes]
+  };
+}
+async function expandEvolveTableForSqlite(target, query, now) {
+  const catalog = await readSqliteTableCatalog(query, target.table);
+  if (!catalog) return [];
+  const table = quoteIdentifier(target.table);
+  const existing = new Map(
+    catalog.columns.map((column) => [column.name, column.type.toUpperCase()])
+  );
+  const plan = planColumns(target, existing, sqliteType);
+  const statements = [];
+  const presentIndexes = await indexColumnsByName(query, target.table);
+  const removedIndexNames = new Set(
+    target.removeIndexes.flatMap((field) => koraIndexNames(target.table, field)).filter((name) => presentIndexes.has(name))
+  );
+  for (const name of removedIndexNames) {
+    statements.push(`DROP INDEX IF EXISTS ${quoteIdentifier(name)}`);
+  }
+  if (plan.drop.length > 0 || plan.change.length > 0) {
+    statements.push(
+      ...await sqliteRebuildStatements(catalog, plan, query, removedIndexNames, now)
+    );
+  } else {
+    for (const [field, spec] of plan.add) {
+      statements.push(
+        `ALTER TABLE ${table} ADD COLUMN ${quoteIdentifier(field)} ${sqliteType(spec)}${defaultClause(spec)}`
+      );
+      if (spec.auto && spec.kind === "timestamp" && spec.default === void 0) {
+        statements.push(`UPDATE ${table} SET ${quoteIdentifier(field)} = ${now}`);
+      }
+    }
+  }
+  const indexed = await singleColumnIndexes(query, target.table, removedIndexNames);
+  for (const field of target.addIndexes) {
+    if (indexed.has(field)) continue;
+    statements.push(
+      `CREATE INDEX IF NOT EXISTS ${koraIndexNames(target.table, field)[0]} ON ${table} (${quoteIdentifier(field)})`
+    );
+  }
+  return statements;
+}
+async function expandEvolveTableForPostgres(target, query, now) {
+  const columns = await query(
+    `SELECT column_name::text AS name, upper(data_type::text) AS type FROM information_schema.columns WHERE table_schema = current_schema() AND table_name = ${sqlText(target.table)}`
+  );
+  if (columns.length === 0) return [];
+  const table = quoteIdentifier(target.table);
+  const existing = new Map(columns.map((row) => [String(row.name), String(row.type)]));
+  const plan = planColumns(target, existing, postgresType);
+  const statements = [];
+  const indexNames = new Set(
+    (await query(
+      `SELECT indexname::text AS name FROM pg_indexes WHERE schemaname = current_schema() AND tablename = ${sqlText(target.table)}`
+    )).map((row) => String(row.name))
+  );
+  for (const field of target.removeIndexes) {
+    const [serverName, clientName] = koraIndexNames(target.table, field);
+    if (indexNames.has(serverName.toLowerCase())) {
+      statements.push(`DROP INDEX IF EXISTS ${serverName}`);
+    }
+    if (indexNames.has(clientName)) {
+      statements.push(`DROP INDEX IF EXISTS ${quoteIdentifier(clientName)}`);
+    }
+  }
+  for (const field of plan.drop) {
+    statements.push(`ALTER TABLE ${table} DROP COLUMN IF EXISTS ${quoteIdentifier(field)}`);
+  }
+  for (const [field, change] of plan.change) {
+    const column = quoteIdentifier(field);
+    const type = postgresType(change.to);
+    statements.push(`ALTER TABLE ${table} ALTER COLUMN ${column} DROP DEFAULT`);
+    statements.push(
+      `ALTER TABLE ${table} ALTER COLUMN ${column} TYPE ${type} USING CAST((${postgresProjection(column, change.from, change.to, now)}) AS ${type})`
+    );
+    if (change.to.default !== void 0) {
+      statements.push(
+        `ALTER TABLE ${table} ALTER COLUMN ${column} SET DEFAULT ${sqlDefaultLiteral(change.to.default)}`
+      );
+    }
+  }
+  for (const [field, spec] of plan.add) {
+    statements.push(
+      `ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${quoteIdentifier(field)} ${postgresType(spec)}${defaultClause(spec)}`
+    );
+    if (spec.auto && spec.kind === "timestamp" && spec.default === void 0) {
+      statements.push(`UPDATE ${table} SET ${quoteIdentifier(field)} = ${now}`);
+    }
+  }
+  for (const field of target.addIndexes) {
+    const name = koraIndexNames(target.table, field)[0];
+    if (indexNames.has(name.toLowerCase())) continue;
+    statements.push(`CREATE INDEX IF NOT EXISTS ${name} ON ${table} (${quoteIdentifier(field)})`);
+  }
+  return statements;
+}
+function planColumns(target, existing, typeOf) {
+  const plan = { add: [], drop: [], change: [] };
+  for (const [field, spec] of Object.entries(target.add)) {
+    if (!existing.has(field)) plan.add.push([field, spec]);
+  }
+  for (const [field, change] of Object.entries(target.change)) {
+    const current = existing.get(field);
+    if (current === void 0) {
+      plan.add.push([field, change.to]);
+      continue;
+    }
+    const from = typeOf(change.from);
+    const to = typeOf(change.to);
+    if (from !== to && current === to) continue;
+    plan.change.push([field, change]);
+  }
+  for (const field of target.drop) {
+    if (existing.has(field) && !(field in target.add) && !(field in target.change)) {
+      if (isKoraInternalColumn(field)) {
+        throw new Error(
+          `Migration directive refuses to drop Kora's own column "${field}" of "${target.table}".`
+        );
+      }
+      plan.drop.push(field);
+    }
+  }
+  return plan;
+}
+async function sqliteRebuildStatements(catalog, plan, query, removedIndexNames, now) {
+  const table = catalog.table;
+  const temp = `_kora_evolve_${table}`;
+  const dropped = new Set(plan.drop);
+  const changed = new Map(plan.change);
+  const ordered = [...catalog.columns].sort((a, b) => a.cid - b.cid).filter((column) => !dropped.has(column.name));
+  const pkColumns = ordered.filter((c) => c.pk > 0).sort((a, b) => a.pk - b.pk);
+  const fkGroups = /* @__PURE__ */ new Map();
+  for (const fk of catalog.foreignKeys) {
+    const group = fkGroups.get(fk.id) ?? [];
+    group.push(fk);
+    fkGroups.set(fk.id, group);
+  }
+  const columnReferences = /* @__PURE__ */ new Map();
+  const tableConstraints = [];
+  for (const group of fkGroups.values()) {
+    group.sort((a, b) => a.seq - b.seq);
+    const first = group[0];
+    if (!first || group.some((fk) => dropped.has(fk.from))) continue;
+    const actions = foreignKeyActions(first);
+    const targetRef = group.every((fk) => fk.to !== null && fk.to !== "") ? `${quoteIdentifier(first.table)}(${group.map((fk) => quoteIdentifier(fk.to ?? "")).join(", ")})` : quoteIdentifier(first.table);
+    if (group.length === 1) {
+      columnReferences.set(first.from, `REFERENCES ${targetRef}${actions}`);
+    } else {
+      tableConstraints.push(
+        `FOREIGN KEY (${group.map((fk) => quoteIdentifier(fk.from)).join(", ")}) REFERENCES ${targetRef}${actions}`
+      );
+    }
+  }
+  if (pkColumns.length > 1) {
+    tableConstraints.unshift(
+      `PRIMARY KEY (${pkColumns.map((c) => quoteIdentifier(c.name)).join(", ")})`
+    );
+  }
+  for (const unique of catalog.uniqueConstraints) {
+    if (unique.some((column) => dropped.has(column))) continue;
+    tableConstraints.push(`UNIQUE (${unique.map(quoteIdentifier).join(", ")})`);
+  }
+  for (const check of parseSqliteCheckConstraints(catalog.sql)) {
+    if (sqliteCheckReferencesColumn(check, dropped)) continue;
+    tableConstraints.push(sqliteCheckConstraintDefinition(check));
+  }
+  const definitions = [];
+  const targetColumns = [];
+  const selections = [];
+  for (const column of ordered) {
+    const change = changed.get(column.name);
+    const parts = [quoteIdentifier(column.name)];
+    if (change) {
+      parts.push(sqliteType(change.to));
+    } else if (column.type) {
+      parts.push(column.type);
+    }
+    if (pkColumns.length === 1 && column.pk === 1) parts.push("PRIMARY KEY");
+    if (column.notnull === 1) parts.push("NOT NULL");
+    if (change) {
+      if (change.to.default !== void 0) {
+        parts.push(`DEFAULT ${sqlDefaultLiteral(change.to.default)}`);
+      }
+    } else if (column.dflt_value !== null) {
+      parts.push(`DEFAULT (${column.dflt_value})`);
+    }
+    const reference = columnReferences.get(column.name);
+    if (reference) parts.push(reference);
+    definitions.push(parts.join(" "));
+    targetColumns.push(quoteIdentifier(column.name));
+    selections.push(
+      change ? sqliteProjection(quoteIdentifier(column.name), change.from, change.to, now) : quoteIdentifier(column.name)
+    );
+  }
+  for (const [field, spec] of plan.add) {
+    definitions.push(`${quoteIdentifier(field)} ${sqliteType(spec)}${defaultClause(spec)}`);
+    targetColumns.push(quoteIdentifier(field));
+    selections.push(fallbackLiteral(spec, now));
+  }
+  const indexColumns = await indexColumnsByName(query, table);
+  const dependents = [];
+  for (const row of await query(
+    `SELECT type, name, sql FROM sqlite_master WHERE type IN ('index', 'trigger') AND tbl_name = ${sqlText(table)} AND sql IS NOT NULL ORDER BY type, name`
+  )) {
+    const name = String(row.name);
+    if (row.type === "index") {
+      if (removedIndexNames.has(name)) continue;
+      if ((indexColumns.get(name) ?? []).some((column) => dropped.has(column))) continue;
+    }
+    dependents.push(String(row.sql));
+  }
+  return [
+    `DROP TABLE IF EXISTS ${quoteIdentifier(temp)}`,
+    `CREATE TABLE ${quoteIdentifier(temp)} (
+  ${[...definitions, ...tableConstraints].join(",\n  ")}
+)`,
+    `INSERT INTO ${quoteIdentifier(temp)} (${targetColumns.join(", ")}) SELECT ${selections.join(", ")} FROM ${quoteIdentifier(table)}`,
+    `DROP TABLE ${quoteIdentifier(table)}`,
+    `ALTER TABLE ${quoteIdentifier(temp)} RENAME TO ${quoteIdentifier(table)}`,
+    ...dependents
+  ];
+}
+async function indexColumnsByName(query, table) {
+  const out = /* @__PURE__ */ new Map();
+  for (const index of await query(`SELECT name FROM pragma_index_list(${sqlText(table)})`)) {
+    const name = String(index.name);
+    const info = await query(`SELECT name FROM pragma_index_info(${sqlText(name)}) ORDER BY seqno`);
+    out.set(
+      name,
+      info.filter((row) => typeof row.name === "string").map((row) => String(row.name))
+    );
+  }
+  return out;
+}
+async function singleColumnIndexes(query, table, ignore) {
+  const out = /* @__PURE__ */ new Set();
+  for (const [name, columns] of await indexColumnsByName(query, table)) {
+    if (ignore.has(name)) continue;
+    const only = columns[0];
+    if (columns.length === 1 && only !== void 0) out.add(only);
+  }
+  return out;
+}
+function koraIndexNames(table, field) {
+  quoteIdentifier(table);
+  quoteIdentifier(field);
+  return [`idx_${table}_${field}`, collectionIndexName(table, field)];
+}
+function defaultClause(spec) {
+  return spec.default !== void 0 ? ` DEFAULT ${sqlDefaultLiteral(spec.default)}` : "";
+}
+function sqliteType(spec) {
+  switch (spec.kind) {
+    case "number":
+      return "REAL";
+    case "boolean":
+    case "timestamp":
+      return "INTEGER";
+    case "richtext":
+      return "BLOB";
+    default:
+      return "TEXT";
+  }
+}
+function postgresType(spec) {
+  switch (spec.kind) {
+    case "number":
+      return "DOUBLE PRECISION";
+    case "boolean":
+      return "INTEGER";
+    case "timestamp":
+      return "BIGINT";
+    case "array":
+    case "object":
+    case "json":
+      return "JSONB";
+    case "richtext":
+      return "BYTEA";
+    default:
+      return "TEXT";
+  }
+}
+function fallbackLiteral(target, now) {
+  if (target.auto && target.kind === "timestamp") return String(now);
+  if (target.default !== void 0) return sqlDefaultLiteral(target.default);
+  return "NULL";
+}
+var NUMERIC_SOURCES = /* @__PURE__ */ new Set(["number", "timestamp", "boolean"]);
+var TEXT_SOURCES = /* @__PURE__ */ new Set(["string", "enum"]);
+var TRUE_WORDS = "('1','true','t','yes','y','on')";
+var FALSE_WORDS = "('0','false','f','no','n','off')";
+function sqliteProjection(column, source, target, now) {
+  if (source.kind === target.kind && source.itemKind === target.itemKind) return column;
+  const fallback = fallbackLiteral(target, now);
+  if (target.kind === "string") return `CAST(${column} AS TEXT)`;
+  if (target.kind === "number" || target.kind === "timestamp") {
+    if (NUMERIC_SOURCES.has(source.kind) || TEXT_SOURCES.has(source.kind)) {
+      const castType = target.kind === "number" ? "REAL" : "INTEGER";
+      return `CASE WHEN ${column} IS NULL THEN NULL ELSE CAST(${column} AS ${castType}) END`;
+    }
+  }
+  if (target.kind === "boolean") {
+    if (NUMERIC_SOURCES.has(source.kind)) {
+      return `CASE WHEN ${column} IS NULL THEN NULL WHEN CAST(${column} AS REAL) = 0 THEN 0 ELSE 1 END`;
+    }
+    if (TEXT_SOURCES.has(source.kind)) {
+      const word = `LOWER(TRIM(CAST(${column} AS TEXT)))`;
+      return `CASE WHEN ${column} IS NULL THEN NULL WHEN ${word} IN ${TRUE_WORDS} THEN 1 WHEN ${word} IN ${FALSE_WORDS} THEN 0 ELSE ${fallback} END`;
+    }
+  }
+  if (target.kind === "enum" && target.enumValues && target.enumValues.length > 0) {
+    if (TEXT_SOURCES.has(source.kind)) {
+      const allowed = target.enumValues.map((value) => sqlDefaultLiteral(value)).join(", ");
+      return `CASE WHEN ${column} IN (${allowed}) THEN ${column} ELSE ${fallback} END`;
+    }
+  }
+  return fallback;
+}
+function postgresProjection(column, source, target, now) {
+  if (source.kind === target.kind && source.itemKind === target.itemKind) return column;
+  const fallback = fallbackLiteral(target, now);
+  const text = `(${column})::text`;
+  if (target.kind === "string") return text;
+  if (target.kind === "number" || target.kind === "timestamp") {
+    const toTarget = (value) => target.kind === "number" ? value : `round(${value})::bigint`;
+    if (NUMERIC_SOURCES.has(source.kind)) {
+      return `CASE WHEN ${column} IS NULL THEN NULL ELSE ${toTarget(`(${column})::double precision`)} END`;
+    }
+    if (TEXT_SOURCES.has(source.kind)) {
+      const trimmed = `btrim(${text})`;
+      return `CASE WHEN ${column} IS NULL THEN NULL WHEN ${trimmed} ~ '^[-+]?([0-9]+([.][0-9]*)?|[.][0-9]+)([eE][-+]?[0-9]+)?$' THEN ${toTarget(`(${trimmed})::double precision`)} ELSE ${fallback} END`;
+    }
+  }
+  if (target.kind === "boolean") {
+    if (NUMERIC_SOURCES.has(source.kind)) {
+      return `CASE WHEN ${column} IS NULL THEN NULL WHEN (${column})::double precision = 0 THEN 0 ELSE 1 END`;
+    }
+    if (TEXT_SOURCES.has(source.kind)) {
+      const word = `lower(btrim(${text}))`;
+      return `CASE WHEN ${column} IS NULL THEN NULL WHEN ${word} IN ${TRUE_WORDS} THEN 1 WHEN ${word} IN ${FALSE_WORDS} THEN 0 ELSE ${fallback} END`;
+    }
+  }
+  if (target.kind === "enum" && target.enumValues && target.enumValues.length > 0) {
+    if (TEXT_SOURCES.has(source.kind)) {
+      const allowed = target.enumValues.map((value) => sqlDefaultLiteral(value)).join(", ");
+      return `CASE WHEN ${text} IN (${allowed}) THEN ${text} ELSE ${fallback} END`;
+    }
+  }
+  return fallback;
+}
+function foreignKeyActions(fk) {
+  let out = "";
+  const onDelete = fk.on_delete?.toUpperCase();
+  const onUpdate = fk.on_update?.toUpperCase();
+  if (onDelete && onDelete !== "NO ACTION") out += ` ON DELETE ${onDelete}`;
+  if (onUpdate && onUpdate !== "NO ACTION") out += ` ON UPDATE ${onUpdate}`;
+  return out;
+}
+function sqlText(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function quoteIdentifier(identifier) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(identifier)) {
+    throw new Error(`Invalid SQL identifier: ${identifier}`);
+  }
+  return `"${identifier}"`;
+}
+
+// src/commands/migrate/value-domain-directive.ts
+import {
+  planPostgresConstraintRelaxation,
+  planSqliteConstraintRelaxation
+} from "@korajs/core/internal";
+var RELAX_VALUE_DOMAIN_DIRECTIVE = "--kora:relax-value-domain";
+function formatRelaxValueDomainDirective(target) {
+  return `${RELAX_VALUE_DOMAIN_DIRECTIVE} ${JSON.stringify(target)}`;
+}
+function parseRelaxValueDomainDirective(statement) {
+  const trimmed = statement.trimStart();
+  if (!trimmed.startsWith(RELAX_VALUE_DOMAIN_DIRECTIVE)) return null;
+  const payload = trimmed.slice(RELAX_VALUE_DOMAIN_DIRECTIVE.length).trim();
+  let parsed;
+  try {
+    parsed = JSON.parse(payload);
+  } catch {
+    parsed = null;
+  }
+  if (typeof parsed !== "object" || parsed === null || typeof parsed.table !== "string" || !Array.isArray(parsed.fields) || !parsed.fields.every((field) => typeof field === "string") || parsed.enums !== void 0 && (!Array.isArray(parsed.enums) || !parsed.enums.every((field) => typeof field === "string"))) {
+    throw new Error(
+      `Malformed migration directive "${statement}": expected ${RELAX_VALUE_DOMAIN_DIRECTIVE} {"table": "...", "fields": ["..."]}. Regenerate the migration with \`kora migrate\`.`
+    );
+  }
+  const target = parsed;
+  return {
+    table: target.table,
+    fields: [...target.fields],
+    ...target.enums !== void 0 ? { enums: [...target.enums] } : {}
+  };
+}
+async function expandRelaxValueDomainForSqlite(target, query) {
+  return planSqliteConstraintRelaxation(query, [target.table], {
+    [target.table]: target.enums ?? target.fields
+  });
+}
+async function expandRelaxValueDomainForPostgres(target, query) {
+  return planPostgresConstraintRelaxation(
+    query,
+    { [target.table]: target.fields },
+    target.enums !== void 0 ? { [target.table]: target.enums } : {}
+  );
+}
+
+// src/commands/migrate/migration-generator.ts
+function generateMigration(previous, current, diff) {
+  const up = [];
+  const downGroups = [];
+  for (const change of diff.changes) {
+    if (change.type === "collection-added") {
+      const collectionDef = current.collections[change.collection];
+      if (!collectionDef) continue;
+      up.push(...generateSQL(change.collection, collectionDef));
+      downGroups.push(dropCollectionStatements(change.collection));
+    }
+    if (change.type === "collection-removed") {
+      const collectionDef = previous.collections[change.collection];
+      up.push(...dropCollectionStatements(change.collection));
+      if (collectionDef) {
+        downGroups.push(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;
+    const valueDomainOnly = diff.changes.every(
+      (change) => change.collection !== collection || change.type === "field-changed" && isValueDomainChange(change.before, change.after)
+    );
+    if (valueDomainOnly) {
+      const directive = relaxValueDomainDirective(collection, previousDef, currentDef);
+      up.push(directive);
+      downGroups.push([directive]);
+      continue;
+    }
+    validateRebuildSafety(collection, previousDef, currentDef);
+    const relax = relaxValueDomainDirective(collection, previousDef, currentDef);
+    up.push(relax, formatEvolveTableDirective(evolveTarget(collection, previousDef, currentDef)));
+    downGroups.push([
+      relax,
+      formatEvolveTableDirective(evolveTarget(collection, currentDef, previousDef))
+    ]);
+  }
+  return {
+    up,
+    down: downGroups.reverse().flat(),
+    summary: diff.changes.map(formatChange),
+    containsBreakingChanges: diff.hasBreakingChanges
+  };
+}
+function isValueDomainChange(before, after) {
+  return before.kind === after.kind && before.itemKind === after.itemKind && before.auto === after.auto;
+}
+function evolveTarget(collection, from, to) {
+  const target = {
+    table: collection,
+    add: {},
+    drop: [],
+    change: {},
+    addIndexes: to.indexes.filter((field) => !from.indexes.includes(field)),
+    removeIndexes: from.indexes.filter((field) => !to.indexes.includes(field))
+  };
+  for (const [field, descriptor] of Object.entries(to.fields)) {
+    const before = from.fields[field];
+    if (!before) {
+      target.add[field] = evolveFieldSpec(descriptor);
+    } else if (before.kind !== descriptor.kind || before.itemKind !== descriptor.itemKind) {
+      target.change[field] = { from: evolveFieldSpec(before), to: evolveFieldSpec(descriptor) };
+    }
+  }
+  target.drop = Object.keys(from.fields).filter((field) => !(field in to.fields));
+  return target;
+}
+function relaxValueDomainDirective(collection, from, to) {
+  const fields = [.../* @__PURE__ */ new Set([...Object.keys(from.fields), ...Object.keys(to.fields)])].sort();
+  const enums = fields.filter(
+    (field) => from.fields[field]?.kind === "enum" || to.fields[field]?.kind === "enum"
+  );
+  return formatRelaxValueDomainDirective({ table: collection, fields, enums });
+}
+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 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 dropCollectionStatements(collection) {
+  const table = quoteIdentifier2(collection);
+  const opsTable = quoteIdentifier2(`_kora_ops_${collection}`);
+  return [`DROP TABLE IF EXISTS ${table}`, `DROP TABLE IF EXISTS ${opsTable}`];
+}
+function quoteIdentifier2(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 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;
+  const foreignKeysOn = Number(db.query?.("PRAGMA foreign_keys")[0]?.foreign_keys ?? 0) === 1;
+  if (foreignKeysOn) db.exec("PRAGMA foreign_keys = OFF");
+  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
+      };
+    }
+    const now = Date.now();
+    const catalogQuery = (table) => {
+      const query = db.query?.bind(db);
+      if (!query) {
+        throw new Error(
+          `Migration ${migrationId}: the SQLite driver cannot read the catalog needed to migrate "${table}".`
+        );
+      }
+      return async (text) => query(text);
+    };
+    for (const statement of statements) {
+      const relax = parseRelaxValueDomainDirective(statement);
+      const evolve = relax ? null : parseEvolveTableDirective(statement);
+      if (relax) {
+        const expanded = await expandRelaxValueDomainForSqlite(relax, catalogQuery(relax.table));
+        for (const rebuild of expanded) db.exec(rebuild);
+      } else if (evolve) {
+        const expanded = await expandEvolveTableForSqlite(evolve, catalogQuery(evolve.table), now);
+        for (const change of expanded) db.exec(change);
+      } else {
+        db.exec(statement);
+      }
+      statementsApplied++;
+    }
+    const violations = db.query?.("PRAGMA foreign_key_check") ?? [];
+    if (violations.length > 0) {
+      throw new Error(
+        `Migration ${migrationId} left ${violations.length} foreign key violation(s) (first: ${JSON.stringify(violations[0])}); nothing was applied.`
+      );
+    }
+    db.exec(
+      `INSERT OR REPLACE INTO _kora_migrations (id, from_version, to_version, applied_at) VALUES (${sqlLiteral(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 (foreignKeysOn) {
+      try {
+        db.exec("PRAGMA foreign_keys = ON");
+      } catch {
+      }
+    }
+    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.meta.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;
+          },
+          query(sql) {
+            return db.prepare(sql).all();
+          },
+          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) : (
+    // One connection: BEGIN, the statements and COMMIT must share it (postgres.js
+    // refuses a raw BEGIN on a pool, UNSAFE_TRANSACTION).
+    (await loadPostgresModule()).default(connectionString, { max: 1 })
+  );
+  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 = ${sqlLiteral(migrationId)}`
+    );
+    if ((existing[0]?.count ?? 0) > 0) {
+      await sql.unsafe("COMMIT");
+      return {
+        backend: "postgres",
+        statementsApplied: 0,
+        historyRecorded: true,
+        skipped: true
+      };
+    }
+    const now = Date.now();
+    const query = async (text) => await sql.unsafe(text);
+    for (const statement of statements) {
+      const relax = parseRelaxValueDomainDirective(statement);
+      const evolve = relax ? null : parseEvolveTableDirective(statement);
+      if (relax) {
+        const expanded = await expandRelaxValueDomainForPostgres(relax, query);
+        for (const alter of expanded) await sql.unsafe(alter);
+      } else if (evolve) {
+        const expanded = await expandEvolveTableForPostgres(evolve, query, now);
+        for (const alter of expanded) await sql.unsafe(alter);
+      } else {
+        assertNotLegacyRebuild(statement, migrationId);
+        await sql.unsafe(statement);
+      }
+      statementsApplied++;
+    }
+    await sql.unsafe(
+      `INSERT INTO _kora_migrations (id, from_version, to_version, applied_at) VALUES (${sqlLiteral(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 assertNotLegacyRebuild(statement, migrationId) {
+  if (/^\s*CREATE\s+TABLE\s+"?_kora_mig_[A-Za-z0-9_]+_new"?/i.test(statement)) {
+    throw new Error(
+      `Migration ${migrationId} was generated by an earlier \`kora migrate\` as a SQLite-only table rebuild, which cannot run on Postgres. Regenerate it: restore kora/schema.snapshot.json to the schema version it migrates from, delete the migration's files, and run \`kora migrate\` again.`
+    );
+  }
+}
+function sqlLiteral(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/operation-transform-generator.ts
+function generateOperationTransformModule(fromVersion, toVersion) {
+  return [
+    "import type { Operation, OperationTransform } from '@korajs/core'",
+    "",
+    "/**",
+    ` * Operation transforms for schema v${fromVersion} \u2192 v${toVersion}.`,
+    " * Implement `transform` to rewrite or drop legacy operations during sync.",
+    " * @see https://korajs.dev/docs/migrations",
+    " */",
+    "export const operationTransforms: OperationTransform[] = [",
+    "  {",
+    `    fromVersion: ${fromVersion},`,
+    `    toVersion: ${toVersion},`,
+    "    transform(operation: Operation): Operation | null {",
+    "      // Return null to drop unmigratable operations.",
+    "      return operation",
+    "    },",
+    "  },",
+    "]",
+    ""
+  ].join("\n");
+}
+
+// src/commands/migrate/migrate-command.ts
+var SNAPSHOT_PATH = "kora/schema.snapshot.json";
+var MIGRATIONS_DIR = "kora/migrations";
+var migrateCommand = defineCommand7({
+  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" ? resolve5(projectRoot, args.schema) : typeof config?.schema === "string" ? resolve5(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 = join6(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" ? resolve5(projectRoot, args["output-dir"]) : resolve5(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 mkdir2(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 readFile3(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 mkdir2(dirname2(path), { recursive: true });
+  await writeFile3(path, `${JSON.stringify(schema, null, 2)}
+`, "utf-8");
+}
+async function writeMigrationFile(outputDir, fromVersion, toVersion, generated) {
+  const existing = await 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 = join6(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 writeFile3(path, fileContent, "utf-8");
+  const transformsPath = join6(outputDir, `${migrationId}.transforms.ts`);
+  await writeFile3(transformsPath, generateOperationTransformModule(fromVersion, toVersion), "utf-8");
+  await writeMigrationManifest(join6(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 writeFile3(path, `${JSON.stringify(manifest, null, 2)}
+`, "utf-8");
+}
+async function listMigrationManifests(outputDir) {
+  const files = await 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 = join6(outputDir, `${id}.json`);
+    const jsonManifest = await readMigrationManifest(manifestPath);
+    if (jsonManifest) {
+      manifests.push({ ...jsonManifest, id });
+      continue;
+    }
+    const migrationPath = join6(outputDir, file);
+    const sourceManifest = await readMigrationManifestFromSource(migrationPath, id);
+    manifests.push(sourceManifest);
+  }
+  return manifests;
+}
+async function readMigrationManifest(path) {
+  try {
+    const content = await readFile3(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 readFile3(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.`);
+  }
+  const fromVersionText = match[1];
+  const toVersionText = match[2];
+  if (fromVersionText === void 0 || toVersionText === void 0) {
+    throw new Error(`Migration id "${id}" does not include a vX-to-vY version suffix.`);
+  }
+  return {
+    fromVersion: Number.parseInt(fromVersionText, 10),
+    toVersion: Number.parseInt(toVersionText, 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 resolve5(projectRoot, dbArg);
+  }
+  const sync = config?.dev?.sync;
+  if (typeof sync === "object" && sync !== null) {
+    if (sync.store === "sqlite") {
+      return join6(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 resolve5(projectRoot, sync.store.filename);
+      }
+      return join6(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/commands/status/status-command.ts
+import { defineCommand as defineCommand8 } from "citty";
+var DEFAULT_SYNC_PORT3 = 3001;
+var STATUS_ENDPOINT2 = "/__kora/status";
+async function fetchServerStatus(url, token) {
+  const statusUrl = `${url.replace(/\/$/, "")}${STATUS_ENDPOINT2}`;
+  const response = await fetch(statusUrl, {
+    headers: token ? { Authorization: `Bearer ${token}` } : void 0
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch status from ${statusUrl}: ${response.status} ${response.statusText}`
+    );
+  }
+  return await response.json();
+}
+function formatUptime(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const parts = [];
+  if (days > 0) parts.push(`${days}d`);
+  if (hours % 24 > 0) parts.push(`${hours % 24}h`);
+  if (minutes % 60 > 0) parts.push(`${minutes % 60}m`);
+  parts.push(`${seconds % 60}s`);
+  return parts.join(" ");
+}
+var statusCommand = defineCommand8({
+  meta: {
+    name: "status",
+    description: "Show Kora sync server status"
+  },
+  args: {
+    url: {
+      type: "string",
+      description: "Sync server URL (default: http://localhost:3001)",
+      default: `http://localhost:${DEFAULT_SYNC_PORT3}`
+    },
+    watch: {
+      type: "boolean",
+      description: "Live-updating status (like htop)",
+      default: false,
+      alias: "w"
+    },
+    token: {
+      type: "string",
+      description: "Admin token (defaults to KORA_ADMIN_TOKEN)"
+    }
+  },
+  async run({ args }) {
+    const logger = createLogger();
+    const url = typeof args.url === "string" ? args.url : `http://localhost:${DEFAULT_SYNC_PORT3}`;
+    const watch2 = args.watch === true;
+    const token = typeof args.token === "string" ? args.token : process.env.KORA_ADMIN_TOKEN ?? void 0;
+    try {
+      if (watch2) {
+        console.clear();
+        logger.banner();
+        logger.info(`Connecting to ${url}...`);
+        const interval = setInterval(async () => {
+          try {
+            const status = await fetchServerStatus(url, token);
+            printStatus(status, url, logger);
+          } catch {
+          }
+        }, 2e3);
+        try {
+          const status = await fetchServerStatus(url, token);
+          printStatus(status, url, logger);
+        } catch {
+        }
+        await new Promise(() => {
+          process.on("SIGINT", () => {
+            clearInterval(interval);
+            process.exit(0);
+          });
+          process.on("SIGTERM", () => {
+            clearInterval(interval);
+            process.exit(0);
+          });
+        });
+      } else {
+        const status = await fetchServerStatus(url, token);
+        printStatus(status, url, logger);
+      }
+    } catch (error) {
+      logger.error(`Failed to connect to ${url}`);
+      if (error instanceof Error) {
+        logger.error(error.message);
+      }
+      logger.blank();
+      logger.step("Make sure the Kora sync server is running.");
+      logger.step("Start it with: kora dev");
+      process.exit(1);
+    }
+  }
+});
+function printStatus(status, url, logger) {
+  console.clear();
+  logger.banner();
+  logger.info(`Kora Sync Server \u2014 ${url}`);
+  logger.blank();
+  if (!status.running) {
+    logger.error("Server is not running");
+    return;
+  }
+  logger.step(`Status:     Running (uptime: ${formatUptime(status.uptime)}) \u2014 v${status.version}`);
+  logger.step(`Schema:     v${status.schemaVersion}`);
+  logger.blank();
+  logger.step(`Connections: ${status.connectedClients} connected`);
+  logger.step(`  Peak:      ${status.peakConnections}`);
+  logger.step(`  Total:     ${status.connectionsTotal}`);
+  if (status.connectedNodeIds.length > 0) {
+    logger.step("  Active nodes:");
+    for (const nodeId of status.connectedNodeIds) {
+      logger.step(`    \u2022 ${nodeId}`);
+    }
+  }
+  logger.blank();
+  logger.step("Operations:");
+  logger.step(`  Received:  ${status.operationsReceived.toLocaleString()}`);
+  logger.step(`  Sent:      ${status.operationsSent.toLocaleString()}`);
+  logger.step(`  Total:     ${status.totalOperations.toLocaleString()}`);
+  logger.blank();
+  if (status.errorCount > 0) {
+    logger.warn(`Errors: ${status.errorCount}`);
+  } else {
+    logger.step("Errors:     0");
+  }
+}
+
+// src/commands/studio/studio-command.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve6 } from "path";
+import { defineCommand as defineCommand9 } from "citty";
+var studioCommand = defineCommand9({
+  meta: {
+    name: "studio",
+    description: "Kora Studio: visualize records, operations, and sync \u2014 or run the sync lab"
+  },
+  args: {
+    db: {
+      type: "string",
+      description: "Path to a Kora SQLite database file (file mode, read-only)"
+    },
+    lab: {
+      type: "boolean",
+      description: "Start the interactive multi-device sync laboratory"
+    },
+    connect: {
+      type: "string",
+      description: "Spectator mode: WebSocket URL of a live Kora sync server (read-only replica)"
+    },
+    token: {
+      type: "string",
+      description: "Spectator mode: bearer token for the sync auth handshake"
+    },
+    devices: {
+      type: "string",
+      description: "Lab mode: number of initial devices (default 2)"
+    },
+    schema: {
+      type: "string",
+      description: "Lab mode: path to a schema file (defaults to a built-in demo schema)"
+    },
+    port: {
+      type: "string",
+      description: "Port for the Studio UI (default 4321, 0 for a random free port)"
+    }
+  },
+  async run({ args }) {
+    const logger = createLogger();
+    const port = args.port !== void 0 ? Number.parseInt(args.port, 10) : 4321;
+    if (Number.isNaN(port) || port < 0 || port > 65535) {
+      throw new Error(`Invalid port "${args.port}"`);
+    }
+    const { startStudioServer } = await import("./studio-server-XLGZNGG5.js");
+    if (typeof args.connect === "string") {
+      if (typeof args.schema !== "string") {
+        throw new Error(
+          "Spectator mode needs your schema to materialize records: kora studio --connect wss://\u2026 --schema ./kora/schema.ts"
+        );
+      }
+      const { loadSchemaDefinition: loadSchemaDefinition2 } = await import("./schema-loader-GGHECMTM.js");
+      const schema = await loadSchemaDefinition2(resolve6(process.cwd(), args.schema), process.cwd());
+      const { SpectatorManager } = await import("./spectator-manager-FTH2NFSE.js");
+      const spectator = new SpectatorManager({
+        url: args.connect,
+        schema,
+        ...typeof args.token === "string" ? { token: args.token } : {}
+      });
+      await spectator.start();
+      const server2 = await startStudioServer({ port, spectator });
+      logger.banner();
+      logger.success(`Kora Studio SPECTATOR running at ${server2.url}`);
+      logger.step(`Watching ${args.connect} (read-only replica \u2014 nothing is ever pushed)`);
+      logger.step("Press Ctrl+C to stop.");
+      const shutdown2 = async () => {
+        await server2.close();
+        await spectator.close();
+        process.exit(0);
+      };
+      process.on("SIGINT", () => void shutdown2());
+      process.on("SIGTERM", () => void shutdown2());
+      return;
+    }
+    if (args.lab) {
+      const { LabManager, defaultLabSchema } = await import("./lab-manager-KUDII6BT.js");
+      let schema = defaultLabSchema();
+      if (typeof args.schema === "string") {
+        const { loadSchemaDefinition: loadSchemaDefinition2 } = await import("./schema-loader-GGHECMTM.js");
+        schema = await loadSchemaDefinition2(resolve6(process.cwd(), args.schema), process.cwd());
+      }
+      const initialDevices = args.devices !== void 0 ? Math.max(1, Number.parseInt(args.devices, 10) || 2) : 2;
+      const lab = new LabManager(schema);
+      await lab.start(initialDevices);
+      const server2 = await startStudioServer({ port, lab });
+      logger.banner();
+      logger.success(`Kora Studio LAB running at ${server2.url}`);
+      logger.step(`${initialDevices} device(s) started against an in-process sync server.`);
+      logger.step("Everything in the lab is throwaway \u2014 experiment freely.");
+      logger.step("Press Ctrl+C to stop.");
+      const shutdown2 = async () => {
+        await server2.close();
+        await lab.close();
+        process.exit(0);
+      };
+      process.on("SIGINT", () => void shutdown2());
+      process.on("SIGTERM", () => void shutdown2());
+      return;
+    }
+    if (typeof args.db !== "string") {
+      throw new Error(
+        "Pass --db <path> to inspect a database, --lab for the sync laboratory, or --connect <wss url> for live spectator mode."
+      );
+    }
+    const dbPath = resolve6(process.cwd(), args.db);
+    if (!existsSync2(dbPath)) {
+      throw new Error(`Database file not found: ${dbPath}`);
+    }
+    const server = await startStudioServer({ port, dbPath });
+    logger.banner();
+    logger.success(`Kora Studio running at ${server.url}`);
+    logger.step(`Database: ${dbPath} (read-only)`);
+    logger.step("Press Ctrl+C to stop.");
+    const shutdown = async () => {
+      await server.close();
+      process.exit(0);
+    };
+    process.on("SIGINT", () => void shutdown());
+    process.on("SIGTERM", () => void shutdown());
+  }
+});
+
+// src/bin.ts
+var main = defineCommand10({
+  meta: {
+    name: "kora",
+    description: "Kora.js, the offline-first application framework"
+  },
+  subCommands: {
+    "agents-md": agentsCommand,
+    backup: backupCommand,
+    compact: compactCommand,
+    create: createCommand,
+    dev: devCommand,
+    doctor: doctorCommand,
+    deploy: deployCommand,
+    generate: generateCommand,
+    logs: logsCommand,
+    migrate: migrateCommand,
+    status: statusCommand,
+    studio: studioCommand
+  }
+});
+runMain(main);
+//# sourceMappingURL=bin.js.map