@korajs/cli 0.4.0 → 0.5.0

package/dist/bin.cjs

@@ -23,67 +23,600 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/bin.ts
-var import_citty6 = require("citty");
+var import_citty11 = require("citty");
+
+// src/commands/backup/backup-command.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_citty = require("citty");
+
+// src/utils/logger.ts
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var CYAN = "\x1B[36m";
+function createLogger(options) {
+  const colorDisabled = options?.noColor === true || process.env.NO_COLOR !== void 0 || !process.stdout.isTTY;
+  function color(code, text) {
+    return colorDisabled ? text : `${code}${text}${RESET}`;
+  }
+  return {
+    info(message) {
+      console.log(color(CYAN, message));
+    },
+    success(message) {
+      console.log(color(GREEN, `  \u2713 ${message}`));
+    },
+    warn(message) {
+      console.warn(color(YELLOW, `  \u26A0 ${message}`));
+    },
+    error(message) {
+      console.error(color(RED, `  \u2717 ${message}`));
+    },
+    step(message) {
+      console.log(color(DIM, `  ${message}`));
+    },
+    blank() {
+      console.log();
+    },
+    banner() {
+      console.log();
+      console.log(
+        color(BOLD + CYAN, "  Kora.js") + color(DIM, " \u2014 Offline-first application framework")
+      );
+      console.log();
+    }
+  };
+}
+
+// src/commands/backup/backup-command.ts
+var DEFAULT_SYNC_PORT = 3001;
+var backupCommand = (0, import_citty.defineCommand)({
+  meta: {
+    name: "backup",
+    description: "Backup and restore Kora sync server data"
+  },
+  subCommands: {
+    create: (0, import_citty.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 (0, import_promises.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: (0, import_citty.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 (0, import_promises.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: (0, import_citty.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 (0, import_promises.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
+var import_node_path5 = require("path");
+var import_citty2 = require("citty");
+
+// src/errors.ts
+var import_core = require("@korajs/core");
+var ProjectExistsError = class extends import_core.KoraError {
+  constructor(directory) {
+    super(
+      `Directory "${directory}" already exists. Choose a different name or remove the existing directory.`,
+      "PROJECT_EXISTS",
+      { directory }
+    );
+    this.directory = directory;
+    this.name = "ProjectExistsError";
+  }
+  directory;
+};
+var SchemaNotFoundError = class extends import_core.KoraError {
+  constructor(searchedPaths) {
+    super(
+      `Could not find a schema file. Searched: ${searchedPaths.join(", ")}. Create a schema file using defineSchema() from @korajs/core.`,
+      "SCHEMA_NOT_FOUND",
+      { searchedPaths }
+    );
+    this.searchedPaths = searchedPaths;
+    this.name = "SchemaNotFoundError";
+  }
+  searchedPaths;
+};
+var InvalidProjectError = class extends import_core.KoraError {
+  constructor(directory) {
+    super(
+      `"${directory}" is not a valid Kora project. No package.json with a kora dependency found. Run this command from inside a Kora project.`,
+      "INVALID_PROJECT",
+      { directory }
+    );
+    this.directory = directory;
+    this.name = "InvalidProjectError";
+  }
+  directory;
+};
+var DevServerError = class extends import_core.KoraError {
+  constructor(binary, searchPath) {
+    super(
+      `Could not find required binary "${binary}" at ${searchPath}. Install project dependencies and try again.`,
+      "DEV_SERVER_ERROR",
+      { binary, searchPath }
+    );
+    this.binary = binary;
+    this.searchPath = searchPath;
+    this.name = "DevServerError";
+  }
+  binary;
+  searchPath;
+};
+
+// src/utils/fs-helpers.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+async function directoryExists(path) {
+  try {
+    await (0, import_promises2.access)(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findProjectRoot(startDir) {
+  let current = (0, import_node_path2.resolve)(startDir ?? process.cwd());
+  for (; ; ) {
+    const pkgPath = (0, import_node_path2.join)(current, "package.json");
+    try {
+      const content = await (0, import_promises2.readFile)(pkgPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (isKoraProject(pkg)) {
+        return current;
+      }
+    } catch {
+    }
+    const parent = (0, import_node_path2.dirname)(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+async function findSchemaFile(projectRoot) {
+  const candidates = [
+    (0, import_node_path2.join)(projectRoot, "src", "schema.ts"),
+    (0, import_node_path2.join)(projectRoot, "schema.ts"),
+    (0, import_node_path2.join)(projectRoot, "src", "schema.js"),
+    (0, import_node_path2.join)(projectRoot, "schema.js")
+  ];
+  for (const candidate of candidates) {
+    try {
+      await (0, import_promises2.access)(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+async function hasTsxInstalled(projectRoot) {
+  try {
+    await (0, import_promises2.access)((0, import_node_path2.join)(projectRoot, "node_modules", "tsx", "package.json"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveProjectBinaryEntryPoint(projectRoot, packageName, binaryName) {
+  const pkgJsonPath = (0, import_node_path2.join)(projectRoot, "node_modules", packageName, "package.json");
+  try {
+    const content = await (0, import_promises2.readFile)(pkgJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    let binPath;
+    if (typeof pkg.bin === "string") {
+      binPath = pkg.bin;
+    } else if (typeof pkg.bin === "object" && pkg.bin !== null) {
+      binPath = pkg.bin[binaryName];
+    }
+    if (!binPath) return null;
+    const fullPath = (0, import_node_path2.join)(projectRoot, "node_modules", packageName, binPath);
+    await (0, import_promises2.access)(fullPath);
+    return fullPath;
+  } catch {
+    return null;
+  }
+}
+function isKoraProject(pkg) {
+  if (typeof pkg !== "object" || pkg === null) return false;
+  const record = pkg;
+  return hasKoraDep(record.dependencies) || hasKoraDep(record.devDependencies);
+}
+function hasKoraDep(deps) {
+  if (typeof deps !== "object" || deps === null) return false;
+  return Object.keys(deps).some((key) => key === "kora" || key.startsWith("@korajs/"));
+}
+
+// src/commands/dev/kora-config.ts
+var import_node_child_process = require("child_process");
+var import_promises3 = require("fs/promises");
+var import_node_path3 = require("path");
+var import_node_url = require("url");
+var CONFIG_CANDIDATES = [
+  "kora.config.ts",
+  "kora.config.mts",
+  "kora.config.cts",
+  "kora.config.js",
+  "kora.config.mjs",
+  "kora.config.cjs"
+];
+async function loadKoraConfig(projectRoot) {
+  const configPath = await findKoraConfigFile(projectRoot);
+  if (!configPath) return null;
+  const ext = (0, import_node_path3.extname)(configPath);
+  if (ext === ".ts" || ext === ".mts" || ext === ".cts") {
+    const loaded2 = await loadTypeScriptConfig(configPath, projectRoot);
+    return toConfigObject(loaded2);
+  }
+  const loaded = await import((0, import_node_url.pathToFileURL)(configPath).href);
+  return toConfigObject(loaded);
+}
+async function findKoraConfigFile(projectRoot) {
+  for (const file of CONFIG_CANDIDATES) {
+    const candidate = (0, import_node_path3.join)(projectRoot, file);
+    try {
+      await (0, import_promises3.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((resolve11, reject) => {
+    const child = (0, import_node_child_process.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) {
+        resolve11(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/migrate/schema-loader.ts
+var import_node_child_process2 = require("child_process");
+var import_node_path4 = require("path");
+var import_node_url2 = require("url");
+async function loadSchemaDefinition(schemaPath, projectRoot) {
+  const ext = (0, import_node_path4.extname)(schemaPath);
+  const moduleValue = ext === ".ts" || ext === ".mts" || ext === ".cts" ? await loadTypeScriptModule(schemaPath, projectRoot) : await import(`${(0, import_node_url2.pathToFileURL)(schemaPath).href}?t=${Date.now()}-${Math.random()}`);
+  return extractSchema(moduleValue);
+}
+function extractSchema(value) {
+  if (typeof value !== "object" || value === null) {
+    throw new Error("Schema module must export an object.");
+  }
+  const moduleRecord = value;
+  const candidate = moduleRecord.default ?? moduleRecord;
+  if (!isSchemaDefinition(candidate)) {
+    throw new Error("Schema module must export a valid SchemaDefinition as default export.");
+  }
+  return candidate;
+}
+function isSchemaDefinition(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const object = value;
+  return typeof object.version === "number" && typeof object.collections === "object" && object.collections !== null && typeof object.relations === "object" && object.relations !== null;
+}
+async function loadTypeScriptModule(schemaPath, projectRoot) {
+  if (!await hasTsxInstalled(projectRoot)) {
+    throw new Error(
+      `Schema file is TypeScript (${schemaPath}) but local "tsx" was not found. Install tsx in the project.`
+    );
+  }
+  const script = "const modulePath = process.argv[process.argv.length - 1];import('node:url').then(u => import(u.pathToFileURL(modulePath).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 runCommand2(
+    process.execPath,
+    ["--import", "tsx", "--eval", script, schemaPath],
+    projectRoot
+  );
+  try {
+    return JSON.parse(output);
+  } catch {
+    throw new Error(`Failed to parse schema module output for ${schemaPath}`);
+  }
+}
+async function runCommand2(command, args, cwd) {
+  return await new Promise((resolve11, reject) => {
+    const child = (0, import_node_child_process2.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) {
+        resolve11(stdout.trim());
+        return;
+      }
+      reject(
+        new Error(`Failed to load TypeScript schema (exit ${code ?? "unknown"}): ${stderr.trim()}`)
+      );
+    });
+  });
+}
+
+// src/commands/compact/compact-command.ts
+var compactCommand = (0, import_citty2.defineCommand)({
+  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" ? (0, import_node_path5.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" ? (0, import_node_path5.resolve)(projectRoot, args.schema) : typeof config?.schema === "string" ? (0, import_node_path5.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/create/create-command.ts
-var import_node_child_process2 = require("child_process");
+var import_node_child_process4 = require("child_process");
 var import_node_fs2 = require("fs");
-var import_node_path5 = require("path");
-var import_node_url2 = require("url");
-var import_citty = require("citty");
-
-// src/errors.ts
-var import_core = require("@korajs/core");
-var ProjectExistsError = class extends import_core.KoraError {
-  constructor(directory) {
-    super(
-      `Directory "${directory}" already exists. Choose a different name or remove the existing directory.`,
-      "PROJECT_EXISTS",
-      { directory }
-    );
-    this.directory = directory;
-    this.name = "ProjectExistsError";
-  }
-  directory;
-};
-var SchemaNotFoundError = class extends import_core.KoraError {
-  constructor(searchedPaths) {
-    super(
-      `Could not find a schema file. Searched: ${searchedPaths.join(", ")}. Create a schema file using defineSchema() from @korajs/core.`,
-      "SCHEMA_NOT_FOUND",
-      { searchedPaths }
-    );
-    this.searchedPaths = searchedPaths;
-    this.name = "SchemaNotFoundError";
-  }
-  searchedPaths;
-};
-var InvalidProjectError = class extends import_core.KoraError {
-  constructor(directory) {
-    super(
-      `"${directory}" is not a valid Kora project. No package.json with a kora dependency found. Run this command from inside a Kora project.`,
-      "INVALID_PROJECT",
-      { directory }
-    );
-    this.directory = directory;
-    this.name = "InvalidProjectError";
-  }
-  directory;
-};
-var DevServerError = class extends import_core.KoraError {
-  constructor(binary, searchPath) {
-    super(
-      `Could not find required binary "${binary}" at ${searchPath}. Install project dependencies and try again.`,
-      "DEV_SERVER_ERROR",
-      { binary, searchPath }
-    );
-    this.binary = binary;
-    this.searchPath = searchPath;
-    this.name = "DevServerError";
-  }
-  binary;
-  searchPath;
-};
+var import_node_path9 = require("path");
+var import_node_url4 = require("url");
+var import_citty3 = require("citty");
 
 // src/prompts/preferences.ts
 var import_conf = __toESM(require("conf"), 1);
@@ -128,18 +661,18 @@ var import_prompts = require("@clack/prompts");
 // src/utils/prompt.ts
 var import_node_readline = require("readline");
 function promptText(message, defaultValue, options) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve11) => {
     const rl = createReadline(options);
     const suffix = defaultValue !== void 0 ? ` (${defaultValue})` : "";
     rl.question(`  ? ${message}${suffix}: `, (answer) => {
       rl.close();
       const trimmed = answer.trim();
-      resolve9(trimmed || defaultValue || "");
+      resolve11(trimmed || defaultValue || "");
     });
   });
 }
 function promptSelect(message, choices, options) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve11) => {
     const rl = createReadline(options);
     const out = options?.output ?? process.stdout;
     out.write(`  ? ${message}
@@ -157,7 +690,7 @@ function promptSelect(message, choices, options) {
         const selected = choices[index];
         if (selected) {
           rl.close();
-          resolve9(selected.value);
+          resolve11(selected.value);
         } else {
           out.write(`  Please enter a number between 1 and ${choices.length}
 `);
@@ -169,7 +702,7 @@ function promptSelect(message, choices, options) {
   });
 }
 function promptConfirm(message, defaultValue = false, options) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve11) => {
     const rl = createReadline(options);
     const suffix = defaultValue ? "Y/n" : "y/N";
     const ask = () => {
@@ -177,17 +710,17 @@ function promptConfirm(message, defaultValue = false, options) {
         const normalized = answer.trim().toLowerCase();
         if (normalized.length === 0) {
           rl.close();
-          resolve9(defaultValue);
+          resolve11(defaultValue);
           return;
         }
         if (normalized === "y" || normalized === "yes") {
           rl.close();
-          resolve9(true);
+          resolve11(true);
           return;
         }
         if (normalized === "n" || normalized === "no") {
           rl.close();
-          resolve9(false);
+          resolve11(false);
           return;
         }
         ;
@@ -300,132 +833,8 @@ var TEMPLATES = [
   "tauri-react"
 ];
 
-// src/utils/fs-helpers.ts
-var import_promises = require("fs/promises");
-var import_node_path = require("path");
-async function directoryExists(path) {
-  try {
-    await (0, import_promises.access)(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function findProjectRoot(startDir) {
-  let current = (0, import_node_path.resolve)(startDir ?? process.cwd());
-  for (; ; ) {
-    const pkgPath = (0, import_node_path.join)(current, "package.json");
-    try {
-      const content = await (0, import_promises.readFile)(pkgPath, "utf-8");
-      const pkg = JSON.parse(content);
-      if (isKoraProject(pkg)) {
-        return current;
-      }
-    } catch {
-    }
-    const parent = (0, import_node_path.dirname)(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  return null;
-}
-async function findSchemaFile(projectRoot) {
-  const candidates = [
-    (0, import_node_path.join)(projectRoot, "src", "schema.ts"),
-    (0, import_node_path.join)(projectRoot, "schema.ts"),
-    (0, import_node_path.join)(projectRoot, "src", "schema.js"),
-    (0, import_node_path.join)(projectRoot, "schema.js")
-  ];
-  for (const candidate of candidates) {
-    try {
-      await (0, import_promises.access)(candidate);
-      return candidate;
-    } catch {
-    }
-  }
-  return null;
-}
-async function hasTsxInstalled(projectRoot) {
-  try {
-    await (0, import_promises.access)((0, import_node_path.join)(projectRoot, "node_modules", "tsx", "package.json"));
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function resolveProjectBinaryEntryPoint(projectRoot, packageName, binaryName) {
-  const pkgJsonPath = (0, import_node_path.join)(projectRoot, "node_modules", packageName, "package.json");
-  try {
-    const content = await (0, import_promises.readFile)(pkgJsonPath, "utf-8");
-    const pkg = JSON.parse(content);
-    let binPath;
-    if (typeof pkg.bin === "string") {
-      binPath = pkg.bin;
-    } else if (typeof pkg.bin === "object" && pkg.bin !== null) {
-      binPath = pkg.bin[binaryName];
-    }
-    if (!binPath) return null;
-    const fullPath = (0, import_node_path.join)(projectRoot, "node_modules", packageName, binPath);
-    await (0, import_promises.access)(fullPath);
-    return fullPath;
-  } catch {
-    return null;
-  }
-}
-function isKoraProject(pkg) {
-  if (typeof pkg !== "object" || pkg === null) return false;
-  const record = pkg;
-  return hasKoraDep(record.dependencies) || hasKoraDep(record.devDependencies);
-}
-function hasKoraDep(deps) {
-  if (typeof deps !== "object" || deps === null) return false;
-  return Object.keys(deps).some((key) => key === "kora" || key.startsWith("@korajs/"));
-}
-
-// src/utils/logger.ts
-var RESET = "\x1B[0m";
-var BOLD = "\x1B[1m";
-var DIM = "\x1B[2m";
-var GREEN = "\x1B[32m";
-var YELLOW = "\x1B[33m";
-var RED = "\x1B[31m";
-var CYAN = "\x1B[36m";
-function createLogger(options) {
-  const colorDisabled = options?.noColor === true || process.env.NO_COLOR !== void 0 || !process.stdout.isTTY;
-  function color(code, text) {
-    return colorDisabled ? text : `${code}${text}${RESET}`;
-  }
-  return {
-    info(message) {
-      console.log(color(CYAN, message));
-    },
-    success(message) {
-      console.log(color(GREEN, `  \u2713 ${message}`));
-    },
-    warn(message) {
-      console.warn(color(YELLOW, `  \u26A0 ${message}`));
-    },
-    error(message) {
-      console.error(color(RED, `  \u2717 ${message}`));
-    },
-    step(message) {
-      console.log(color(DIM, `  ${message}`));
-    },
-    blank() {
-      console.log();
-    },
-    banner() {
-      console.log();
-      console.log(
-        color(BOLD + CYAN, "  Kora.js") + color(DIM, " \u2014 Offline-first application framework")
-      );
-      console.log();
-    }
-  };
-}
-
 // src/utils/package-manager.ts
-var import_node_child_process = require("child_process");
+var import_node_child_process3 = require("child_process");
 function detectPackageManager() {
   const userAgent = process.env.npm_config_user_agent;
   if (!userAgent) return "npm";
@@ -443,8 +852,8 @@ function getRunDevCommand(pm) {
 }
 
 // src/commands/create/environment-detection.ts
-var import_promises2 = require("fs/promises");
-var import_node_path2 = require("path");
+var import_promises4 = require("fs/promises");
+var import_node_path6 = require("path");
 function detectEditorFromEnvironment(env = process.env) {
   const termProgram = String(env.TERM_PROGRAM ?? "").toLowerCase();
   const editorValue = `${String(env.EDITOR ?? "")} ${String(env.VISUAL ?? "")}`.toLowerCase();
@@ -470,18 +879,18 @@ async function detectGitContext(startDir) {
   };
 }
 async function detectMonorepoContext(startDir) {
-  let current = (0, import_node_path2.resolve)(startDir);
+  let current = (0, import_node_path6.resolve)(startDir);
   for (; ; ) {
-    if (await fileExists((0, import_node_path2.join)(current, "pnpm-workspace.yaml"))) {
+    if (await fileExists((0, import_node_path6.join)(current, "pnpm-workspace.yaml"))) {
       return { isMonorepo: true, root: current, kind: "pnpm-workspace" };
     }
-    if (await fileExists((0, import_node_path2.join)(current, "turbo.json"))) {
+    if (await fileExists((0, import_node_path6.join)(current, "turbo.json"))) {
       return { isMonorepo: true, root: current, kind: "turborepo" };
     }
-    const packageJsonPath = (0, import_node_path2.join)(current, "package.json");
+    const packageJsonPath = (0, import_node_path6.join)(current, "package.json");
     if (await fileExists(packageJsonPath)) {
       try {
-        const packageJsonRaw = await (0, import_promises2.readFile)(packageJsonPath, "utf-8");
+        const packageJsonRaw = await (0, import_promises4.readFile)(packageJsonPath, "utf-8");
         const parsed = JSON.parse(packageJsonRaw);
         if (Array.isArray(parsed.workspaces) || isNpmWorkspaceObject(parsed.workspaces)) {
           return { isMonorepo: true, root: current, kind: "npm-workspaces" };
@@ -489,7 +898,7 @@ async function detectMonorepoContext(startDir) {
       } catch {
       }
     }
-    const parent = (0, import_node_path2.dirname)(current);
+    const parent = (0, import_node_path6.dirname)(current);
     if (parent === current) {
       return { isMonorepo: false, root: null, kind: "none" };
     }
@@ -501,9 +910,9 @@ async function applyEditorWorkspacePreset(params) {
   if (editor !== "vscode" && editor !== "cursor" && editor !== "windsurf") {
     return { applied: false, filePath: null };
   }
-  const vscodeDir = (0, import_node_path2.join)(targetDir, ".vscode");
-  const extensionsPath = (0, import_node_path2.join)(vscodeDir, "extensions.json");
-  await (0, import_promises2.mkdir)(vscodeDir, { recursive: true });
+  const vscodeDir = (0, import_node_path6.join)(targetDir, ".vscode");
+  const extensionsPath = (0, import_node_path6.join)(vscodeDir, "extensions.json");
+  await (0, import_promises4.mkdir)(vscodeDir, { recursive: true });
   const recommendations = ["korajs.kora-devtools"];
   const existing = await readJsonObject(extensionsPath);
   const existingRecommendations = Array.isArray(existing?.recommendations) ? existing.recommendations.filter((item) => typeof item === "string") : [];
@@ -511,19 +920,19 @@ async function applyEditorWorkspacePreset(params) {
   const next = {
     recommendations: mergedRecommendations
   };
-  await (0, import_promises2.writeFile)(extensionsPath, `${JSON.stringify(next, null, 2)}
+  await (0, import_promises4.writeFile)(extensionsPath, `${JSON.stringify(next, null, 2)}
 `, "utf-8");
   return { applied: true, filePath: extensionsPath };
 }
 function resolveMonorepoTargetDirectory(monorepoRoot, projectName) {
-  return (0, import_node_path2.join)(monorepoRoot, "packages", projectName);
+  return (0, import_node_path6.join)(monorepoRoot, "packages", projectName);
 }
 function dedupeStrings(values) {
   return Array.from(new Set(values));
 }
 async function readJsonObject(path) {
   try {
-    const content = await (0, import_promises2.readFile)(path, "utf-8");
+    const content = await (0, import_promises4.readFile)(path, "utf-8");
     const parsed = JSON.parse(content);
     if (typeof parsed === "object" && parsed !== null) {
       return parsed;
@@ -540,22 +949,22 @@ function isNpmWorkspaceObject(value) {
 }
 async function fileExists(path) {
   try {
-    await (0, import_promises2.access)(path);
+    await (0, import_promises4.access)(path);
     return true;
   } catch {
     return false;
   }
 }
 async function findNearestAncestorWithEntry(startDir, entryName) {
-  let current = (0, import_node_path2.resolve)(startDir);
+  let current = (0, import_node_path6.resolve)(startDir);
   for (; ; ) {
-    const candidate = (0, import_node_path2.join)(current, entryName);
+    const candidate = (0, import_node_path6.join)(current, entryName);
     try {
-      await (0, import_promises2.stat)(candidate);
+      await (0, import_promises4.stat)(candidate);
       return current;
     } catch {
     }
-    const parent = (0, import_node_path2.dirname)(current);
+    const parent = (0, import_node_path6.dirname)(current);
     if (parent === current) {
       return null;
     }
@@ -626,10 +1035,49 @@ async function resolveCreatePreferencesFlow(params) {
   if (isTauri) {
     effective.framework = "react";
     effective.tailwind = false;
-    effective.sync = true;
-    effective.db = "sqlite";
-    effective.dbProvider = "none";
     effective.auth = "none";
+    if (flags.sync !== void 0) {
+      effective.sync = flags.sync;
+    } else if (!flags.useDefaults && !usedStoredPreferences) {
+      effective.sync = await prompts.confirm("Enable multi-device sync?", true);
+    }
+    if (flags.db !== void 0) {
+      if (!isDatabaseValue(flags.db)) {
+        throw new Error(
+          `Invalid --db value "${flags.db}". Expected one of: none, sqlite, postgres.`
+        );
+      }
+      effective.db = flags.db;
+    } else if (!effective.sync) {
+      effective.db = "none";
+    } else if (!flags.useDefaults && !usedStoredPreferences) {
+      effective.db = await prompts.select("Sync server database:", [
+        { label: "SQLite (zero-config; local, LAN, small teams)", value: "sqlite" },
+        { label: "PostgreSQL (production-scale)", value: "postgres" }
+      ]);
+    }
+    if (effective.db === "none") {
+      effective.sync = false;
+    }
+    if (effective.db !== "postgres") {
+      effective.dbProvider = "none";
+    } else if (flags.dbProvider !== void 0) {
+      if (!isDatabaseProviderValue(flags.dbProvider)) {
+        throw new Error(
+          `Invalid --db-provider value "${flags.dbProvider}". Expected one of: none, local, supabase, neon, railway, vercel-postgres, custom.`
+        );
+      }
+      effective.dbProvider = flags.dbProvider;
+    } else if (!flags.useDefaults && !usedStoredPreferences) {
+      effective.dbProvider = await prompts.select("Database provider:", [
+        { label: "Local Postgres", value: "local" },
+        { label: "Supabase", value: "supabase" },
+        { label: "Neon", value: "neon" },
+        { label: "Railway", value: "railway" },
+        { label: "Vercel Postgres", value: "vercel-postgres" },
+        { label: "Custom connection string", value: "custom" }
+      ]);
+    }
   } else {
     if (flags.framework !== void 0) {
       if (!isFrameworkValue(flags.framework)) {
@@ -778,8 +1226,8 @@ function validateProjectName(name) {
 }
 
 // src/commands/create/sync-provider-preset.ts
-var import_promises3 = require("fs/promises");
-var import_node_path3 = require("path");
+var import_promises5 = require("fs/promises");
+var import_node_path7 = require("path");
 async function applySyncProviderPreset(options) {
   if (!isSyncTemplate(options.template)) {
     return;
@@ -789,64 +1237,32 @@ async function applySyncProviderPreset(options) {
   }
   const providerName = getProviderDisplayName(options.dbProvider);
   const providerConnectionString = getProviderConnectionStringExample(options.dbProvider);
-  const serverPath = (0, import_node_path3.join)(options.targetDir, "server.ts");
-  const envPath = (0, import_node_path3.join)(options.targetDir, ".env.example");
-  const readmePath = (0, import_node_path3.join)(options.targetDir, "README.md");
-  const serverTemplate = [
-    "import { createPostgresServerStore, createProductionServer } from '@korajs/server'",
-    "",
-    `// PostgreSQL provider preset: ${providerName}`,
-    "// Ensure DATABASE_URL is set in your environment.",
-    "",
-    "async function start(): Promise<void> {",
-    "	const connectionString = process.env.DATABASE_URL || ''",
-    "	if (connectionString.length === 0) {",
-    "		throw new Error('DATABASE_URL is required for PostgreSQL sync server store.')",
-    "	}",
-    "",
-    "	const store = await createPostgresServerStore({ connectionString })",
-    "	const server = createProductionServer({",
-    "		store,",
-    "		port: Number(process.env.PORT) || 3001,",
-    "		staticDir: './dist',",
-    "		syncPath: '/kora-sync',",
-    "	})",
-    "",
-    "	const url = await server.start()",
-    "	console.log(`Kora app running at ${url}`)",
-    "}",
-    "",
-    "void start()",
-    ""
-  ].join("\n");
-  const envTemplate = [
-    "# Kora Sync Server",
-    "# WebSocket URL for the sync server (used by the client)",
-    "VITE_SYNC_URL=ws://localhost:3001",
-    "",
-    "# Sync server port",
-    "PORT=3001",
+  const envPath = (0, import_node_path7.join)(options.targetDir, ".env.example");
+  const readmePath = (0, import_node_path7.join)(options.targetDir, "README.md");
+  const existingReadme = await (0, import_promises5.readFile)(readmePath, "utf-8");
+  const existingEnv = await (0, import_promises5.readFile)(envPath, "utf-8");
+  const trimmedReadme = existingReadme.trimEnd();
+  const trimmedEnv = existingEnv.trimEnd();
+  const envSuffix = [
     "",
-    `# PostgreSQL connection string (${providerName})`,
-    `# Example: ${providerConnectionString}`,
-    "DATABASE_URL=",
-    ""
+    `# PostgreSQL provider preset: ${providerName}`,
+    `# Example: ${providerConnectionString}`
   ].join("\n");
-  const existingReadme = await (0, import_promises3.readFile)(readmePath, "utf-8");
-  const trimmedReadme = existingReadme.trimEnd();
   const readmeSuffix = [
     "",
     "## PostgreSQL Provider Preset",
     "",
     `Selected DB provider: ${options.dbProvider}`,
     "",
-    "This scaffold uses `createPostgresServerStore` in `server.ts` and reads `DATABASE_URL` from the environment. See `.env.example` for provider-specific examples.",
+    "This scaffold keeps one sync server entrypoint. When `DATABASE_URL` is set, `server.ts` uses PostgreSQL. When it is empty, the same server uses SQLite at `KORA_SERVER_DB`.",
+    "",
+    "The generated server uses `createPostgresServerStore` automatically when `DATABASE_URL` is present.",
     ""
   ].join("\n");
   const readmeTemplate = `${trimmedReadme}${readmeSuffix}`;
-  await (0, import_promises3.writeFile)(serverPath, serverTemplate, "utf-8");
-  await (0, import_promises3.writeFile)(envPath, envTemplate, "utf-8");
-  await (0, import_promises3.writeFile)(readmePath, readmeTemplate, "utf-8");
+  await (0, import_promises5.writeFile)(envPath, `${trimmedEnv}${envSuffix}
+`, "utf-8");
+  await (0, import_promises5.writeFile)(readmePath, readmeTemplate, "utf-8");
 }
 function isSyncTemplate(template) {
   return template === "react-sync" || template === "react-tailwind-sync" || template === "tauri-react";
@@ -890,9 +1306,9 @@ function getProviderConnectionStringExample(provider) {
 
 // src/templates/composer.ts
 var import_node_fs = require("fs");
-var import_promises4 = require("fs/promises");
-var import_node_path4 = require("path");
-var import_node_url = require("url");
+var import_promises6 = require("fs/promises");
+var import_node_path8 = require("path");
+var import_node_url3 = require("url");
 var import_meta = {};
 function substituteVariables(template, context) {
   return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
@@ -901,16 +1317,16 @@ function substituteVariables(template, context) {
   });
 }
 function getTemplatePath(templateName) {
-  let dir = (0, import_node_path4.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+  let dir = (0, import_node_path8.dirname)((0, import_node_url3.fileURLToPath)(import_meta.url));
   for (let i = 0; i < 7; i++) {
-    const candidate = (0, import_node_path4.resolve)(dir, "templates", templateName);
+    const candidate = (0, import_node_path8.resolve)(dir, "templates", templateName);
     if ((0, import_node_fs.existsSync)(candidate)) {
       return candidate;
     }
-    dir = (0, import_node_path4.dirname)(dir);
+    dir = (0, import_node_path8.dirname)(dir);
   }
-  const currentDir = (0, import_node_path4.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
-  return (0, import_node_path4.resolve)(currentDir, "..", "..", "..", "templates", templateName);
+  const currentDir = (0, import_node_path8.dirname)((0, import_node_url3.fileURLToPath)(import_meta.url));
+  return (0, import_node_path8.resolve)(currentDir, "..", "..", "..", "templates", templateName);
 }
 function createCompatibilityLayerPlan(templateName) {
   const baseLayer = { category: "base", name: "base", sourceTemplate: "react-basic" };
@@ -995,22 +1411,22 @@ async function composeTemplateLayers(plan, targetDir, context) {
   }
 }
 async function copyDirectory(src, dest, vars) {
-  await (0, import_promises4.mkdir)(dest, { recursive: true });
-  const entries = await (0, import_promises4.readdir)(src);
+  await (0, import_promises6.mkdir)(dest, { recursive: true });
+  const entries = await (0, import_promises6.readdir)(src);
   for (const entry of entries) {
-    const srcPath = (0, import_node_path4.join)(src, entry);
-    const srcStat = await (0, import_promises4.stat)(srcPath);
+    const srcPath = (0, import_node_path8.join)(src, entry);
+    const srcStat = await (0, import_promises6.stat)(srcPath);
     if (srcStat.isDirectory()) {
-      await copyDirectory(srcPath, (0, import_node_path4.join)(dest, entry), vars);
+      await copyDirectory(srcPath, (0, import_node_path8.join)(dest, entry), vars);
       continue;
     }
     if (entry.endsWith(".hbs")) {
-      const content = await (0, import_promises4.readFile)(srcPath, "utf-8");
+      const content = await (0, import_promises6.readFile)(srcPath, "utf-8");
       const outputName = entry.slice(0, -4);
-      await (0, import_promises4.writeFile)((0, import_node_path4.join)(dest, outputName), substituteVariables(content, vars), "utf-8");
+      await (0, import_promises6.writeFile)((0, import_node_path8.join)(dest, outputName), substituteVariables(content, vars), "utf-8");
       continue;
     }
-    await (0, import_promises4.copyFile)(srcPath, (0, import_node_path4.join)(dest, entry));
+    await (0, import_promises6.copyFile)(srcPath, (0, import_node_path8.join)(dest, entry));
   }
 }
 
@@ -1022,7 +1438,7 @@ async function scaffoldTemplate(templateName, targetDir, context) {
 
 // src/commands/create/create-command.ts
 var import_meta2 = {};
-var createCommand = (0, import_citty.defineCommand)({
+var createCommand = (0, import_citty3.defineCommand)({
   meta: {
     name: "create",
     description: "Create a new Kora application"
@@ -1161,7 +1577,7 @@ var createCommand = (0, import_citty.defineCommand)({
       const editorDetection = detectEditorFromEnvironment();
       const gitContext = await detectGitContext(process.cwd());
       const monorepoContext = await detectMonorepoContext(process.cwd());
-      let targetDir = (0, import_node_path5.resolve)(process.cwd(), projectName);
+      let targetDir = (0, import_node_path9.resolve)(process.cwd(), projectName);
       if (!useDefaults && monorepoContext.isMonorepo && monorepoContext.root !== null) {
         const useWorkspaceTarget = await prompts.confirm(
           `Detected ${formatMonorepoKind(monorepoContext.kind)} at ${monorepoContext.root}. Create app under packages/${projectName}?`,
@@ -1231,7 +1647,7 @@ var createCommand = (0, import_citty.defineCommand)({
       if (!args["skip-install"]) {
         logger.step("Installing dependencies...");
         try {
-          (0, import_node_child_process2.execSync)(getInstallCommand(pm), { cwd: targetDir, stdio: "inherit" });
+          (0, import_node_child_process4.execSync)(getInstallCommand(pm), { cwd: targetDir, stdio: "inherit" });
           logger.success("Dependencies installed");
         } catch {
           logger.warn("Failed to install dependencies. Run install manually.");
@@ -1331,9 +1747,9 @@ function relativeToTarget(targetDir, filePath) {
 }
 function resolveKoraVersion() {
   try {
-    let dir = (0, import_node_path5.dirname)((0, import_node_url2.fileURLToPath)(import_meta2.url));
+    let dir = (0, import_node_path9.dirname)((0, import_node_url4.fileURLToPath)(import_meta2.url));
     for (let i = 0; i < 5; i++) {
-      const pkgPath = (0, import_node_path5.resolve)(dir, "package.json");
+      const pkgPath = (0, import_node_path9.resolve)(dir, "package.json");
       if ((0, import_node_fs2.existsSync)(pkgPath)) {
         const pkg = JSON.parse((0, import_node_fs2.readFileSync)(pkgPath, "utf-8"));
         if (pkg.name === "@korajs/cli") {
@@ -1342,7 +1758,7 @@ function resolveKoraVersion() {
           return `^${parts[0]}.${parts[1]}.0`;
         }
       }
-      dir = (0, import_node_path5.dirname)(dir);
+      dir = (0, import_node_path9.dirname)(dir);
     }
     return "latest";
   } catch {
@@ -1351,8 +1767,9 @@ function resolveKoraVersion() {
 }
 
 // src/commands/deploy/deploy-command.ts
-var import_node_path16 = require("path");
-var import_citty2 = require("citty");
+var import_node_fs4 = require("fs");
+var import_node_path20 = require("path");
+var import_citty4 = require("citty");
 
 // src/commands/deploy/adapters/adapter.ts
 var DEPLOY_PLATFORMS = [
@@ -1369,14 +1786,14 @@ function isDeployPlatform(value) {
 }
 
 // src/commands/deploy/adapters/aws-ecs-adapter.ts
-var import_node_child_process4 = require("child_process");
-var import_node_path8 = require("path");
+var import_node_child_process6 = require("child_process");
+var import_node_path12 = require("path");
 
 // src/commands/deploy/builder/client-builder.ts
-var import_node_child_process3 = require("child_process");
+var import_node_child_process5 = require("child_process");
 var import_node_fs3 = require("fs");
-var import_promises5 = require("fs/promises");
-var import_node_path6 = require("path");
+var import_promises7 = require("fs/promises");
+var import_node_path10 = require("path");
 async function buildClient(options) {
   const viteEntryPoint = await resolveProjectBinaryEntryPoint(options.projectRoot, "vite", "vite");
   if (!viteEntryPoint) {
@@ -1397,15 +1814,15 @@ async function buildClient(options) {
   return { outDir: options.outDir };
 }
 async function patchSqliteWasmAssets(projectRoot, outDir) {
-  const assetsDir = (0, import_node_path6.join)(outDir, "assets");
+  const assetsDir = (0, import_node_path10.join)(outDir, "assets");
   if (!(0, import_node_fs3.existsSync)(assetsDir)) return;
-  const files = await (0, import_promises5.readdir)(assetsDir);
+  const files = await (0, import_promises7.readdir)(assetsDir);
   const hashedWasm = files.find((f) => /^sqlite3-.+\.wasm$/.test(f));
   if (hashedWasm && !files.includes("sqlite3.wasm")) {
-    await (0, import_promises5.copyFile)((0, import_node_path6.join)(assetsDir, hashedWasm), (0, import_node_path6.join)(assetsDir, "sqlite3.wasm"));
+    await (0, import_promises7.copyFile)((0, import_node_path10.join)(assetsDir, hashedWasm), (0, import_node_path10.join)(assetsDir, "sqlite3.wasm"));
   }
   if (!files.includes("sqlite3-opfs-async-proxy.js")) {
-    const proxyFile = (0, import_node_path6.resolve)(
+    const proxyFile = (0, import_node_path10.resolve)(
       projectRoot,
       "node_modules",
       "@sqlite.org",
@@ -1415,13 +1832,13 @@ async function patchSqliteWasmAssets(projectRoot, outDir) {
       "sqlite3-opfs-async-proxy.js"
     );
     if ((0, import_node_fs3.existsSync)(proxyFile)) {
-      await (0, import_promises5.copyFile)(proxyFile, (0, import_node_path6.join)(assetsDir, "sqlite3-opfs-async-proxy.js"));
+      await (0, import_promises7.copyFile)(proxyFile, (0, import_node_path10.join)(assetsDir, "sqlite3-opfs-async-proxy.js"));
     }
   }
 }
 async function runProcess(command, args, cwd) {
-  await new Promise((resolve9, reject) => {
-    const child = (0, import_node_child_process3.spawn)(command, args, {
+  await new Promise((resolve11, reject) => {
+    const child = (0, import_node_child_process5.spawn)(command, args, {
       cwd,
       stdio: "inherit",
       env: process.env
@@ -1431,7 +1848,7 @@ async function runProcess(command, args, cwd) {
     });
     child.on("exit", (code) => {
       if (code === 0) {
-        resolve9();
+        resolve11();
         return;
       }
       reject(new Error(`Client build failed with exit code ${String(code ?? "unknown")}.`));
@@ -1440,9 +1857,9 @@ async function runProcess(command, args, cwd) {
 }
 
 // src/commands/deploy/builder/server-bundler.ts
-var import_promises6 = require("fs/promises");
-var import_promises7 = require("fs/promises");
-var import_node_path7 = require("path");
+var import_promises8 = require("fs/promises");
+var import_promises9 = require("fs/promises");
+var import_node_path11 = require("path");
 var import_esbuild = require("esbuild");
 var DEFAULT_ENTRY_CANDIDATES = [
   "server.ts",
@@ -1458,8 +1875,8 @@ async function bundleServer(options) {
       `Could not find a server entry file in ${options.projectRoot}. Looked for: ${candidates.join(", ")}`
     );
   }
-  await (0, import_promises6.mkdir)(options.deployDirectory, { recursive: true });
-  const outputFilePath = (0, import_node_path7.join)(options.deployDirectory, "server-bundled.js");
+  await (0, import_promises8.mkdir)(options.deployDirectory, { recursive: true });
+  const outputFilePath = (0, import_node_path11.join)(options.deployDirectory, "server-bundled.js");
   await (0, import_esbuild.build)({
     entryPoints: [entryFilePath],
     outfile: outputFilePath,
@@ -1481,9 +1898,9 @@ async function bundleServer(options) {
 }
 async function resolveServerEntry(projectRoot, candidates) {
   for (const candidate of candidates) {
-    const fullPath = (0, import_node_path7.join)(projectRoot, candidate);
+    const fullPath = (0, import_node_path11.join)(projectRoot, candidate);
     try {
-      await (0, import_promises7.access)(fullPath);
+      await (0, import_promises9.access)(fullPath);
       return fullPath;
     } catch {
     }
@@ -1585,19 +2002,19 @@ var AwsEcsAdapter = class {
       appName: config.appName,
       region: config.region
     };
-    const deployDirectory = (0, import_node_path8.join)(config.projectRoot, ".kora", "deploy");
+    const deployDirectory = (0, import_node_path12.join)(config.projectRoot, ".kora", "deploy");
     await bundleServer({
       projectRoot: config.projectRoot,
       deployDirectory
     });
-    const client = await buildClient({
+    const client = config.deployTarget === "sync-server" ? null : await buildClient({
       projectRoot: config.projectRoot,
-      outDir: (0, import_node_path8.join)(deployDirectory, "dist"),
+      outDir: (0, import_node_path12.join)(deployDirectory, "dist"),
       mode: "production"
     });
     return {
-      clientDirectory: client.outDir,
-      serverBundlePath: (0, import_node_path8.join)(deployDirectory, "server-bundled.js"),
+      clientDirectory: client?.outDir ?? null,
+      serverBundlePath: (0, import_node_path12.join)(deployDirectory, "server-bundled.js"),
       deployDirectory
     };
   }
@@ -1829,8 +2246,8 @@ var AwsEcsAdapter = class {
 };
 var NodeAwsCommandRunner = class {
   async run(command, args, cwd) {
-    return new Promise((resolve9) => {
-      const child = (0, import_node_child_process4.spawn)(command, args, {
+    return new Promise((resolve11) => {
+      const child = (0, import_node_child_process6.spawn)(command, args, {
         cwd,
         env: process.env,
         stdio: ["ignore", "pipe", "pipe"]
@@ -1844,11 +2261,11 @@ var NodeAwsCommandRunner = class {
         stderr += chunk.toString("utf-8");
       });
       child.on("error", (error) => {
-        resolve9({ exitCode: 1, stdout, stderr: `${stderr}
+        resolve11({ exitCode: 1, stdout, stderr: `${stderr}
 ${error.message}` });
       });
       child.on("exit", (code) => {
-        resolve9({ exitCode: code ?? 1, stdout: stdout.trim(), stderr: stderr.trim() });
+        resolve11({ exitCode: code ?? 1, stdout: stdout.trim(), stderr: stderr.trim() });
       });
     });
   }
@@ -1862,8 +2279,8 @@ function inferLogLevel(line) {
 }
 
 // src/commands/deploy/adapters/aws-lightsail-adapter.ts
-var import_node_child_process5 = require("child_process");
-var import_node_path9 = require("path");
+var import_node_child_process7 = require("child_process");
+var import_node_path13 = require("path");
 var AwsLightsailAdapter = class {
   name = "aws-lightsail";
   logger = createLogger();
@@ -1936,19 +2353,19 @@ var AwsLightsailAdapter = class {
       appName: config.appName,
       region: config.region
     };
-    const deployDirectory = (0, import_node_path9.join)(config.projectRoot, ".kora", "deploy");
+    const deployDirectory = (0, import_node_path13.join)(config.projectRoot, ".kora", "deploy");
     await bundleServer({
       projectRoot: config.projectRoot,
       deployDirectory
     });
-    const client = await buildClient({
+    const client = config.deployTarget === "sync-server" ? null : await buildClient({
       projectRoot: config.projectRoot,
-      outDir: (0, import_node_path9.join)(deployDirectory, "dist"),
+      outDir: (0, import_node_path13.join)(deployDirectory, "dist"),
       mode: "production"
     });
     return {
-      clientDirectory: client.outDir,
-      serverBundlePath: (0, import_node_path9.join)(deployDirectory, "server-bundled.js"),
+      clientDirectory: client?.outDir ?? null,
+      serverBundlePath: (0, import_node_path13.join)(deployDirectory, "server-bundled.js"),
       deployDirectory
     };
   }
@@ -2176,8 +2593,8 @@ var AwsLightsailAdapter = class {
 };
 var NodeAwsLightsailCommandRunner = class {
   async run(command, args, cwd) {
-    return new Promise((resolve9) => {
-      const child = (0, import_node_child_process5.spawn)(command, args, {
+    return new Promise((resolve11) => {
+      const child = (0, import_node_child_process7.spawn)(command, args, {
         cwd,
         env: process.env,
         stdio: ["ignore", "pipe", "pipe"]
@@ -2191,11 +2608,11 @@ var NodeAwsLightsailCommandRunner = class {
         stderr += chunk.toString("utf-8");
       });
       child.on("error", (error) => {
-        resolve9({ exitCode: 1, stdout, stderr: `${stderr}
+        resolve11({ exitCode: 1, stdout, stderr: `${stderr}
 ${error.message}` });
       });
       child.on("exit", (code) => {
-        resolve9({ exitCode: code ?? 1, stdout: stdout.trim(), stderr: stderr.trim() });
+        resolve11({ exitCode: code ?? 1, stdout: stdout.trim(), stderr: stderr.trim() });
       });
     });
   }
@@ -2247,12 +2664,12 @@ function inferLogLevel2(line) {
 }
 
 // src/commands/deploy/adapters/fly-adapter.ts
-var import_node_child_process6 = require("child_process");
-var import_node_path11 = require("path");
+var import_node_child_process8 = require("child_process");
+var import_node_path15 = require("path");
 
 // src/commands/deploy/artifacts/fly-toml-generator.ts
-var import_promises8 = require("fs/promises");
-var import_node_path10 = require("path");
+var import_promises10 = require("fs/promises");
+var import_node_path14 = require("path");
 var GENERATED_HEADER = "# Generated by kora deploy \u2014 do not edit manually";
 function generateFlyToml(options) {
   const internalPort = options.internalPort ?? 3e3;
@@ -2277,14 +2694,14 @@ function generateFlyToml(options) {
     '    interval = "30s"',
     '    method = "GET"',
     '    timeout = "5s"',
-    '    path = "/"',
+    '    path = "/health"',
     ""
   ].join("\n");
 }
 async function writeFlyTomlArtifact(deployDirectory, options) {
-  await (0, import_promises8.mkdir)(deployDirectory, { recursive: true });
-  const filePath = (0, import_node_path10.join)(deployDirectory, "fly.toml");
-  await (0, import_promises8.writeFile)(filePath, generateFlyToml(options), "utf-8");
+  await (0, import_promises10.mkdir)(deployDirectory, { recursive: true });
+  const filePath = (0, import_node_path14.join)(deployDirectory, "fly.toml");
+  await (0, import_promises10.writeFile)(filePath, generateFlyToml(options), "utf-8");
   return filePath;
 }
 
@@ -2378,7 +2795,7 @@ var FlyAdapter = class {
       appName: config.appName,
       region: config.region
     };
-    const deployDirectory = (0, import_node_path11.join)(config.projectRoot, ".kora", "deploy");
+    const deployDirectory = (0, import_node_path15.join)(config.projectRoot, ".kora", "deploy");
     await writeFlyTomlArtifact(deployDirectory, {
       appName: config.appName,
       region: config.region ?? "iad"
@@ -2387,14 +2804,14 @@ var FlyAdapter = class {
       projectRoot: config.projectRoot,
       deployDirectory
     });
-    const client = await buildClient({
+    const client = config.deployTarget === "sync-server" ? null : await buildClient({
       projectRoot: config.projectRoot,
-      outDir: (0, import_node_path11.join)(deployDirectory, "dist"),
+      outDir: (0, import_node_path15.join)(deployDirectory, "dist"),
       mode: "production"
     });
     return {
-      clientDirectory: client.outDir,
-      serverBundlePath: (0, import_node_path11.join)(deployDirectory, "server-bundled.js"),
+      clientDirectory: client?.outDir ?? null,
+      serverBundlePath: (0, import_node_path15.join)(deployDirectory, "server-bundled.js"),
       deployDirectory
     };
   }
@@ -2520,8 +2937,8 @@ var FlyAdapter = class {
 };
 var NodeFlyCommandRunner = class {
   async run(command, args, cwd) {
-    return await new Promise((resolve9) => {
-      const child = (0, import_node_child_process6.spawn)(command, args, {
+    return await new Promise((resolve11) => {
+      const child = (0, import_node_child_process8.spawn)(command, args, {
         cwd,
         env: process.env,
         stdio: ["ignore", "pipe", "pipe"]
@@ -2535,7 +2952,7 @@ var NodeFlyCommandRunner = class {
         stderr += chunk.toString("utf-8");
       });
       child.on("error", (error) => {
-        resolve9({
+        resolve11({
           exitCode: 1,
           stdout,
           stderr: `${stderr}
@@ -2543,7 +2960,7 @@ ${error.message}`
         });
       });
       child.on("exit", (code) => {
-        resolve9({
+        resolve11({
           exitCode: code ?? 1,
           stdout: stdout.trim(),
           stderr: stderr.trim()
@@ -2615,12 +3032,12 @@ ${stdout}`.toLowerCase();
 }
 
 // src/commands/deploy/adapters/railway-adapter.ts
-var import_node_child_process7 = require("child_process");
-var import_node_path13 = require("path");
+var import_node_child_process9 = require("child_process");
+var import_node_path17 = require("path");
 
 // src/commands/deploy/artifacts/railway-json-generator.ts
-var import_promises9 = require("fs/promises");
-var import_node_path12 = require("path");
+var import_promises11 = require("fs/promises");
+var import_node_path16 = require("path");
 var GENERATED_HEADER2 = "Generated by kora deploy - do not edit manually.";
 function generateRailwayJson(options) {
   const file = {
@@ -2645,9 +3062,9 @@ function generateRailwayJson(options) {
 `;
 }
 async function writeRailwayJsonArtifact(deployDirectory, options) {
-  await (0, import_promises9.mkdir)(deployDirectory, { recursive: true });
-  const filePath = (0, import_node_path12.join)(deployDirectory, "railway.json");
-  await (0, import_promises9.writeFile)(filePath, generateRailwayJson(options), "utf-8");
+  await (0, import_promises11.mkdir)(deployDirectory, { recursive: true });
+  const filePath = (0, import_node_path16.join)(deployDirectory, "railway.json");
+  await (0, import_promises11.writeFile)(filePath, generateRailwayJson(options), "utf-8");
   return filePath;
 }
 
@@ -2736,7 +3153,7 @@ var RailwayAdapter = class {
       appName: config.appName,
       region: config.region
     };
-    const deployDirectory = (0, import_node_path13.join)(config.projectRoot, ".kora", "deploy");
+    const deployDirectory = (0, import_node_path17.join)(config.projectRoot, ".kora", "deploy");
     await writeRailwayJsonArtifact(deployDirectory, {
       appName: config.appName,
       environment: config.environment
@@ -2745,14 +3162,14 @@ var RailwayAdapter = class {
       projectRoot: config.projectRoot,
       deployDirectory
     });
-    const client = await buildClient({
+    const client = config.deployTarget === "sync-server" ? null : await buildClient({
       projectRoot: config.projectRoot,
-      outDir: (0, import_node_path13.join)(deployDirectory, "dist"),
+      outDir: (0, import_node_path17.join)(deployDirectory, "dist"),
       mode: "production"
     });
     return {
-      clientDirectory: client.outDir,
-      serverBundlePath: (0, import_node_path13.join)(deployDirectory, "server-bundled.js"),
+      clientDirectory: client?.outDir ?? null,
+      serverBundlePath: (0, import_node_path17.join)(deployDirectory, "server-bundled.js"),
       deployDirectory
     };
   }
@@ -2856,8 +3273,8 @@ var RailwayAdapter = class {
 };
 var NodeRailwayCommandRunner = class {
   async run(command, args, cwd) {
-    return await new Promise((resolve9) => {
-      const child = (0, import_node_child_process7.spawn)(command, args, {
+    return await new Promise((resolve11) => {
+      const child = (0, import_node_child_process9.spawn)(command, args, {
         cwd,
         env: process.env,
         stdio: ["ignore", "pipe", "pipe"]
@@ -2871,7 +3288,7 @@ var NodeRailwayCommandRunner = class {
         stderr += chunk.toString("utf-8");
       });
       child.on("error", (error) => {
-        resolve9({
+        resolve11({
           exitCode: 1,
           stdout,
           stderr: `${stderr}
@@ -2879,7 +3296,7 @@ ${error.message}`
         });
       });
       child.on("exit", (code) => {
-        resolve9({
+        resolve11({
           exitCode: code ?? 1,
           stdout: stdout.trim(),
           stderr: stderr.trim()
@@ -3037,13 +3454,13 @@ function createDeployAdapter(platform) {
 }
 
 // src/commands/deploy/artifacts/dockerfile-generator.ts
-var import_promises10 = require("fs/promises");
-var import_node_path14 = require("path");
+var import_promises12 = require("fs/promises");
+var import_node_path18 = require("path");
 var GENERATED_HEADER3 = "# Generated by kora deploy \u2014 do not edit manually";
 function generateDockerfile(options = {}) {
   const nodeVersion = options.nodeVersion ?? "20-alpine";
   const port = options.port ?? 3e3;
-  const clientDirectory = options.clientDirectory ?? "dist";
+  const clientDirectory = options.clientDirectory === void 0 ? "dist" : options.clientDirectory;
   const serverBundleFile = options.serverBundleFile ?? "server-bundled.js";
   const hasNativeDeps = options.nativeDependencies && Object.keys(options.nativeDependencies).length > 0;
   const lines = [
@@ -3063,7 +3480,9 @@ function generateDockerfile(options = {}) {
     lines.push("RUN npm install --omit=dev");
     lines.push("");
   }
-  lines.push(`COPY ${clientDirectory} ./dist`);
+  if (clientDirectory !== null) {
+    lines.push(`COPY ${clientDirectory} ./dist`);
+  }
   lines.push(`COPY ${serverBundleFile} ./server-bundled.js`);
   lines.push("");
   lines.push(`EXPOSE ${String(port)}`);
@@ -3102,37 +3521,37 @@ function generateDockerIgnore() {
   ].join("\n");
 }
 async function writeDockerfileArtifact(deployDirectory, options = {}) {
-  await (0, import_promises10.mkdir)(deployDirectory, { recursive: true });
-  const dockerfilePath = (0, import_node_path14.join)(deployDirectory, "Dockerfile");
-  await (0, import_promises10.writeFile)(dockerfilePath, generateDockerfile(options), "utf-8");
+  await (0, import_promises12.mkdir)(deployDirectory, { recursive: true });
+  const dockerfilePath = (0, import_node_path18.join)(deployDirectory, "Dockerfile");
+  await (0, import_promises12.writeFile)(dockerfilePath, generateDockerfile(options), "utf-8");
   if (options.nativeDependencies && Object.keys(options.nativeDependencies).length > 0) {
-    const pkgJsonPath = (0, import_node_path14.join)(deployDirectory, "package.json");
-    await (0, import_promises10.writeFile)(pkgJsonPath, generateDeployPackageJson(options.nativeDependencies), "utf-8");
+    const pkgJsonPath = (0, import_node_path18.join)(deployDirectory, "package.json");
+    await (0, import_promises12.writeFile)(pkgJsonPath, generateDeployPackageJson(options.nativeDependencies), "utf-8");
   }
   return dockerfilePath;
 }
 async function writeDockerIgnoreArtifact(deployDirectory) {
-  await (0, import_promises10.mkdir)(deployDirectory, { recursive: true });
-  const dockerIgnorePath = (0, import_node_path14.join)(deployDirectory, ".dockerignore");
-  await (0, import_promises10.writeFile)(dockerIgnorePath, generateDockerIgnore(), "utf-8");
+  await (0, import_promises12.mkdir)(deployDirectory, { recursive: true });
+  const dockerIgnorePath = (0, import_node_path18.join)(deployDirectory, ".dockerignore");
+  await (0, import_promises12.writeFile)(dockerIgnorePath, generateDockerIgnore(), "utf-8");
   return dockerIgnorePath;
 }
 
 // src/commands/deploy/state/deploy-state.ts
-var import_promises11 = require("fs/promises");
-var import_node_path15 = require("path");
-var KORA_DEPLOY_DIRECTORY = (0, import_node_path15.join)(".kora", "deploy");
+var import_promises13 = require("fs/promises");
+var import_node_path19 = require("path");
+var KORA_DEPLOY_DIRECTORY = (0, import_node_path19.join)(".kora", "deploy");
 var DEPLOY_STATE_FILENAME = "deploy.json";
 function resolveDeployDirectory(projectRoot) {
-  return (0, import_node_path15.join)(projectRoot, KORA_DEPLOY_DIRECTORY);
+  return (0, import_node_path19.join)(projectRoot, KORA_DEPLOY_DIRECTORY);
 }
 function resolveDeployStatePath(projectRoot) {
-  return (0, import_node_path15.join)(resolveDeployDirectory(projectRoot), DEPLOY_STATE_FILENAME);
+  return (0, import_node_path19.join)(resolveDeployDirectory(projectRoot), DEPLOY_STATE_FILENAME);
 }
 async function readDeployState(projectRoot) {
   const statePath = resolveDeployStatePath(projectRoot);
   try {
-    const source = await (0, import_promises11.readFile)(statePath, "utf-8");
+    const source = await (0, import_promises13.readFile)(statePath, "utf-8");
     const parsed = JSON.parse(source);
     return parseDeployState(parsed);
   } catch (error) {
@@ -3179,13 +3598,13 @@ async function updateDeployState(projectRoot, patch, now = /* @__PURE__ */ new D
   return nextState;
 }
 async function resetDeployState(projectRoot) {
-  await (0, import_promises11.rm)(resolveDeployDirectory(projectRoot), { recursive: true, force: true });
+  await (0, import_promises13.rm)(resolveDeployDirectory(projectRoot), { recursive: true, force: true });
 }
 async function persistDeployState(projectRoot, state) {
   const deployDir = resolveDeployDirectory(projectRoot);
   const statePath = resolveDeployStatePath(projectRoot);
-  await (0, import_promises11.mkdir)(deployDir, { recursive: true });
-  await (0, import_promises11.writeFile)(statePath, `${JSON.stringify(state, null, 2)}
+  await (0, import_promises13.mkdir)(deployDir, { recursive: true });
+  await (0, import_promises13.writeFile)(statePath, `${JSON.stringify(state, null, 2)}
 `, "utf-8");
 }
 function parseDeployState(value) {
@@ -3235,7 +3654,7 @@ function readOptionalString(value, field) {
 }
 
 // src/commands/deploy/deploy-command.ts
-var deployCommand = (0, import_citty2.defineCommand)({
+var deployCommand = (0, import_citty4.defineCommand)({
   meta: {
     name: "deploy",
     description: "Deploy a Kora project to your selected platform"
@@ -3270,7 +3689,7 @@ var deployCommand = (0, import_citty2.defineCommand)({
     }
   },
   subCommands: {
-    status: (0, import_citty2.defineCommand)({
+    status: (0, import_citty4.defineCommand)({
       meta: {
         name: "status",
         description: "Show current deployment status"
@@ -3301,7 +3720,7 @@ var deployCommand = (0, import_citty2.defineCommand)({
         logger.step(`Sync URL: ${state.syncUrl ?? "n/a"}`);
       }
     }),
-    rollback: (0, import_citty2.defineCommand)({
+    rollback: (0, import_citty4.defineCommand)({
       meta: {
         name: "rollback",
         description: "Rollback the current deployment"
@@ -3332,7 +3751,7 @@ var deployCommand = (0, import_citty2.defineCommand)({
         logger.success(`Rolled back ${state.platform} deployment to ${deploymentId}.`);
       }
     }),
-    logs: (0, import_citty2.defineCommand)({
+    logs: (0, import_citty4.defineCommand)({
       meta: {
         name: "logs",
         description: "Read deployment logs"
@@ -3388,12 +3807,14 @@ var deployCommand = (0, import_citty2.defineCommand)({
     const region = resolveRegion(args.region, existingState?.region, confirmMode);
     const deployDirectory = resolveDeployDirectory(projectRoot);
     const environment = args.prod === true ? "production" : "preview";
+    const deployTarget = detectDeployTarget(projectRoot);
     const config = {
       projectRoot,
       appName,
       region,
       environment,
-      confirm: confirmMode
+      confirm: confirmMode,
+      deployTarget
     };
     const adapter = createDeployAdapter(platform);
     configureAdapterContext(adapter, {
@@ -3405,10 +3826,14 @@ var deployCommand = (0, import_citty2.defineCommand)({
     logger.info(
       `Deploying to ${platform} (${appName}${region ? `, ${region}` : ""}, ${environment})`
     );
+    if (deployTarget === "sync-server") {
+      logger.step("Detected Tauri project. Deploying the sync server only.");
+    }
     if (confirmMode) {
       logger.step("Running in --confirm mode (non-interactive, fail-fast).");
     }
     await writeDockerfileArtifact(deployDirectory, {
+      clientDirectory: deployTarget === "sync-server" ? null : void 0,
       nativeDependencies: {
         "better-sqlite3": "^11.0.0",
         "drizzle-orm": "^0.45.2",
@@ -3513,7 +3938,7 @@ function resolveAppName(argValue, storedValue, projectRoot, confirm) {
       "Missing app name in --confirm mode. Provide --app or run an interactive deploy first."
     );
   }
-  return sanitizeAppName((0, import_node_path16.basename)(projectRoot));
+  return sanitizeAppName((0, import_node_path20.basename)(projectRoot));
 }
 function resolveRegion(argValue, storedValue, confirm) {
   if (typeof argValue === "string" && argValue.length > 0) return argValue;
@@ -3547,109 +3972,21 @@ function configureAdapterContext(adapter, context) {
     adapter.setContext(context);
   }
 }
+function detectDeployTarget(projectRoot) {
+  return (0, import_node_fs4.existsSync)((0, import_node_path20.join)(projectRoot, "src-tauri")) ? "sync-server" : "full-stack";
+}
 function hasContextSetter(adapter) {
   return typeof adapter.setContext === "function";
 }
 
 // src/commands/dev/dev-command.ts
-var import_promises13 = require("fs/promises");
-var import_node_path19 = require("path");
-var import_node_path20 = require("path");
-var import_citty3 = require("citty");
-
-// src/commands/dev/kora-config.ts
-var import_node_child_process8 = require("child_process");
-var import_promises12 = require("fs/promises");
-var import_node_path17 = require("path");
-var import_node_url3 = require("url");
-var CONFIG_CANDIDATES = [
-  "kora.config.ts",
-  "kora.config.mts",
-  "kora.config.cts",
-  "kora.config.js",
-  "kora.config.mjs",
-  "kora.config.cjs"
-];
-async function loadKoraConfig(projectRoot) {
-  const configPath = await findKoraConfigFile(projectRoot);
-  if (!configPath) return null;
-  const ext = (0, import_node_path17.extname)(configPath);
-  if (ext === ".ts" || ext === ".mts" || ext === ".cts") {
-    const loaded2 = await loadTypeScriptConfig(configPath, projectRoot);
-    return toConfigObject(loaded2);
-  }
-  const loaded = await import((0, import_node_url3.pathToFileURL)(configPath).href);
-  return toConfigObject(loaded);
-}
-async function findKoraConfigFile(projectRoot) {
-  for (const file of CONFIG_CANDIDATES) {
-    const candidate = (0, import_node_path17.join)(projectRoot, file);
-    try {
-      await (0, import_promises12.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((resolve9, reject) => {
-    const child = (0, import_node_child_process8.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) {
-        resolve9(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;
-}
+var import_promises14 = require("fs/promises");
+var import_node_path22 = require("path");
+var import_node_path23 = require("path");
+var import_citty5 = require("citty");
 
 // src/commands/dev/process-manager.ts
-var import_node_child_process9 = require("child_process");
+var import_node_child_process10 = require("child_process");
 var ProcessManager = class {
   processes = /* @__PURE__ */ new Map();
   spawn(config) {
@@ -3658,12 +3995,12 @@ var ProcessManager = class {
       env: { ...process.env, ...config.env },
       stdio: ["ignore", "pipe", "pipe"]
     };
-    const child = (0, import_node_child_process9.spawn)(config.command, config.args, options);
+    const child = (0, import_node_child_process10.spawn)(config.command, config.args, options);
     let resolveExit;
     const runningProcess = {
       child,
-      exitPromise: new Promise((resolve9) => {
-        resolveExit = resolve9;
+      exitPromise: new Promise((resolve11) => {
+        resolveExit = resolve11;
       }),
       stdoutBuffer: "",
       stderrBuffer: ""
@@ -3730,15 +4067,15 @@ var ProcessManager = class {
   }
 };
 function delay(ms) {
-  return new Promise((resolve9) => {
-    setTimeout(resolve9, ms);
+  return new Promise((resolve11) => {
+    setTimeout(resolve11, ms);
   });
 }
 
 // src/commands/dev/schema-watcher.ts
-var import_node_child_process10 = require("child_process");
-var import_node_fs4 = require("fs");
-var import_node_path18 = require("path");
+var import_node_child_process11 = require("child_process");
+var import_node_fs5 = require("fs");
+var import_node_path21 = require("path");
 var SchemaWatcher = class {
   constructor(config) {
     this.config = config;
@@ -3750,7 +4087,7 @@ var SchemaWatcher = class {
   debounceTimer = null;
   start() {
     if (this.watcher) return;
-    this.watcher = (0, import_node_fs4.watch)(this.config.schemaPath, () => {
+    this.watcher = (0, import_node_fs5.watch)(this.config.schemaPath, () => {
       this.scheduleRegeneration();
     });
     this.watcher.on("error", (error) => {
@@ -3766,7 +4103,7 @@ var SchemaWatcher = class {
     this.watcher = null;
   }
   async regenerate() {
-    const koraBinJs = (0, import_node_path18.join)(
+    const koraBinJs = (0, import_node_path21.join)(
       this.config.projectRoot,
       "node_modules",
       "@korajs",
@@ -3793,8 +4130,8 @@ var SchemaWatcher = class {
   }
 };
 async function spawnCommand(command, args, cwd) {
-  await new Promise((resolve9, reject) => {
-    const child = (0, import_node_child_process10.spawn)(command, args, {
+  await new Promise((resolve11, reject) => {
+    const child = (0, import_node_child_process11.spawn)(command, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env
@@ -3810,7 +4147,7 @@ async function spawnCommand(command, args, cwd) {
     });
     child.on("exit", (code) => {
       if (code === 0) {
-        resolve9();
+        resolve11();
         return;
       }
       reject(new Error(`Type generation exited with code ${code ?? "unknown"}.`));
@@ -3832,7 +4169,7 @@ function toError(error) {
 }
 
 // src/commands/dev/dev-command.ts
-var devCommand = (0, import_citty3.defineCommand)({
+var devCommand = (0, import_citty5.defineCommand)({
   meta: {
     name: "dev",
     description: "Start the Kora development environment"
@@ -3872,7 +4209,7 @@ var devCommand = (0, import_citty3.defineCommand)({
     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", (0, import_node_path19.join)(projectRoot, "node_modules", ".bin", "vite"));
+      throw new DevServerError("vite", (0, import_node_path22.join)(projectRoot, "node_modules", ".bin", "vite"));
     }
     const syncServerFile = await findSyncServerFile(projectRoot);
     let managedSyncStore = normalizeManagedSyncStore(config, projectRoot);
@@ -3888,7 +4225,7 @@ var devCommand = (0, import_citty3.defineCommand)({
     }
     if (shouldStartSync && syncServerFile === null && managedSyncStore) {
       const hasServerPackage = await fileExists2(
-        (0, import_node_path19.join)(projectRoot, "node_modules", "@korajs", "server", "package.json")
+        (0, import_node_path22.join)(projectRoot, "node_modules", "@korajs", "server", "package.json")
       );
       if (!hasServerPackage) {
         logger.warn(
@@ -3905,7 +4242,7 @@ var devCommand = (0, import_citty3.defineCommand)({
     }
     let configuredSchemaPath = null;
     if (typeof config?.schema === "string") {
-      const candidate = (0, import_node_path20.resolve)(projectRoot, config.schema);
+      const candidate = (0, import_node_path23.resolve)(projectRoot, config.schema);
       if (await fileExists2(candidate)) {
         configuredSchemaPath = candidate;
       } else {
@@ -3920,8 +4257,8 @@ var devCommand = (0, import_citty3.defineCommand)({
     let schemaWatcher = null;
     let shuttingDown = false;
     let resolveFinished;
-    const finished = new Promise((resolve9) => {
-      resolveFinished = resolve9;
+    const finished = new Promise((resolve11) => {
+      resolveFinished = resolve11;
     });
     const onManagedProcessExit = () => {
       if (!processManager.hasRunning() && !shuttingDown) {
@@ -3964,11 +4301,15 @@ var devCommand = (0, import_citty3.defineCommand)({
       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: true");
     processManager.spawn({
       label: "vite",
       command: process.execPath,
       args: [viteEntryPoint, "--port", String(vitePort)],
       cwd: projectRoot,
+      env: {
+        KORA_DEV: "1"
+      },
       onExit: onManagedProcessExit
     });
     if (shouldStartSync && hasTsx && syncServerFile) {
@@ -4019,10 +4360,10 @@ var devCommand = (0, import_citty3.defineCommand)({
   }
 });
 async function findSyncServerFile(projectRoot) {
-  const candidates = [(0, import_node_path19.join)(projectRoot, "server.ts"), (0, import_node_path19.join)(projectRoot, "server.js")];
+  const candidates = [(0, import_node_path22.join)(projectRoot, "server.ts"), (0, import_node_path22.join)(projectRoot, "server.js")];
   for (const candidate of candidates) {
     try {
-      await (0, import_promises13.access)(candidate);
+      await (0, import_promises14.access)(candidate);
       return candidate;
     } catch {
     }
@@ -4031,7 +4372,7 @@ async function findSyncServerFile(projectRoot) {
 }
 async function fileExists2(path) {
   try {
-    await (0, import_promises13.access)(path);
+    await (0, import_promises14.access)(path);
     return true;
   } catch {
     return false;
@@ -4043,7 +4384,7 @@ function normalizeManagedSyncStore(config, projectRoot) {
   const store = sync.store;
   if (store === void 0) return { type: "memory" };
   if (store === "memory") return { type: "memory" };
-  if (store === "sqlite") return { type: "sqlite", filename: (0, import_node_path19.join)(projectRoot, "kora-sync.db") };
+  if (store === "sqlite") return { type: "sqlite", filename: (0, import_node_path22.join)(projectRoot, "kora-sync.db") };
   if (store === "postgres") {
     const connectionString = process.env.DATABASE_URL;
     if (!connectionString) return null;
@@ -4052,7 +4393,7 @@ function normalizeManagedSyncStore(config, projectRoot) {
   if (typeof store === "object" && store !== null) {
     if (store.type === "memory") return { type: "memory" };
     if (store.type === "sqlite") {
-      const filename = typeof store.filename === "string" && store.filename.length > 0 ? (0, import_node_path20.resolve)(projectRoot, store.filename) : (0, import_node_path19.join)(projectRoot, "kora-sync.db");
+      const filename = typeof store.filename === "string" && store.filename.length > 0 ? (0, import_node_path23.resolve)(projectRoot, store.filename) : (0, import_node_path22.join)(projectRoot, "kora-sync.db");
       return { type: "sqlite", filename };
     }
     if (store.type === "postgres" && typeof store.connectionString === "string") {
@@ -4090,35 +4431,403 @@ if (storeConfig.type === 'memory') {
   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));
+  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
+var import_citty6 = require("citty");
+
+// src/commands/doctor/doctor-checks.ts
+var import_promises15 = require("fs/promises");
+var import_node_path24 = require("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 = (0, import_node_path24.resolve)(projectRoot, configSchema);
+    try {
+      await (0, import_promises15.access)(resolved);
+      return resolved;
+    } catch {
+    }
+  }
+  return findSchemaFile(projectRoot);
+}
+async function checkWorkerFile(projectRoot) {
+  const candidates = [
+    (0, import_node_path24.join)(projectRoot, "src", "kora-worker.ts"),
+    (0, import_node_path24.join)(projectRoot, "src", "kora-worker.js")
+  ];
+  for (const path of candidates) {
+    try {
+      await (0, import_promises15.access)(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 (0, import_promises15.readFile)((0, import_node_path24.join)(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 = (0, import_node_path24.join)(projectRoot, file);
+    try {
+      const content = await (0, import_promises15.readFile)(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."
+      }
+    ];
+  }
 }
-const server = createKoraServer({ store, port: Number(config.port ?? 3001) });
-const shutdown = async () => {
-  try {
-    await server.stop();
-  } catch {
+function doctorHasFailures(results) {
+  return results.some((r) => r.status === "fail");
+}
+
+// src/commands/doctor/doctor-command.ts
+var doctorCommand = (0, import_citty6.defineCommand)({
+  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.");
+    }
   }
-  process.exit(0);
-};
-process.on('SIGINT', () => {
-  void shutdown();
-});
-process.on('SIGTERM', () => {
-  void shutdown();
 });
-await server.start();
-process.stdout.write('Managed sync server running on ws://localhost:' + String(config.port ?? 3001) + '\\n');
-await new Promise(() => {});
-`;
 
 // src/commands/generate/generate-command.ts
-var import_promises14 = require("fs/promises");
-var import_node_path21 = require("path");
-var import_citty4 = require("citty");
+var import_promises16 = require("fs/promises");
+var import_node_path25 = require("path");
+var import_citty7 = require("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/type-generator.ts
 function generateTypes(schema) {
@@ -4132,7 +4841,7 @@ function generateTypes(schema) {
     return lines.join("\n");
   }
   for (const [name, collection] of Object.entries(schema.collections)) {
-    const pascal = toPascalCase(name);
+    const pascal = toPascalCase2(name);
     const fields = collection.fields;
     lines.push(`export interface ${pascal}Record {`);
     lines.push("	readonly id: string");
@@ -4209,7 +4918,7 @@ function itemKindToTypeScript(kind) {
       return "unknown";
   }
 }
-function toPascalCase(name) {
+function toPascalCase2(name) {
   return name.split(/[_-]/).map((part) => {
     if (part.length === 0) return "";
     const first = part[0];
@@ -4218,13 +4927,13 @@ function toPascalCase(name) {
 }
 
 // src/commands/generate/generate-command.ts
-var generateCommand = (0, import_citty4.defineCommand)({
+var generateCommand = (0, import_citty7.defineCommand)({
   meta: {
     name: "generate",
     description: "Generate code from your Kora schema"
   },
   subCommands: {
-    types: (0, import_citty4.defineCommand)({
+    types: (0, import_citty7.defineCommand)({
       meta: {
         name: "types",
         description: "Generate TypeScript types from your schema"
@@ -4248,7 +4957,7 @@ var generateCommand = (0, import_citty4.defineCommand)({
         }
         let schemaPath;
         if (args.schema && typeof args.schema === "string") {
-          schemaPath = (0, import_node_path21.resolve)(args.schema);
+          schemaPath = (0, import_node_path25.resolve)(args.schema);
         } else {
           const found = await findSchemaFile(projectRoot);
           if (!found) {
@@ -4263,7 +4972,7 @@ var generateCommand = (0, import_citty4.defineCommand)({
         }
         logger.step(`Reading schema from ${schemaPath}...`);
         const schemaModule = await import(schemaPath);
-        const schema = extractSchema(schemaModule);
+        const schema = extractSchema2(schemaModule);
         if (!schema) {
           logger.error("Schema file must export a SchemaDefinition as the default export.");
           process.exitCode = 1;
@@ -4271,31 +4980,193 @@ var generateCommand = (0, import_citty4.defineCommand)({
         }
         const output = generateTypes(schema);
         const outputFile = typeof args.output === "string" ? args.output : "kora/generated/types.ts";
-        const outputPath = (0, import_node_path21.resolve)(projectRoot, outputFile);
-        await (0, import_promises14.mkdir)((0, import_node_path21.dirname)(outputPath), { recursive: true });
-        await (0, import_promises14.writeFile)(outputPath, output, "utf-8");
+        const outputPath = (0, import_node_path25.resolve)(projectRoot, outputFile);
+        await (0, import_promises16.mkdir)((0, import_node_path25.dirname)(outputPath), { recursive: true });
+        await (0, import_promises16.writeFile)(outputPath, output, "utf-8");
         logger.success(`Generated types at ${outputPath}`);
       }
+    }),
+    hooks: (0, import_citty7.defineCommand)({
+      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 = (0, import_node_path25.resolve)(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" ? (0, import_node_path25.resolve)(projectRoot, args.output) : (0, import_node_path25.resolve)(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 = (0, import_node_path25.resolve)(outputDir, name);
+          await (0, import_promises16.mkdir)((0, import_node_path25.dirname)(filePath), { recursive: true });
+          await (0, import_promises16.writeFile)(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) {
+function extractSchema2(mod) {
   if (typeof mod !== "object" || mod === null) return null;
   const record = mod;
   const candidate = record.default ?? record;
-  if (isSchemaDefinition(candidate)) return candidate;
+  if (isSchemaDefinition2(candidate)) return candidate;
   return null;
 }
-function isSchemaDefinition(value) {
+function isSchemaDefinition2(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
+var import_citty8 = require("citty");
+var DEFAULT_SYNC_PORT2 = 3001;
+var EVENTS_ENDPOINT = "/__kora/events";
+var logsCommand = (0, import_citty8.defineCommand)({
+  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
-var import_promises15 = require("fs/promises");
-var import_node_path23 = require("path");
-var import_citty5 = require("citty");
+var import_promises17 = require("fs/promises");
+var import_node_path26 = require("path");
+var import_citty9 = require("citty");
 
 // src/commands/migrate/migration-generator.ts
 var import_core2 = require("@korajs/core");
@@ -4861,83 +5732,34 @@ async function loadPostgresModule() {
   }
 }
 
-// src/commands/migrate/schema-loader.ts
-var import_node_child_process11 = require("child_process");
-var import_node_path22 = require("path");
-var import_node_url4 = require("url");
-async function loadSchemaDefinition(schemaPath, projectRoot) {
-  const ext = (0, import_node_path22.extname)(schemaPath);
-  const moduleValue = ext === ".ts" || ext === ".mts" || ext === ".cts" ? await loadTypeScriptModule(schemaPath, projectRoot) : await import(`${(0, import_node_url4.pathToFileURL)(schemaPath).href}?t=${Date.now()}-${Math.random()}`);
-  return extractSchema2(moduleValue);
-}
-function extractSchema2(value) {
-  if (typeof value !== "object" || value === null) {
-    throw new Error("Schema module must export an object.");
-  }
-  const moduleRecord = value;
-  const candidate = moduleRecord.default ?? moduleRecord;
-  if (!isSchemaDefinition2(candidate)) {
-    throw new Error("Schema module must export a valid SchemaDefinition as default export.");
-  }
-  return candidate;
-}
-function isSchemaDefinition2(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const object = value;
-  return typeof object.version === "number" && typeof object.collections === "object" && object.collections !== null && typeof object.relations === "object" && object.relations !== null;
-}
-async function loadTypeScriptModule(schemaPath, projectRoot) {
-  if (!await hasTsxInstalled(projectRoot)) {
-    throw new Error(
-      `Schema file is TypeScript (${schemaPath}) but local "tsx" was not found. Install tsx in the project.`
-    );
-  }
-  const script = "const modulePath = process.argv[process.argv.length - 1];import('node:url').then(u => import(u.pathToFileURL(modulePath).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 runCommand2(
-    process.execPath,
-    ["--import", "tsx", "--eval", script, schemaPath],
-    projectRoot
-  );
-  try {
-    return JSON.parse(output);
-  } catch {
-    throw new Error(`Failed to parse schema module output for ${schemaPath}`);
-  }
-}
-async function runCommand2(command, args, cwd) {
-  return await new Promise((resolve9, reject) => {
-    const child = (0, import_node_child_process11.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) {
-        resolve9(stdout.trim());
-        return;
-      }
-      reject(
-        new Error(`Failed to load TypeScript schema (exit ${code ?? "unknown"}): ${stderr.trim()}`)
-      );
-    });
-  });
+// 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 = (0, import_citty5.defineCommand)({
+var migrateCommand = (0, import_citty9.defineCommand)({
   meta: {
     name: "migrate",
     description: "Detect schema changes and generate/apply migrations"
@@ -4979,12 +5801,12 @@ var migrateCommand = (0, import_citty5.defineCommand)({
       throw new InvalidProjectError(process.cwd());
     }
     const config = await loadKoraConfig(projectRoot);
-    const resolvedSchemaPath = typeof args.schema === "string" ? (0, import_node_path23.resolve)(projectRoot, args.schema) : typeof config?.schema === "string" ? (0, import_node_path23.resolve)(projectRoot, config.schema) : await findSchemaFile(projectRoot);
+    const resolvedSchemaPath = typeof args.schema === "string" ? (0, import_node_path26.resolve)(projectRoot, args.schema) : typeof config?.schema === "string" ? (0, import_node_path26.resolve)(projectRoot, config.schema) : await findSchemaFile(projectRoot);
     if (!resolvedSchemaPath) {
       throw new SchemaNotFoundError(["src/schema.ts", "schema.ts", "src/schema.js", "schema.js"]);
     }
     const currentSchema = await loadSchemaDefinition(resolvedSchemaPath, projectRoot);
-    const snapshotFile = (0, import_node_path23.join)(projectRoot, SNAPSHOT_PATH);
+    const snapshotFile = (0, import_node_path26.join)(projectRoot, SNAPSHOT_PATH);
     const previousSchema = await readSchemaSnapshot(snapshotFile);
     if (!previousSchema) {
       if (args["dry-run"] === true) {
@@ -4997,7 +5819,7 @@ var migrateCommand = (0, import_citty5.defineCommand)({
       return;
     }
     const diff = diffSchemas(previousSchema, currentSchema);
-    const outputDir = typeof args["output-dir"] === "string" ? (0, import_node_path23.resolve)(projectRoot, args["output-dir"]) : (0, import_node_path23.resolve)(projectRoot, MIGRATIONS_DIR);
+    const outputDir = typeof args["output-dir"] === "string" ? (0, import_node_path26.resolve)(projectRoot, args["output-dir"]) : (0, import_node_path26.resolve)(projectRoot, MIGRATIONS_DIR);
     if (!diff.hasChanges) {
       logger.success("No schema changes detected.");
       if (args.apply === true) {
@@ -5049,7 +5871,7 @@ var migrateCommand = (0, import_citty5.defineCommand)({
       logger.warn("Dry run enabled: no files written, no migrations applied.");
       return;
     }
-    await (0, import_promises15.mkdir)(outputDir, { recursive: true });
+    await (0, import_promises17.mkdir)(outputDir, { recursive: true });
     const migrationPath = await writeMigrationFile(
       outputDir,
       diff.fromVersion,
@@ -5085,7 +5907,7 @@ var migrateCommand = (0, import_citty5.defineCommand)({
 });
 async function readSchemaSnapshot(path) {
   try {
-    const content = await (0, import_promises15.readFile)(path, "utf-8");
+    const content = await (0, import_promises17.readFile)(path, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -5106,15 +5928,15 @@ function isInteractiveTerminal2() {
   return process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
 async function writeSchemaSnapshot(path, schema) {
-  await (0, import_promises15.mkdir)((0, import_node_path23.dirname)(path), { recursive: true });
-  await (0, import_promises15.writeFile)(path, `${JSON.stringify(schema, null, 2)}
+  await (0, import_promises17.mkdir)((0, import_node_path26.dirname)(path), { recursive: true });
+  await (0, import_promises17.writeFile)(path, `${JSON.stringify(schema, null, 2)}
 `, "utf-8");
 }
 async function writeMigrationFile(outputDir, fromVersion, toVersion, generated) {
-  const existing = await (0, import_promises15.readdir)(outputDir).catch(() => []);
+  const existing = await (0, import_promises17.readdir)(outputDir).catch(() => []);
   const sequence = existing.filter((file) => /^\d{3}-/.test(file)).length + 1;
   const filename = `${String(sequence).padStart(3, "0")}-v${fromVersion}-to-v${toVersion}.ts`;
-  const path = (0, import_node_path23.join)(outputDir, filename);
+  const path = (0, import_node_path26.join)(outputDir, filename);
   const migrationId = filename.replace(/\.ts$/, "");
   const fileContent = [
     `export const up = ${JSON.stringify(generated.up, null, 2)} as const`,
@@ -5126,8 +5948,10 @@ async function writeMigrationFile(outputDir, fromVersion, toVersion, generated)
     `export const containsBreakingChanges = ${generated.containsBreakingChanges}`,
     ""
   ].join("\n");
-  await (0, import_promises15.writeFile)(path, fileContent, "utf-8");
-  await writeMigrationManifest((0, import_node_path23.join)(outputDir, `${migrationId}.json`), {
+  await (0, import_promises17.writeFile)(path, fileContent, "utf-8");
+  const transformsPath = (0, import_node_path26.join)(outputDir, `${migrationId}.transforms.ts`);
+  await (0, import_promises17.writeFile)(transformsPath, generateOperationTransformModule(fromVersion, toVersion), "utf-8");
+  await writeMigrationManifest((0, import_node_path26.join)(outputDir, `${migrationId}.json`), {
     id: migrationId,
     fromVersion,
     toVersion,
@@ -5139,22 +5963,22 @@ async function writeMigrationFile(outputDir, fromVersion, toVersion, generated)
   return path;
 }
 async function writeMigrationManifest(path, manifest) {
-  await (0, import_promises15.writeFile)(path, `${JSON.stringify(manifest, null, 2)}
+  await (0, import_promises17.writeFile)(path, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
 }
 async function listMigrationManifests(outputDir) {
-  const files = await (0, import_promises15.readdir)(outputDir).catch(() => []);
+  const files = await (0, import_promises17.readdir)(outputDir).catch(() => []);
   const migrationFiles = files.filter((file) => /^\d{3}-.*\.ts$/.test(file)).sort((left, right) => left.localeCompare(right));
   const manifests = [];
   for (const file of migrationFiles) {
     const id = file.replace(/\.ts$/, "");
-    const manifestPath = (0, import_node_path23.join)(outputDir, `${id}.json`);
+    const manifestPath = (0, import_node_path26.join)(outputDir, `${id}.json`);
     const jsonManifest = await readMigrationManifest(manifestPath);
     if (jsonManifest) {
       manifests.push({ ...jsonManifest, id });
       continue;
     }
-    const migrationPath = (0, import_node_path23.join)(outputDir, file);
+    const migrationPath = (0, import_node_path26.join)(outputDir, file);
     const sourceManifest = await readMigrationManifestFromSource(migrationPath, id);
     manifests.push(sourceManifest);
   }
@@ -5162,7 +5986,7 @@ async function listMigrationManifests(outputDir) {
 }
 async function readMigrationManifest(path) {
   try {
-    const content = await (0, import_promises15.readFile)(path, "utf-8");
+    const content = await (0, import_promises17.readFile)(path, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     const code = error.code;
@@ -5173,7 +5997,7 @@ async function readMigrationManifest(path) {
   }
 }
 async function readMigrationManifestFromSource(path, id) {
-  const content = await (0, import_promises15.readFile)(path, "utf-8");
+  const content = await (0, import_promises17.readFile)(path, "utf-8");
   const versions = parseVersionsFromMigrationId(id);
   return {
     id,
@@ -5190,9 +6014,14 @@ function parseVersionsFromMigrationId(id) {
   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(match[1], 10),
-    toVersion: Number.parseInt(match[2], 10)
+    fromVersion: Number.parseInt(fromVersionText, 10),
+    toVersion: Number.parseInt(toVersionText, 10)
   };
 }
 function parseStringArrayExport(source, exportName) {
@@ -5230,18 +6059,18 @@ function parseLiteralExport(source, exportName) {
 }
 function resolveSqliteApplyPath(dbArg, projectRoot, config) {
   if (typeof dbArg === "string") {
-    return (0, import_node_path23.resolve)(projectRoot, dbArg);
+    return (0, import_node_path26.resolve)(projectRoot, dbArg);
   }
   const sync = config?.dev?.sync;
   if (typeof sync === "object" && sync !== null) {
     if (sync.store === "sqlite") {
-      return (0, import_node_path23.join)(projectRoot, "kora-sync.db");
+      return (0, import_node_path26.join)(projectRoot, "kora-sync.db");
     }
     if (typeof sync.store === "object" && sync.store !== null && sync.store.type === "sqlite") {
       if (typeof sync.store.filename === "string" && sync.store.filename.length > 0) {
-        return (0, import_node_path23.resolve)(projectRoot, sync.store.filename);
+        return (0, import_node_path26.resolve)(projectRoot, sync.store.filename);
       }
-      return (0, import_node_path23.join)(projectRoot, "kora-sync.db");
+      return (0, import_node_path26.join)(projectRoot, "kora-sync.db");
     }
   }
   return void 0;
@@ -5258,19 +6087,156 @@ function resolvePostgresConnectionString(config) {
   return void 0;
 }
 
+// src/commands/status/status-command.ts
+var import_citty10 = require("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 = (0, import_citty10.defineCommand)({
+  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/bin.ts
-var main = (0, import_citty6.defineCommand)({
+var main = (0, import_citty11.defineCommand)({
   meta: {
     name: "kora",
     description: "Kora.js \u2014 Offline-first application framework"
   },
   subCommands: {
+    backup: backupCommand,
+    compact: compactCommand,
     create: createCommand,
     dev: devCommand,
+    doctor: doctorCommand,
     deploy: deployCommand,
     generate: generateCommand,
-    migrate: migrateCommand
+    logs: logsCommand,
+    migrate: migrateCommand,
+    status: statusCommand
   }
 });
-(0, import_citty6.runMain)(main);
+(0, import_citty11.runMain)(main);
 //# sourceMappingURL=bin.cjs.map