@korajs/cli 0.1.14 → 0.2.0

package/dist/bin.cjs

@@ -23,12 +23,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/bin.ts
-var import_citty5 = require("citty");
+var import_citty6 = require("citty");
 
 // src/commands/create/create-command.ts
 var import_node_child_process2 = require("child_process");
 var import_node_fs2 = require("fs");
-var import_node_path3 = require("path");
+var import_node_path5 = require("path");
 var import_node_url2 = require("url");
 var import_citty = require("citty");
 
@@ -85,6 +85,209 @@ var DevServerError = class extends import_core.KoraError {
   searchPath;
 };
 
+// src/prompts/preferences.ts
+var import_conf = __toESM(require("conf"), 1);
+var DEFAULT_PREFERENCES = {
+  framework: "react",
+  tailwind: true,
+  sync: true,
+  db: "sqlite",
+  dbProvider: "none",
+  auth: "none",
+  packageManager: "pnpm"
+};
+var PREFERENCES_KEY = "create.defaults";
+var PreferenceStore = class {
+  store;
+  constructor() {
+    this.store = new import_conf.default({
+      projectName: "korajs-cli"
+    });
+  }
+  getCreatePreferences() {
+    return this.store.get(PREFERENCES_KEY) ?? null;
+  }
+  saveCreatePreferences(preferences) {
+    this.store.set(PREFERENCES_KEY, preferences);
+  }
+  clearCreatePreferences() {
+    this.store.delete(PREFERENCES_KEY);
+  }
+};
+function getCreatePreferencesOrDefault(store) {
+  return store.getCreatePreferences() ?? DEFAULT_PREFERENCES;
+}
+function getDefaultCreatePreferences() {
+  return { ...DEFAULT_PREFERENCES };
+}
+
+// src/prompts/prompt-client.ts
+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) => {
+    const rl = createReadline(options);
+    const suffix = defaultValue !== void 0 ? ` (${defaultValue})` : "";
+    rl.question(`  ? ${message}${suffix}: `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      resolve9(trimmed || defaultValue || "");
+    });
+  });
+}
+function promptSelect(message, choices, options) {
+  return new Promise((resolve9) => {
+    const rl = createReadline(options);
+    const out = options?.output ?? process.stdout;
+    out.write(`  ? ${message}
+`);
+    for (let i = 0; i < choices.length; i++) {
+      const choice = choices[i];
+      if (choice) {
+        out.write(`    ${i + 1}) ${choice.label}
+`);
+      }
+    }
+    const ask = () => {
+      rl.question("  > ", (answer) => {
+        const index = Number.parseInt(answer.trim(), 10) - 1;
+        const selected = choices[index];
+        if (selected) {
+          rl.close();
+          resolve9(selected.value);
+        } else {
+          out.write(`  Please enter a number between 1 and ${choices.length}
+`);
+          ask();
+        }
+      });
+    };
+    ask();
+  });
+}
+function promptConfirm(message, defaultValue = false, options) {
+  return new Promise((resolve9) => {
+    const rl = createReadline(options);
+    const suffix = defaultValue ? "Y/n" : "y/N";
+    const ask = () => {
+      rl.question(`  ? ${message} (${suffix}): `, (answer) => {
+        const normalized = answer.trim().toLowerCase();
+        if (normalized.length === 0) {
+          rl.close();
+          resolve9(defaultValue);
+          return;
+        }
+        if (normalized === "y" || normalized === "yes") {
+          rl.close();
+          resolve9(true);
+          return;
+        }
+        if (normalized === "n" || normalized === "no") {
+          rl.close();
+          resolve9(false);
+          return;
+        }
+        (options?.output ?? process.stdout).write("  Please answer with y or n\n");
+        ask();
+      });
+    };
+    ask();
+  });
+}
+function createReadline(options) {
+  return (0, import_node_readline.createInterface)({
+    input: options?.input ?? process.stdin,
+    output: options?.output ?? process.stdout
+  });
+}
+
+// src/prompts/prompt-client.ts
+var PromptCancelledError = class extends Error {
+  constructor(message = "Prompt cancelled by user") {
+    super(message);
+    this.name = "PromptCancelledError";
+  }
+};
+var ReadlinePromptClient = class {
+  async text(message, defaultValue) {
+    return promptText(message, defaultValue);
+  }
+  async select(message, options) {
+    return promptSelect(
+      message,
+      options.filter((option) => option.disabled !== true).map((option) => ({ label: option.label, value: option.value }))
+    );
+  }
+  async confirm(message, defaultValue = false) {
+    return promptConfirm(message, defaultValue);
+  }
+  intro(message) {
+    void message;
+  }
+  outro(message) {
+    void message;
+  }
+};
+function createPromptClient() {
+  const canUseInteractiveClack = typeof process !== "undefined" && process.stdin.isTTY && process.stdout.isTTY;
+  if (canUseInteractiveClack) {
+    return new ClackPromptClient();
+  }
+  return new ReadlinePromptClient();
+}
+var ClackPromptClient = class {
+  async text(message, defaultValue) {
+    const result = await (0, import_prompts.text)({
+      message,
+      placeholder: defaultValue,
+      defaultValue
+    });
+    if ((0, import_prompts.isCancel)(result)) {
+      (0, import_prompts.cancel)("Operation cancelled.");
+      throw new PromptCancelledError();
+    }
+    const value = result.trim();
+    if (value.length > 0) return value;
+    return defaultValue ?? "";
+  }
+  async select(message, options) {
+    const mappedOptions = options.map((option) => ({
+      label: option.label,
+      value: option.value,
+      hint: option.hint,
+      disabled: option.disabled
+    }));
+    const result = await (0, import_prompts.select)({
+      message,
+      options: mappedOptions
+    });
+    if ((0, import_prompts.isCancel)(result)) {
+      (0, import_prompts.cancel)("Operation cancelled.");
+      throw new PromptCancelledError();
+    }
+    return result;
+  }
+  async confirm(message, defaultValue = false) {
+    const result = await (0, import_prompts.confirm)({
+      message,
+      initialValue: defaultValue
+    });
+    if ((0, import_prompts.isCancel)(result)) {
+      (0, import_prompts.cancel)("Operation cancelled.");
+      throw new PromptCancelledError();
+    }
+    return result;
+  }
+  intro(message) {
+    (0, import_prompts.intro)(message);
+  }
+  outro(message) {
+    (0, import_prompts.outro)(message);
+  }
+};
+
 // src/types.ts
 var PACKAGE_MANAGERS = ["pnpm", "npm", "yarn", "bun"];
 var TEMPLATES = [
@@ -93,28 +296,6 @@ var TEMPLATES = [
   "react-sync",
   "react-basic"
 ];
-var TEMPLATE_INFO = [
-  {
-    name: "react-tailwind-sync",
-    label: "React + Tailwind (with sync)",
-    description: "Polished dark-themed app with Tailwind CSS and sync server (Recommended)"
-  },
-  {
-    name: "react-tailwind",
-    label: "React + Tailwind (local-only)",
-    description: "Polished dark-themed app with Tailwind CSS \u2014 no sync server"
-  },
-  {
-    name: "react-sync",
-    label: "React + CSS (with sync)",
-    description: "Clean CSS app with sync server included"
-  },
-  {
-    name: "react-basic",
-    label: "React + CSS (local-only)",
-    description: "Clean CSS app \u2014 no sync server"
-  }
-];
 
 // src/utils/fs-helpers.ts
 var import_promises = require("fs/promises");
@@ -258,288 +439,2291 @@ function getRunDevCommand(pm) {
   return `${pm} dev`;
 }
 
-// src/utils/prompt.ts
-var import_node_readline = require("readline");
-function promptText(message, defaultValue, options) {
-  return new Promise((resolve7) => {
-    const rl = createReadline(options);
-    const suffix = defaultValue !== void 0 ? ` (${defaultValue})` : "";
-    rl.question(`  ? ${message}${suffix}: `, (answer) => {
-      rl.close();
-      const trimmed = answer.trim();
-      resolve7(trimmed || defaultValue || "");
-    });
-  });
+// src/commands/create/environment-detection.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+function detectEditorFromEnvironment(env = process.env) {
+  const termProgram = String(env.TERM_PROGRAM ?? "").toLowerCase();
+  const editorValue = `${String(env.EDITOR ?? "")} ${String(env.VISUAL ?? "")}`.toLowerCase();
+  if (termProgram.includes("cursor") || env.CURSOR_TRACE_ID !== void 0 || env.CURSOR_SESSION_ID !== void 0 || editorValue.includes("cursor")) {
+    return { editor: "cursor", source: "env" };
+  }
+  if (termProgram.includes("windsurf") || env.WINDSURF_SESSION_ID !== void 0 || editorValue.includes("windsurf")) {
+    return { editor: "windsurf", source: "env" };
+  }
+  if (termProgram.includes("vscode") || env.VSCODE_GIT_IPC_HANDLE !== void 0 || env.VSCODE_IPC_HOOK !== void 0 || env.VSCODE_PID !== void 0 || editorValue.includes("code")) {
+    return { editor: "vscode", source: "env" };
+  }
+  if (termProgram.includes("zed") || env.ZED_TERM !== void 0 || editorValue.includes("zed")) {
+    return { editor: "zed", source: "env" };
+  }
+  return { editor: "unknown", source: "none" };
 }
-function promptSelect(message, choices, options) {
-  return new Promise((resolve7) => {
-    const rl = createReadline(options);
-    const out = options?.output ?? process.stdout;
-    out.write(`  ? ${message}
-`);
-    for (let i = 0; i < choices.length; i++) {
-      const choice = choices[i];
-      if (choice) {
-        out.write(`    ${i + 1}) ${choice.label}
-`);
-      }
+async function detectGitContext(startDir) {
+  const root = await findNearestAncestorWithEntry(startDir, ".git");
+  return {
+    hasRepository: root !== null,
+    repositoryRoot: root
+  };
+}
+async function detectMonorepoContext(startDir) {
+  let current = (0, import_node_path2.resolve)(startDir);
+  for (; ; ) {
+    if (await fileExists((0, import_node_path2.join)(current, "pnpm-workspace.yaml"))) {
+      return { isMonorepo: true, root: current, kind: "pnpm-workspace" };
     }
-    const ask = () => {
-      rl.question("  > ", (answer) => {
-        const index = Number.parseInt(answer.trim(), 10) - 1;
-        const selected = choices[index];
-        if (selected) {
-          rl.close();
-          resolve7(selected.value);
-        } else {
-          out.write(`  Please enter a number between 1 and ${choices.length}
-`);
-          ask();
+    if (await fileExists((0, import_node_path2.join)(current, "turbo.json"))) {
+      return { isMonorepo: true, root: current, kind: "turborepo" };
+    }
+    const packageJsonPath = (0, import_node_path2.join)(current, "package.json");
+    if (await fileExists(packageJsonPath)) {
+      try {
+        const packageJsonRaw = await (0, import_promises2.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" };
         }
-      });
-    };
-    ask();
+      } catch {
+      }
+    }
+    const parent = (0, import_node_path2.dirname)(current);
+    if (parent === current) {
+      return { isMonorepo: false, root: null, kind: "none" };
+    }
+    current = parent;
+  }
+}
+async function applyEditorWorkspacePreset(params) {
+  const { targetDir, editor } = 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 recommendations = ["korajs.kora-devtools"];
+  const existing = await readJsonObject(extensionsPath);
+  const existingRecommendations = Array.isArray(existing?.recommendations) ? existing.recommendations.filter((item) => typeof item === "string") : [];
+  const mergedRecommendations = dedupeStrings([...existingRecommendations, ...recommendations]);
+  const next = {
+    recommendations: mergedRecommendations
+  };
+  await (0, import_promises2.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);
+}
+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 parsed = JSON.parse(content);
+    if (typeof parsed === "object" && parsed !== null) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function isNpmWorkspaceObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return Array.isArray(record.packages);
+}
+async function fileExists(path) {
+  try {
+    await (0, import_promises2.access)(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findNearestAncestorWithEntry(startDir, entryName) {
+  let current = (0, import_node_path2.resolve)(startDir);
+  for (; ; ) {
+    const candidate = (0, import_node_path2.join)(current, entryName);
+    try {
+      await (0, import_promises2.stat)(candidate);
+      return current;
+    } catch {
+    }
+    const parent = (0, import_node_path2.dirname)(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+// src/commands/create/options.ts
+function determineTemplateFromSelections(input) {
+  const shouldSync = input.sync && input.db !== "none";
+  if (input.tailwind && shouldSync) return "react-tailwind-sync";
+  if (input.tailwind && !shouldSync) return "react-tailwind";
+  if (!input.tailwind && shouldSync) return "react-sync";
+  return "react-basic";
+}
+function isFrameworkValue(value) {
+  return value === "react" || value === "vue" || value === "svelte" || value === "solid";
+}
+function isAuthValue(value) {
+  return value === "none" || value === "email-password" || value === "oauth";
+}
+function isDatabaseValue(value) {
+  return value === "none" || value === "sqlite" || value === "postgres";
+}
+function isDatabaseProviderValue(value) {
+  return value === "none" || value === "local" || value === "supabase" || value === "neon" || value === "railway" || value === "vercel-postgres" || value === "custom";
+}
+
+// src/commands/create/preferences-flow.ts
+async function resolveCreatePreferencesFlow(params) {
+  const { flags, prompts, store } = params;
+  const stored = store.getCreatePreferences();
+  const base = getCreatePreferencesOrDefault(store);
+  const hasExplicitFlags = hasExplicitPreferenceFlags(flags);
+  const canOfferStored = !flags.useDefaults && !hasExplicitFlags && stored !== null && promptSupportsRichOptions();
+  let effective = { ...base };
+  let usedStoredPreferences = false;
+  if (flags.useDefaults) {
+    effective = getDefaultCreatePreferences();
+  } else if (canOfferStored && stored !== null) {
+    const reuseStored = await prompts.select("Welcome back! Choose setup mode:", [
+      { label: formatStoredPreferenceLabel(stored), value: "reuse" },
+      { label: "Customize", value: "customize" }
+    ]);
+    if (reuseStored === "reuse") {
+      effective = { ...stored };
+      usedStoredPreferences = true;
+    }
+  }
+  if (flags.framework !== void 0) {
+    if (!isFrameworkValue(flags.framework)) {
+      throw new Error(
+        `Invalid --framework value "${flags.framework}". Expected one of: react, vue, svelte, solid.`
+      );
+    }
+    effective.framework = flags.framework;
+  } else if (!flags.useDefaults && !usedStoredPreferences) {
+    effective.framework = await prompts.select("UI framework:", [
+      { label: "React", value: "react" },
+      { label: "Vue (coming soon)", value: "vue", disabled: true },
+      { label: "Svelte (coming soon)", value: "svelte", disabled: true },
+      { label: "Solid (coming soon)", value: "solid", disabled: true }
+    ]);
+  }
+  if (flags.auth !== void 0) {
+    if (!isAuthValue(flags.auth)) {
+      throw new Error(
+        `Invalid --auth value "${flags.auth}". Expected one of: none, email-password, oauth.`
+      );
+    }
+    effective.auth = flags.auth;
+  } else if (!flags.useDefaults && !usedStoredPreferences) {
+    effective.auth = await prompts.select("Authentication:", [
+      { label: "None", value: "none" },
+      { label: "Email + Password (coming soon)", value: "email-password", disabled: true },
+      { label: "OAuth (coming soon)", value: "oauth", disabled: true }
+    ]);
+  }
+  if (flags.tailwind !== void 0) {
+    effective.tailwind = flags.tailwind;
+  } else if (!flags.useDefaults && !usedStoredPreferences) {
+    effective.tailwind = await prompts.confirm("Use Tailwind CSS?", true);
+  }
+  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("Server-side database:", [
+      { label: "SQLite (zero-config)", value: "sqlite" },
+      { label: "PostgreSQL (production-scale)", value: "postgres" }
+    ]);
+  }
+  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" }
+    ]);
+  }
+  const template = determineTemplateFromSelections({
+    tailwind: effective.tailwind,
+    sync: effective.sync,
+    db: effective.db
   });
+  return {
+    framework: effective.framework,
+    auth: effective.auth,
+    db: effective.db,
+    dbProvider: effective.dbProvider,
+    tailwind: effective.tailwind,
+    sync: effective.sync,
+    template,
+    usedStoredPreferences
+  };
 }
-function promptConfirm(message, defaultValue = false, options) {
-  return new Promise((resolve7) => {
-    const rl = createReadline(options);
-    const suffix = defaultValue ? "Y/n" : "y/N";
-    const ask = () => {
-      rl.question(`  ? ${message} (${suffix}): `, (answer) => {
-        const normalized = answer.trim().toLowerCase();
-        if (normalized.length === 0) {
-          rl.close();
-          resolve7(defaultValue);
-          return;
-        }
-        if (normalized === "y" || normalized === "yes") {
-          rl.close();
-          resolve7(true);
-          return;
-        }
-        if (normalized === "n" || normalized === "no") {
-          rl.close();
-          resolve7(false);
-          return;
-        }
-        (options?.output ?? process.stdout).write("  Please answer with y or n\n");
-        ask();
-      });
+function shouldSavePreferences(flags) {
+  return !flags.useDefaults;
+}
+function saveResolvedPreferences(store, resolution) {
+  store.saveCreatePreferences({
+    framework: resolution.framework,
+    tailwind: resolution.tailwind,
+    sync: resolution.sync,
+    db: resolution.db,
+    dbProvider: resolution.dbProvider,
+    auth: resolution.auth,
+    packageManager: resolution.packageManager
+  });
+}
+function hasExplicitPreferenceFlags(flags) {
+  return flags.framework !== void 0 || flags.auth !== void 0 || flags.db !== void 0 || flags.dbProvider !== void 0 || flags.tailwind !== void 0 || flags.sync !== void 0;
+}
+function promptSupportsRichOptions() {
+  return typeof process !== "undefined" && process.stdin.isTTY && process.stdout.isTTY;
+}
+function formatStoredPreferenceLabel(preferences) {
+  const syncLabel = preferences.sync ? `sync/${preferences.db}` : "local-only";
+  const styleLabel = preferences.tailwind ? "tailwind" : "css";
+  return `Use previous settings (${preferences.framework} + ${styleLabel} + ${syncLabel} + ${preferences.packageManager})`;
+}
+
+// src/commands/create/project-name.ts
+var import_validate_npm_package_name = __toESM(require("validate-npm-package-name"), 1);
+function validateProjectName(name) {
+  const trimmedName = name.trim();
+  if (trimmedName.length === 0) {
+    return {
+      valid: false,
+      issues: ["Project name cannot be empty."]
+    };
+  }
+  const validation = (0, import_validate_npm_package_name.default)(trimmedName);
+  const issues = [...validation.errors ?? [], ...validation.warnings ?? []];
+  if (!validation.validForNewPackages && issues.length === 0) {
+    return {
+      valid: false,
+      issues: ["Project name is not a valid npm package name."]
+    };
+  }
+  return {
+    valid: validation.validForNewPackages,
+    issues
+  };
+}
+
+// src/commands/create/sync-provider-preset.ts
+var import_promises3 = require("fs/promises");
+var import_node_path3 = require("path");
+async function applySyncProviderPreset(options) {
+  if (!isSyncTemplate(options.template)) {
+    return;
+  }
+  if (options.db !== "postgres") {
+    return;
+  }
+  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",
+    "",
+    `# PostgreSQL connection string (${providerName})`,
+    `# Example: ${providerConnectionString}`,
+    "DATABASE_URL=",
+    ""
+  ].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.",
+    ""
+  ].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");
+}
+function isSyncTemplate(template) {
+  return template === "react-sync" || template === "react-tailwind-sync";
+}
+function getProviderDisplayName(provider) {
+  switch (provider) {
+    case "supabase":
+      return "Supabase";
+    case "neon":
+      return "Neon";
+    case "railway":
+      return "Railway";
+    case "vercel-postgres":
+      return "Vercel Postgres";
+    case "custom":
+      return "Custom";
+    case "local":
+      return "Local Postgres";
+    case "none":
+      return "PostgreSQL";
+  }
+}
+function getProviderConnectionStringExample(provider) {
+  switch (provider) {
+    case "supabase":
+      return "postgresql://postgres:<password>@db.<project-ref>.supabase.co:5432/postgres?sslmode=require";
+    case "neon":
+      return "postgresql://<user>:<password>@<branch>.<project>.neon.tech/neondb?sslmode=require";
+    case "railway":
+      return "postgresql://postgres:<password>@<host>.railway.app:<port>/railway?sslmode=require";
+    case "vercel-postgres":
+      return "postgresql://<user>:<password>@<host>.pooler.vercel-storage.com:5432/verceldb?sslmode=require";
+    case "custom":
+      return "postgresql://<user>:<password>@<host>:5432/<database>";
+    case "local":
+      return "postgresql://postgres:postgres@localhost:5432/kora";
+    case "none":
+      return "postgresql://postgres:postgres@localhost:5432/kora";
+  }
+}
+
+// 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_meta = {};
+function substituteVariables(template, context) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
+    const value = context[key];
+    return value !== void 0 ? value : `{{${key}}}`;
+  });
+}
+function getTemplatePath(templateName) {
+  let dir = (0, import_node_path4.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+  for (let i = 0; i < 7; i++) {
+    const candidate = (0, import_node_path4.resolve)(dir, "templates", templateName);
+    if ((0, import_node_fs.existsSync)(candidate)) {
+      return candidate;
+    }
+    dir = (0, import_node_path4.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);
+}
+function createCompatibilityLayerPlan(templateName) {
+  const baseLayer = { category: "base", name: "base", sourceTemplate: "react-basic" };
+  const uiLayer = { category: "ui", name: "react", sourceTemplate: null };
+  const authLayer = { category: "auth", name: "none", sourceTemplate: null };
+  switch (templateName) {
+    case "react-basic":
+      return {
+        compatibilityTarget: templateName,
+        layers: [
+          baseLayer,
+          uiLayer,
+          { category: "style", name: "plain", sourceTemplate: null },
+          { category: "sync", name: "disabled", sourceTemplate: null },
+          { category: "db", name: "none", sourceTemplate: null },
+          authLayer
+        ]
+      };
+    case "react-tailwind":
+      return {
+        compatibilityTarget: templateName,
+        layers: [
+          baseLayer,
+          uiLayer,
+          { category: "style", name: "tailwind", sourceTemplate: "react-tailwind" },
+          { category: "sync", name: "disabled", sourceTemplate: null },
+          { category: "db", name: "none", sourceTemplate: null },
+          authLayer
+        ]
+      };
+    case "react-sync":
+      return {
+        compatibilityTarget: templateName,
+        layers: [
+          baseLayer,
+          uiLayer,
+          { category: "style", name: "plain", sourceTemplate: null },
+          { category: "sync", name: "enabled", sourceTemplate: "react-sync" },
+          { category: "db", name: "sqlite", sourceTemplate: null },
+          authLayer
+        ]
+      };
+    case "react-tailwind-sync":
+      return {
+        compatibilityTarget: templateName,
+        layers: [
+          baseLayer,
+          uiLayer,
+          { category: "style", name: "tailwind", sourceTemplate: "react-tailwind" },
+          { category: "sync", name: "enabled", sourceTemplate: "react-tailwind-sync" },
+          { category: "db", name: "sqlite", sourceTemplate: null },
+          authLayer
+        ]
+      };
+  }
+}
+async function composeTemplateLayers(plan, targetDir, context) {
+  const vars = {
+    projectName: context.projectName,
+    packageManager: context.packageManager,
+    koraVersion: context.koraVersion,
+    dbProvider: context.dbProvider ?? "none"
+  };
+  for (const layer of plan.layers) {
+    if (layer.sourceTemplate === null) {
+      continue;
+    }
+    const sourceDir = getTemplatePath(layer.sourceTemplate);
+    await copyDirectory(sourceDir, targetDir, vars);
+  }
+}
+async function copyDirectory(src, dest, vars) {
+  await (0, import_promises4.mkdir)(dest, { recursive: true });
+  const entries = await (0, import_promises4.readdir)(src);
+  for (const entry of entries) {
+    const srcPath = (0, import_node_path4.join)(src, entry);
+    const srcStat = await (0, import_promises4.stat)(srcPath);
+    if (srcStat.isDirectory()) {
+      await copyDirectory(srcPath, (0, import_node_path4.join)(dest, entry), vars);
+      continue;
+    }
+    if (entry.endsWith(".hbs")) {
+      const content = await (0, import_promises4.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");
+      continue;
+    }
+    await (0, import_promises4.copyFile)(srcPath, (0, import_node_path4.join)(dest, entry));
+  }
+}
+
+// src/commands/create/template-engine.ts
+async function scaffoldTemplate(templateName, targetDir, context) {
+  const plan = createCompatibilityLayerPlan(templateName);
+  await composeTemplateLayers(plan, targetDir, context);
+}
+
+// src/commands/create/create-command.ts
+var import_meta2 = {};
+var createCommand = (0, import_citty.defineCommand)({
+  meta: {
+    name: "create",
+    description: "Create a new Kora application"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Project directory name",
+      required: false
+    },
+    template: {
+      type: "string",
+      description: "Project template (react-tailwind-sync, react-tailwind, react-sync, react-basic)"
+    },
+    pm: {
+      type: "string",
+      description: "Package manager (pnpm, npm, yarn, bun)"
+    },
+    framework: {
+      type: "string",
+      description: "UI framework (react, vue, svelte, solid)"
+    },
+    db: {
+      type: "string",
+      description: "Database backend for sync templates (sqlite, postgres)"
+    },
+    "db-provider": {
+      type: "string",
+      description: "Database provider for postgres (local, supabase, neon, railway, vercel-postgres, custom)"
+    },
+    auth: {
+      type: "string",
+      description: "Authentication mode (none, email-password, oauth)"
+    },
+    "skip-install": {
+      type: "boolean",
+      description: "Skip installing dependencies",
+      default: false
+    },
+    yes: {
+      type: "boolean",
+      alias: "y",
+      description: "Accept all defaults (react-tailwind-sync + detected package manager)",
+      default: false
+    },
+    tailwind: {
+      type: "boolean",
+      description: "Use Tailwind CSS (use --no-tailwind to skip)"
+    },
+    sync: {
+      type: "boolean",
+      description: "Include sync server (use --no-sync to skip)"
+    }
+  },
+  async run({ args }) {
+    const logger = createLogger();
+    const prompts = createPromptClient();
+    const preferenceStore = new PreferenceStore();
+    logger.banner();
+    try {
+      const useDefaults = args.yes === true;
+      if (!useDefaults) {
+        prompts.intro("Kora.js \u2014 Offline-first application framework");
+      }
+      const projectName = args.name || (useDefaults ? "my-kora-app" : await prompts.text("Project name", "my-kora-app"));
+      if (!projectName) {
+        logger.error("Project name is required");
+        process.exitCode = 1;
+        return;
+      }
+      const nameValidation = validateProjectName(projectName);
+      if (!nameValidation.valid) {
+        logger.error("Invalid project name.");
+        for (const issue of nameValidation.issues) {
+          logger.step(`- ${issue}`);
+        }
+        if (!useDefaults) {
+          prompts.outro("Project creation aborted.");
+        }
+        process.exitCode = 1;
+        return;
+      }
+      const preferenceFlags = {
+        framework: typeof args.framework === "string" ? args.framework : void 0,
+        auth: typeof args.auth === "string" ? args.auth : void 0,
+        db: typeof args.db === "string" ? args.db : void 0,
+        dbProvider: typeof args["db-provider"] === "string" ? args["db-provider"] : void 0,
+        tailwind: args.tailwind,
+        sync: args.sync,
+        useDefaults
+      };
+      const selection = await resolveCreatePreferencesFlow({
+        flags: preferenceFlags,
+        prompts,
+        store: preferenceStore
+      });
+      if (selection.framework !== "react") {
+        logger.error(`Framework "${selection.framework}" is not available yet. Use "react".`);
+        if (!useDefaults) {
+          prompts.outro("Project creation aborted.");
+        }
+        process.exitCode = 1;
+        return;
+      }
+      if (selection.auth !== "none") {
+        logger.error(`Auth mode "${selection.auth}" is not available yet. Use "none".`);
+        if (!useDefaults) {
+          prompts.outro("Project creation aborted.");
+        }
+        process.exitCode = 1;
+        return;
+      }
+      const template = args.template && isValidTemplate(args.template) ? args.template : selection.template;
+      let pm;
+      if (args.pm && isValidPackageManager(args.pm)) {
+        pm = args.pm;
+      } else if (useDefaults) {
+        pm = detectPackageManager();
+      } else if (selection.usedStoredPreferences) {
+        pm = preferenceStore.getCreatePreferences()?.packageManager ?? detectPackageManager();
+      } else {
+        const detected = detectPackageManager();
+        pm = await prompts.select(
+          "Package manager:",
+          PACKAGE_MANAGERS.map((p) => ({
+            label: p === detected ? `${p} (detected)` : p,
+            value: p
+          }))
+        );
+      }
+      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);
+      if (!useDefaults && monorepoContext.isMonorepo && monorepoContext.root !== null) {
+        const useWorkspaceTarget = await prompts.confirm(
+          `Detected ${formatMonorepoKind(monorepoContext.kind)} at ${monorepoContext.root}. Create app under packages/${projectName}?`,
+          true
+        );
+        if (useWorkspaceTarget) {
+          targetDir = resolveMonorepoTargetDirectory(monorepoContext.root, projectName);
+        }
+      }
+      if (await directoryExists(targetDir)) {
+        throw new ProjectExistsError(projectName);
+      }
+      const koraVersion = resolveKoraVersion();
+      logger.step(`Creating ${projectName} with ${template} template...`);
+      await scaffoldTemplate(template, targetDir, {
+        projectName,
+        packageManager: pm,
+        koraVersion,
+        dbProvider: selection.dbProvider
+      });
+      await applySyncProviderPreset({
+        targetDir,
+        template,
+        db: selection.db,
+        dbProvider: selection.dbProvider
+      });
+      if (!useDefaults && editorDetection.editor !== "unknown") {
+        const shouldApplyEditorPreset = await prompts.confirm(
+          `Detected ${formatEditor(editorDetection.editor)}. Add workspace recommendations for ${formatEditor(editorDetection.editor)}?`,
+          true
+        );
+        if (shouldApplyEditorPreset) {
+          const appliedPreset = await applyEditorWorkspacePreset({
+            targetDir,
+            editor: editorDetection.editor
+          });
+          if (appliedPreset.applied) {
+            logger.step(
+              `Added editor recommendations at ${relativeToTarget(targetDir, appliedPreset.filePath)}`
+            );
+          }
+        }
+      }
+      if (selection.db === "postgres" && isSyncTemplate2(template)) {
+        logger.info(
+          `Applied PostgreSQL sync preset (${formatDbProviderForLog(selection.dbProvider)}). Update DATABASE_URL in .env.example before running the sync server.`
+        );
+      }
+      if (gitContext.hasRepository) {
+        logger.step(
+          `Detected existing git repository at ${gitContext.repositoryRoot}. Skipping git initialization.`
+        );
+      }
+      logger.success("Project scaffolded");
+      if (shouldSavePreferences(preferenceFlags)) {
+        saveResolvedPreferences(preferenceStore, {
+          framework: selection.framework,
+          auth: selection.auth,
+          db: selection.db,
+          dbProvider: selection.dbProvider,
+          tailwind: selection.tailwind,
+          sync: selection.sync,
+          packageManager: pm
+        });
+      }
+      if (!args["skip-install"]) {
+        logger.step("Installing dependencies...");
+        try {
+          (0, import_node_child_process2.execSync)(getInstallCommand(pm), { cwd: targetDir, stdio: "inherit" });
+          logger.success("Dependencies installed");
+        } catch {
+          logger.warn("Failed to install dependencies. Run install manually.");
+        }
+      }
+      logger.blank();
+      logger.info("Done! Next steps:");
+      logger.blank();
+      logger.step(`  cd ${targetDir}`);
+      logger.step(`  ${getRunDevCommand(pm)}`);
+      logger.blank();
+      if (!useDefaults) {
+        prompts.outro("Project ready. Happy building with Kora!");
+      }
+    } catch (error) {
+      if (error instanceof PromptCancelledError) {
+        process.exitCode = 1;
+        return;
+      }
+      if (error instanceof Error && error.message.startsWith("Invalid --")) {
+        logger.error(error.message);
+        if (!args.yes) {
+          prompts.outro("Project creation aborted.");
+        }
+        process.exitCode = 1;
+        return;
+      }
+      throw error;
+    }
+  }
+});
+function isValidTemplate(value) {
+  return TEMPLATES.includes(value);
+}
+function isValidPackageManager(value) {
+  return PACKAGE_MANAGERS.includes(value);
+}
+function isSyncTemplate2(template) {
+  return template === "react-sync" || template === "react-tailwind-sync";
+}
+function formatDbProviderForLog(dbProvider) {
+  switch (dbProvider) {
+    case "supabase":
+      return "Supabase";
+    case "neon":
+      return "Neon";
+    case "railway":
+      return "Railway";
+    case "vercel-postgres":
+      return "Vercel Postgres";
+    case "custom":
+      return "Custom";
+    case "local":
+      return "Local Postgres";
+    case "none":
+      return "PostgreSQL";
+    default:
+      return dbProvider;
+  }
+}
+function formatEditor(editor) {
+  switch (editor) {
+    case "vscode":
+      return "VS Code";
+    case "cursor":
+      return "Cursor";
+    case "windsurf":
+      return "Windsurf";
+    case "zed":
+      return "Zed";
+    default:
+      return editor;
+  }
+}
+function formatMonorepoKind(kind) {
+  switch (kind) {
+    case "pnpm-workspace":
+      return "pnpm workspace";
+    case "npm-workspaces":
+      return "npm workspace";
+    case "turborepo":
+      return "Turborepo";
+    default:
+      return "monorepo";
+  }
+}
+function relativeToTarget(targetDir, filePath) {
+  if (filePath === null) return ".";
+  const normalizedTarget = targetDir.endsWith("/") ? targetDir : `${targetDir}/`;
+  if (filePath.startsWith(normalizedTarget)) {
+    return filePath.slice(normalizedTarget.length);
+  }
+  if (filePath === targetDir) {
+    return ".";
+  }
+  return filePath;
+}
+function resolveKoraVersion() {
+  try {
+    let dir = (0, import_node_path5.dirname)((0, import_node_url2.fileURLToPath)(import_meta2.url));
+    for (let i = 0; i < 5; i++) {
+      const pkgPath = (0, import_node_path5.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") {
+          if (pkg.version === "0.0.0") return "latest";
+          const parts = pkg.version.split(".");
+          return `^${parts[0]}.${parts[1]}.0`;
+        }
+      }
+      dir = (0, import_node_path5.dirname)(dir);
+    }
+    return "latest";
+  } catch {
+    return "latest";
+  }
+}
+
+// src/commands/deploy/deploy-command.ts
+var import_node_path14 = require("path");
+var import_citty2 = require("citty");
+
+// src/commands/deploy/adapters/adapter.ts
+var DEPLOY_PLATFORMS = ["fly", "railway", "render", "docker", "kora-cloud"];
+function isDeployPlatform(value) {
+  return DEPLOY_PLATFORMS.includes(value);
+}
+
+// src/commands/deploy/adapters/fly-adapter.ts
+var import_node_child_process4 = require("child_process");
+var import_node_path9 = require("path");
+
+// src/commands/deploy/artifacts/fly-toml-generator.ts
+var import_promises5 = require("fs/promises");
+var import_node_path6 = require("path");
+var GENERATED_HEADER = "# Generated by kora deploy \u2014 do not edit manually";
+function generateFlyToml(options) {
+  const internalPort = options.internalPort ?? 3e3;
+  return [
+    GENERATED_HEADER,
+    "",
+    `app = "${options.appName}"`,
+    `primary_region = "${options.region}"`,
+    "",
+    "[build]",
+    `  dockerfile = "Dockerfile"`,
+    "",
+    "[http_service]",
+    `  internal_port = ${String(internalPort)}`,
+    "  force_https = true",
+    '  auto_stop_machines = "stop"',
+    "  auto_start_machines = true",
+    "  min_machines_running = 0",
+    "",
+    "  [[http_service.checks]]",
+    '    grace_period = "10s"',
+    '    interval = "30s"',
+    '    method = "GET"',
+    '    timeout = "5s"',
+    '    path = "/"',
+    ""
+  ].join("\n");
+}
+async function writeFlyTomlArtifact(deployDirectory, options) {
+  await (0, import_promises5.mkdir)(deployDirectory, { recursive: true });
+  const filePath = (0, import_node_path6.join)(deployDirectory, "fly.toml");
+  await (0, import_promises5.writeFile)(filePath, generateFlyToml(options), "utf-8");
+  return filePath;
+}
+
+// src/commands/deploy/builder/client-builder.ts
+var import_node_child_process3 = require("child_process");
+var import_promises6 = require("fs/promises");
+var import_node_fs3 = require("fs");
+var import_node_path7 = require("path");
+async function buildClient(options) {
+  const viteEntryPoint = await resolveProjectBinaryEntryPoint(options.projectRoot, "vite", "vite");
+  if (!viteEntryPoint) {
+    throw new Error(
+      `Could not find local Vite binary in ${options.projectRoot}. Install dependencies before deploying.`
+    );
+  }
+  const args = [
+    viteEntryPoint,
+    "build",
+    "--outDir",
+    options.outDir,
+    "--mode",
+    options.mode ?? "production"
+  ];
+  await runProcess(process.execPath, args, options.projectRoot);
+  await patchSqliteWasmAssets(options.projectRoot, options.outDir);
+  return { outDir: options.outDir };
+}
+async function patchSqliteWasmAssets(projectRoot, outDir) {
+  const assetsDir = (0, import_node_path7.join)(outDir, "assets");
+  if (!(0, import_node_fs3.existsSync)(assetsDir)) return;
+  const files = await (0, import_promises6.readdir)(assetsDir);
+  const hashedWasm = files.find((f) => /^sqlite3-.+\.wasm$/.test(f));
+  if (hashedWasm && !files.includes("sqlite3.wasm")) {
+    await (0, import_promises6.copyFile)((0, import_node_path7.join)(assetsDir, hashedWasm), (0, import_node_path7.join)(assetsDir, "sqlite3.wasm"));
+  }
+  if (!files.includes("sqlite3-opfs-async-proxy.js")) {
+    const proxyFile = (0, import_node_path7.resolve)(
+      projectRoot,
+      "node_modules",
+      "@sqlite.org",
+      "sqlite-wasm",
+      "sqlite-wasm",
+      "jswasm",
+      "sqlite3-opfs-async-proxy.js"
+    );
+    if ((0, import_node_fs3.existsSync)(proxyFile)) {
+      await (0, import_promises6.copyFile)(proxyFile, (0, import_node_path7.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, {
+      cwd,
+      stdio: "inherit",
+      env: process.env
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve9();
+        return;
+      }
+      reject(new Error(`Client build failed with exit code ${String(code ?? "unknown")}.`));
+    });
+  });
+}
+
+// src/commands/deploy/builder/server-bundler.ts
+var import_promises7 = require("fs/promises");
+var import_promises8 = require("fs/promises");
+var import_node_path8 = require("path");
+var import_esbuild = require("esbuild");
+var DEFAULT_ENTRY_CANDIDATES = [
+  "server.ts",
+  "server.js",
+  "src/server.ts",
+  "src/server.js"
+];
+async function bundleServer(options) {
+  const candidates = options.entryFileCandidates ?? DEFAULT_ENTRY_CANDIDATES;
+  const entryFilePath = await resolveServerEntry(options.projectRoot, candidates);
+  if (!entryFilePath) {
+    throw new Error(
+      `Could not find a server entry file in ${options.projectRoot}. Looked for: ${candidates.join(", ")}`
+    );
+  }
+  await (0, import_promises7.mkdir)(options.deployDirectory, { recursive: true });
+  const outputFilePath = (0, import_node_path8.join)(options.deployDirectory, "server-bundled.js");
+  await (0, import_esbuild.build)({
+    entryPoints: [entryFilePath],
+    outfile: outputFilePath,
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    target: ["node20"],
+    sourcemap: false,
+    logLevel: "silent",
+    external: ["better-sqlite3"],
+    banner: {
+      js: "import { createRequire as __createRequire } from 'module'; const require = __createRequire(import.meta.url);"
+    }
+  });
+  return {
+    entryFilePath,
+    outputFilePath
+  };
+}
+async function resolveServerEntry(projectRoot, candidates) {
+  for (const candidate of candidates) {
+    const fullPath = (0, import_node_path8.join)(projectRoot, candidate);
+    try {
+      await (0, import_promises8.access)(fullPath);
+      return fullPath;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/commands/deploy/adapters/fly-adapter.ts
+var FlyAdapter = class {
+  name = "fly";
+  logger = createLogger();
+  runner;
+  commandCandidates;
+  flyCommand = null;
+  currentContext;
+  lastDeploymentId = null;
+  constructor(options = {}) {
+    this.runner = options.runner ?? new NodeFlyCommandRunner();
+    this.commandCandidates = options.commandCandidates ?? DEFAULT_FLY_COMMAND_CANDIDATES;
+    this.currentContext = options.context ?? null;
+  }
+  /**
+   * Seeds runtime context for non-provisioning commands.
+   */
+  setContext(context) {
+    this.currentContext = context;
+  }
+  /**
+   * Checks whether a Fly CLI executable can be resolved.
+   */
+  async detect() {
+    const command = await this.tryResolveFlyCommand(process.cwd());
+    return command !== null;
+  }
+  /**
+   * Ensures Fly CLI is available before deployment.
+   */
+  async install() {
+    const available = await this.detect();
+    if (!available) {
+      throw new Error(
+        "Fly CLI is required but not installed. Install from https://fly.io/docs/hands-on/install-flyctl/."
+      );
+    }
+  }
+  /**
+   * Performs Fly authentication check/login.
+   */
+  async authenticate() {
+    const projectRoot = this.currentContext?.projectRoot ?? process.cwd();
+    const status = await this.runFlyCommand(["auth", "whoami", "--json"], projectRoot, false);
+    if (status.exitCode === 0) return;
+    const login = await this.runFlyCommand(["auth", "login"], projectRoot, true);
+    if (login.exitCode !== 0) {
+      throw new Error(`Fly authentication failed: ${normalizeError(login.stderr, login.stdout)}`);
+    }
+  }
+  /**
+   * Provisions app and optionally region-bound resources in Fly.
+   */
+  async provision(config) {
+    this.currentContext = {
+      projectRoot: config.projectRoot,
+      appName: config.appName,
+      region: config.region ?? "iad"
+    };
+    const appCreateArgs = ["apps", "create", config.appName];
+    const createApp = await this.runFlyCommand(appCreateArgs, config.projectRoot, false);
+    if (createApp.exitCode !== 0 && !isAlreadyExistsResponse(createApp.stderr, createApp.stdout)) {
+      throw new Error(
+        `Fly app provisioning failed for "${config.appName}": ${normalizeError(createApp.stderr, createApp.stdout)}`
+      );
+    }
+    const secrets = [];
+    const portSecret = await this.runFlyCommand(
+      ["secrets", "set", "PORT=3000", "--app", config.appName],
+      config.projectRoot,
+      false
+    );
+    if (portSecret.exitCode === 0) {
+      secrets.push("PORT");
+    }
+    return {
+      applicationId: config.appName,
+      databaseId: null,
+      secretsSet: secrets
+    };
+  }
+  /**
+   * Builds local artifacts consumed by Fly deploy.
+   */
+  async build(config) {
+    this.currentContext = {
+      projectRoot: config.projectRoot,
+      appName: config.appName,
+      region: config.region
+    };
+    const deployDirectory = (0, import_node_path9.join)(config.projectRoot, ".kora", "deploy");
+    await writeFlyTomlArtifact(deployDirectory, {
+      appName: config.appName,
+      region: config.region ?? "iad"
+    });
+    await bundleServer({
+      projectRoot: config.projectRoot,
+      deployDirectory
+    });
+    const client = await buildClient({
+      projectRoot: config.projectRoot,
+      outDir: (0, import_node_path9.join)(deployDirectory, "dist"),
+      mode: "production"
+    });
+    return {
+      clientDirectory: client.outDir,
+      serverBundlePath: (0, import_node_path9.join)(deployDirectory, "server-bundled.js"),
+      deployDirectory
+    };
+  }
+  /**
+   * Deploys generated artifacts to Fly and returns live endpoints.
+   */
+  async deploy(artifacts) {
+    const context = this.requireContext();
+    const deploy = await this.runFlyCommand(
+      ["deploy", "--config", "fly.toml", "--app", context.appName],
+      artifacts.deployDirectory,
+      true
+    );
+    if (deploy.exitCode !== 0) {
+      throw new Error(`Fly deployment failed: ${normalizeError(deploy.stderr, deploy.stdout)}`);
+    }
+    const info = await this.runFlyCommand(
+      ["status", "--app", context.appName, "--json"],
+      context.projectRoot,
+      false
+    );
+    const hostname = parseFlyHostname(info.stdout) ?? `${context.appName}.fly.dev`;
+    const deploymentId = parseFlyDeploymentId(info.stdout) ?? (/* @__PURE__ */ new Date()).toISOString();
+    this.lastDeploymentId = deploymentId;
+    return {
+      deploymentId,
+      liveUrl: `https://${hostname}`,
+      syncUrl: `wss://${hostname}/kora-sync`
+    };
+  }
+  /**
+   * Rolls back to a deployment version.
+   */
+  async rollback(deploymentId) {
+    const context = this.requireContext();
+    const rollback = await this.runFlyCommand(
+      ["releases", "revert", deploymentId, "--app", context.appName],
+      context.projectRoot,
+      true
+    );
+    if (rollback.exitCode !== 0) {
+      throw new Error(`Fly rollback failed: ${normalizeError(rollback.stderr, rollback.stdout)}`);
+    }
+  }
+  /**
+   * Returns deployment logs as an async iterable.
+   */
+  async *logs(options) {
+    const context = this.requireContext();
+    const args = ["logs", "--app", context.appName, "--no-tail"];
+    if (typeof options.since === "string" && options.since.length > 0) {
+      args.push("--region", options.since);
+    }
+    const result = await this.runFlyCommand(args, context.projectRoot, false);
+    if (result.exitCode !== 0) {
+      throw new Error(`Fly logs failed: ${normalizeError(result.stderr, result.stdout)}`);
+    }
+    const lines = result.stdout.split(/\r?\n/).filter((line) => line.length > 0);
+    for (const line of lines) {
+      yield {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level: inferLogLevel(line),
+        message: line
+      };
+    }
+  }
+  /**
+   * Reads current deployment status from Fly.
+   */
+  async status() {
+    const context = this.requireContext();
+    const status = await this.runFlyCommand(
+      ["status", "--app", context.appName, "--json"],
+      context.projectRoot,
+      false
+    );
+    if (status.exitCode !== 0) {
+      return {
+        state: "failed",
+        message: normalizeError(status.stderr, status.stdout)
+      };
+    }
+    const hostname = parseFlyHostname(status.stdout);
+    return {
+      state: "healthy",
+      message: "Fly deployment is healthy.",
+      liveUrl: hostname ? `https://${hostname}` : void 0
+    };
+  }
+  async runFlyCommand(flyArgs, cwd, inheritOutput) {
+    const flyBinary = await this.resolveFlyCommand(cwd);
+    if (inheritOutput) {
+      this.logger.step(`fly ${flyArgs.join(" ")}`);
+    }
+    return await this.runner.run(flyBinary, flyArgs, cwd);
+  }
+  requireContext() {
+    if (!this.currentContext) {
+      throw new Error("Fly adapter context is not initialized. Run provision() first.");
+    }
+    return this.currentContext;
+  }
+  async resolveFlyCommand(cwd) {
+    if (this.flyCommand) {
+      return this.flyCommand;
+    }
+    const resolved = await this.tryResolveFlyCommand(cwd);
+    if (!resolved) {
+      throw new Error("Could not resolve a usable Fly CLI command (tried flyctl, fly).");
+    }
+    this.flyCommand = resolved;
+    return resolved;
+  }
+  async tryResolveFlyCommand(cwd) {
+    for (const command of this.commandCandidates) {
+      const versionCheck = await this.runner.run(command, ["version"], cwd);
+      if (versionCheck.exitCode === 0) {
+        return command;
+      }
+    }
+    return null;
+  }
+};
+var NodeFlyCommandRunner = class {
+  async run(command, args, cwd) {
+    return await new Promise((resolve9) => {
+      const child = (0, import_node_child_process4.spawn)(command, args, {
+        cwd,
+        env: process.env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      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) => {
+        resolve9({
+          exitCode: 1,
+          stdout,
+          stderr: `${stderr}
+${error.message}`
+        });
+      });
+      child.on("exit", (code) => {
+        resolve9({
+          exitCode: code ?? 1,
+          stdout: stdout.trim(),
+          stderr: stderr.trim()
+        });
+      });
+    });
+  }
+};
+var DEFAULT_FLY_COMMAND_CANDIDATES = ["flyctl", "fly"];
+function parseFlyHostname(rawJson) {
+  const parsed = parseJsonRecord(rawJson);
+  if (!parsed) return null;
+  const hostname = parsed.Hostname;
+  if (typeof hostname === "string" && hostname.length > 0) {
+    return hostname;
+  }
+  const hostnames = parsed.Hostnames;
+  if (Array.isArray(hostnames)) {
+    const first = hostnames.find((item) => typeof item === "string");
+    if (typeof first === "string" && first.length > 0) {
+      return first;
+    }
+  }
+  return null;
+}
+function parseFlyDeploymentId(rawJson) {
+  const parsed = parseJsonRecord(rawJson);
+  if (!parsed) return null;
+  const deploymentId = parsed.DeploymentID;
+  if (typeof deploymentId === "string" && deploymentId.length > 0) {
+    return deploymentId;
+  }
+  const latestDeployment = parsed.LatestDeployment;
+  if (typeof latestDeployment === "object" && latestDeployment !== null) {
+    const id = latestDeployment.ID;
+    if (typeof id === "string" && id.length > 0) {
+      return id;
+    }
+  }
+  return null;
+}
+function parseJsonRecord(value) {
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function inferLogLevel(line) {
+  const normalized = line.toLowerCase();
+  if (normalized.includes("error")) return "error";
+  if (normalized.includes("warn")) return "warn";
+  if (normalized.includes("debug")) return "debug";
+  return "info";
+}
+function normalizeError(stderr, stdout) {
+  if (stderr.length > 0) return stderr;
+  if (stdout.length > 0) return stdout;
+  return "unknown fly CLI error";
+}
+function isAlreadyExistsResponse(stderr, stdout) {
+  const text = `${stderr}
+${stdout}`.toLowerCase();
+  return text.includes("already exists") || text.includes("already been taken");
+}
+
+// src/commands/deploy/adapters/railway-adapter.ts
+var import_node_child_process5 = require("child_process");
+var import_node_path11 = require("path");
+
+// src/commands/deploy/artifacts/railway-json-generator.ts
+var import_promises9 = require("fs/promises");
+var import_node_path10 = require("path");
+var GENERATED_HEADER2 = "Generated by kora deploy - do not edit manually.";
+function generateRailwayJson(options) {
+  const file = {
+    $schema: "https://railway.app/railway.schema.json",
+    build: {
+      builder: "DOCKERFILE",
+      dockerfilePath: "Dockerfile"
+    },
+    deploy: {
+      startCommand: options.startCommand ?? "node ./server-bundled.js",
+      healthcheckPath: options.healthcheckPath ?? "/health",
+      restartPolicyType: "on_failure",
+      restartPolicyMaxRetries: 3
+    },
+    metadata: {
+      generatedBy: GENERATED_HEADER2,
+      appName: options.appName,
+      region: options.region
+    }
+  };
+  return `${JSON.stringify(file, null, 2)}
+`;
+}
+async function writeRailwayJsonArtifact(deployDirectory, options) {
+  await (0, import_promises9.mkdir)(deployDirectory, { recursive: true });
+  const filePath = (0, import_node_path10.join)(deployDirectory, "railway.json");
+  await (0, import_promises9.writeFile)(filePath, generateRailwayJson(options), "utf-8");
+  return filePath;
+}
+
+// src/commands/deploy/adapters/railway-adapter.ts
+var RailwayAdapter = class {
+  name = "railway";
+  logger = createLogger();
+  runner;
+  commandCandidates;
+  railwayCommand = null;
+  currentContext;
+  lastDeploymentId = null;
+  constructor(options = {}) {
+    this.runner = options.runner ?? new NodeRailwayCommandRunner();
+    this.commandCandidates = options.commandCandidates ?? DEFAULT_RAILWAY_COMMAND_CANDIDATES;
+    this.currentContext = options.context ?? null;
+  }
+  setContext(context) {
+    this.currentContext = context;
+  }
+  async detect() {
+    const command = await this.tryResolveRailwayCommand(process.cwd());
+    return command !== null;
+  }
+  async install() {
+    const available = await this.detect();
+    if (!available) {
+      throw new Error(
+        "Railway CLI is required but not installed. Install with `npm i -g @railway/cli` or see https://docs.railway.com/guides/cli."
+      );
+    }
+  }
+  async authenticate() {
+    const projectRoot = this.currentContext?.projectRoot ?? process.cwd();
+    const whoami = await this.runRailwayCommand(["whoami"], projectRoot, false);
+    if (whoami.exitCode === 0) return;
+    const login = await this.runRailwayCommand(["login"], projectRoot, true);
+    if (login.exitCode !== 0) {
+      throw new Error(
+        `Railway authentication failed: ${normalizeError2(login.stderr, login.stdout)}`
+      );
+    }
+  }
+  async provision(config) {
+    this.currentContext = {
+      projectRoot: config.projectRoot,
+      appName: config.appName,
+      region: config.region
+    };
+    const init = await this.runRailwayCommand(
+      ["init", "--name", config.appName, "--confirm"],
+      config.projectRoot,
+      false
+    );
+    if (init.exitCode !== 0 && !isAlreadyExistsResponse2(init.stderr, init.stdout)) {
+      throw new Error(
+        `Railway project provisioning failed for "${config.appName}": ${normalizeError2(init.stderr, init.stdout)}`
+      );
+    }
+    const link = await this.runRailwayCommand(
+      ["link", "--project", config.appName, "--environment", config.environment, "--yes"],
+      config.projectRoot,
+      false
+    );
+    if (link.exitCode !== 0 && !isAlreadyExistsResponse2(link.stderr, link.stdout)) {
+      throw new Error(`Railway link failed: ${normalizeError2(link.stderr, link.stdout)}`);
+    }
+    const vars = [];
+    const setPort = await this.runRailwayCommand(
+      ["variables", "set", "PORT=3000", "--yes"],
+      config.projectRoot,
+      false
+    );
+    if (setPort.exitCode === 0) {
+      vars.push("PORT");
+    }
+    return {
+      applicationId: config.appName,
+      databaseId: null,
+      secretsSet: vars
+    };
+  }
+  async build(config) {
+    this.currentContext = {
+      projectRoot: config.projectRoot,
+      appName: config.appName,
+      region: config.region
+    };
+    const deployDirectory = (0, import_node_path11.join)(config.projectRoot, ".kora", "deploy");
+    await writeRailwayJsonArtifact(deployDirectory, {
+      appName: config.appName,
+      environment: config.environment
+    });
+    await bundleServer({
+      projectRoot: config.projectRoot,
+      deployDirectory
+    });
+    const client = await buildClient({
+      projectRoot: config.projectRoot,
+      outDir: (0, import_node_path11.join)(deployDirectory, "dist"),
+      mode: "production"
+    });
+    return {
+      clientDirectory: client.outDir,
+      serverBundlePath: (0, import_node_path11.join)(deployDirectory, "server-bundled.js"),
+      deployDirectory
+    };
+  }
+  async deploy(artifacts) {
+    const context = this.requireContext();
+    const up = await this.runRailwayCommand(["up", "--yes"], artifacts.deployDirectory, true);
+    if (up.exitCode !== 0) {
+      throw new Error(`Railway deployment failed: ${normalizeError2(up.stderr, up.stdout)}`);
+    }
+    const status = await this.runRailwayCommand(["status", "--json"], context.projectRoot, false);
+    const deploymentId = parseRailwayDeploymentId(status.stdout) ?? (/* @__PURE__ */ new Date()).toISOString();
+    const liveUrl = parseRailwayUrl(status.stdout) ?? `https://${context.appName}.up.railway.app`;
+    this.lastDeploymentId = deploymentId;
+    return {
+      deploymentId,
+      liveUrl,
+      syncUrl: toSyncUrl(liveUrl)
+    };
+  }
+  async rollback(deploymentId) {
+    const context = this.requireContext();
+    const rollback = await this.runRailwayCommand(
+      ["redeploy", "--deployment", deploymentId, "--yes"],
+      context.projectRoot,
+      true
+    );
+    if (rollback.exitCode !== 0) {
+      throw new Error(
+        `Railway rollback failed: ${normalizeError2(rollback.stderr, rollback.stdout)}`
+      );
+    }
+  }
+  async *logs(options) {
+    const context = this.requireContext();
+    const args = ["logs"];
+    if (typeof options.tail === "number" && options.tail > 0) {
+      args.push("--lines", String(options.tail));
+    }
+    const result = await this.runRailwayCommand(args, context.projectRoot, false);
+    if (result.exitCode !== 0) {
+      throw new Error(`Railway logs failed: ${normalizeError2(result.stderr, result.stdout)}`);
+    }
+    const lines = result.stdout.split(/\r?\n/).filter((line) => line.length > 0);
+    for (const line of lines) {
+      yield {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level: inferLogLevel2(line),
+        message: line
+      };
+    }
+  }
+  async status() {
+    const context = this.requireContext();
+    const status = await this.runRailwayCommand(["status", "--json"], context.projectRoot, false);
+    if (status.exitCode !== 0) {
+      return {
+        state: "failed",
+        message: normalizeError2(status.stderr, status.stdout)
+      };
+    }
+    const liveUrl = parseRailwayUrl(status.stdout);
+    return {
+      state: "healthy",
+      message: "Railway deployment is healthy.",
+      liveUrl: liveUrl ?? void 0
+    };
+  }
+  async runRailwayCommand(railwayArgs, cwd, inheritOutput) {
+    const command = await this.resolveRailwayCommand(cwd);
+    if (inheritOutput) {
+      this.logger.step(`railway ${railwayArgs.join(" ")}`);
+    }
+    return await this.runner.run(command, railwayArgs, cwd);
+  }
+  requireContext() {
+    if (!this.currentContext) {
+      throw new Error("Railway adapter context is not initialized. Run provision() first.");
+    }
+    return this.currentContext;
+  }
+  async resolveRailwayCommand(cwd) {
+    if (this.railwayCommand) {
+      return this.railwayCommand;
+    }
+    const resolved = await this.tryResolveRailwayCommand(cwd);
+    if (!resolved) {
+      throw new Error("Could not resolve a usable Railway CLI command (tried railway).");
+    }
+    this.railwayCommand = resolved;
+    return resolved;
+  }
+  async tryResolveRailwayCommand(cwd) {
+    for (const command of this.commandCandidates) {
+      const version = await this.runner.run(command, ["--version"], cwd);
+      if (version.exitCode === 0) {
+        return command;
+      }
+    }
+    return null;
+  }
+};
+var NodeRailwayCommandRunner = class {
+  async run(command, args, cwd) {
+    return await new Promise((resolve9) => {
+      const child = (0, import_node_child_process5.spawn)(command, args, {
+        cwd,
+        env: process.env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      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) => {
+        resolve9({
+          exitCode: 1,
+          stdout,
+          stderr: `${stderr}
+${error.message}`
+        });
+      });
+      child.on("exit", (code) => {
+        resolve9({
+          exitCode: code ?? 1,
+          stdout: stdout.trim(),
+          stderr: stderr.trim()
+        });
+      });
+    });
+  }
+};
+var DEFAULT_RAILWAY_COMMAND_CANDIDATES = ["railway"];
+function parseRailwayUrl(rawJson) {
+  const record = parseJsonRecord2(rawJson);
+  if (!record) return null;
+  const url = record.url;
+  if (typeof url === "string" && url.length > 0) {
+    return ensureHttpsUrl(url);
+  }
+  const service = record.service;
+  if (typeof service === "object" && service !== null) {
+    const domain = service.domain;
+    if (typeof domain === "string" && domain.length > 0) {
+      return ensureHttpsUrl(domain);
+    }
+  }
+  return null;
+}
+function parseRailwayDeploymentId(rawJson) {
+  const record = parseJsonRecord2(rawJson);
+  if (!record) return null;
+  const deploymentId = record.deploymentId;
+  if (typeof deploymentId === "string" && deploymentId.length > 0) {
+    return deploymentId;
+  }
+  const deployment = record.deployment;
+  if (typeof deployment === "object" && deployment !== null) {
+    const id = deployment.id;
+    if (typeof id === "string" && id.length > 0) {
+      return id;
+    }
+  }
+  return null;
+}
+function parseJsonRecord2(value) {
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function toSyncUrl(liveUrl) {
+  try {
+    const url = new URL(liveUrl);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    url.pathname = "/kora-sync";
+    return url.toString().replace(/\/$/, "");
+  } catch {
+    return null;
+  }
+}
+function ensureHttpsUrl(value) {
+  if (value.startsWith("http://") || value.startsWith("https://")) {
+    return value;
+  }
+  return `https://${value}`;
+}
+function inferLogLevel2(line) {
+  const normalized = line.toLowerCase();
+  if (normalized.includes("error")) return "error";
+  if (normalized.includes("warn")) return "warn";
+  if (normalized.includes("debug")) return "debug";
+  return "info";
+}
+function normalizeError2(stderr, stdout) {
+  if (stderr.length > 0) return stderr;
+  if (stdout.length > 0) return stdout;
+  return "unknown railway CLI error";
+}
+function isAlreadyExistsResponse2(stderr, stdout) {
+  const text = `${stderr}
+${stdout}`.toLowerCase();
+  return text.includes("already exists");
+}
+
+// src/commands/deploy/adapters/stub-adapter.ts
+var StubDeployAdapter = class {
+  name;
+  contextLabel;
+  constructor(platform) {
+    this.name = platform;
+    this.contextLabel = `Deploy adapter "${platform}" is not implemented yet.`;
+  }
+  setContext(_context) {
+  }
+  async detect() {
+    return false;
+  }
+  async install() {
+    throw this.notImplementedError();
+  }
+  async authenticate() {
+    throw this.notImplementedError();
+  }
+  async provision(_config) {
+    throw this.notImplementedError();
+  }
+  async build(_config) {
+    throw this.notImplementedError();
+  }
+  async deploy(_artifacts) {
+    throw this.notImplementedError();
+  }
+  async rollback(_deploymentId) {
+    throw this.notImplementedError();
+  }
+  logs(_options) {
+    throw this.notImplementedError();
+  }
+  async status() {
+    return {
+      state: "unknown",
+      message: this.notImplementedMessage()
     };
-    ask();
-  });
+  }
+  notImplementedError() {
+    return new Error(this.notImplementedMessage());
+  }
+  notImplementedMessage() {
+    return `${this.contextLabel} Start with --platform fly for now.`;
+  }
+};
+
+// src/commands/deploy/adapters/factory.ts
+function createDeployAdapter(platform) {
+  switch (platform) {
+    case "fly":
+      return new FlyAdapter();
+    case "railway":
+      return new RailwayAdapter();
+    case "render":
+    case "docker":
+    case "kora-cloud":
+      return new StubDeployAdapter(platform);
+    default: {
+      const exhaustiveCheck = platform;
+      return exhaustiveCheck;
+    }
+  }
 }
-function createReadline(options) {
-  return (0, import_node_readline.createInterface)({
-    input: options?.input ?? process.stdin,
-    output: options?.output ?? process.stdout
-  });
+
+// src/commands/deploy/artifacts/dockerfile-generator.ts
+var import_promises10 = require("fs/promises");
+var import_node_path12 = 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 serverBundleFile = options.serverBundleFile ?? "server-bundled.js";
+  const hasNativeDeps = options.nativeDependencies && Object.keys(options.nativeDependencies).length > 0;
+  const lines = [
+    GENERATED_HEADER3,
+    "",
+    `FROM node:${nodeVersion} AS runtime`,
+    "WORKDIR /app",
+    "ENV NODE_ENV=production",
+    `ENV PORT=${String(port)}`,
+    ""
+  ];
+  if (hasNativeDeps) {
+    lines.push("# Install build tools for native modules");
+    lines.push("RUN apk add --no-cache python3 make g++");
+    lines.push("");
+    lines.push("COPY package.json ./package.json");
+    lines.push("RUN npm install --omit=dev");
+    lines.push("");
+  }
+  lines.push(`COPY ${clientDirectory} ./dist`);
+  lines.push(`COPY ${serverBundleFile} ./server-bundled.js`);
+  lines.push("");
+  lines.push(`EXPOSE ${String(port)}`);
+  lines.push('CMD ["node", "./server-bundled.js"]');
+  lines.push("");
+  return lines.join("\n");
+}
+function generateDeployPackageJson(nativeDependencies) {
+  const pkg = {
+    name: "kora-deploy",
+    version: "1.0.0",
+    private: true,
+    type: "module",
+    dependencies: nativeDependencies
+  };
+  return JSON.stringify(pkg, null, 2) + "\n";
+}
+function generateDockerIgnore() {
+  return [
+    GENERATED_HEADER3,
+    "",
+    "node_modules",
+    "npm-debug.log*",
+    "pnpm-debug.log*",
+    "yarn-error.log*",
+    ".env",
+    ".env.*",
+    ".git",
+    ".gitignore",
+    "coverage",
+    ".turbo",
+    "*.test.ts",
+    "*.spec.ts",
+    ""
+  ].join("\n");
+}
+async function writeDockerfileArtifact(deployDirectory, options = {}) {
+  await (0, import_promises10.mkdir)(deployDirectory, { recursive: true });
+  const dockerfilePath = (0, import_node_path12.join)(deployDirectory, "Dockerfile");
+  await (0, import_promises10.writeFile)(dockerfilePath, generateDockerfile(options), "utf-8");
+  if (options.nativeDependencies && Object.keys(options.nativeDependencies).length > 0) {
+    const pkgJsonPath = (0, import_node_path12.join)(deployDirectory, "package.json");
+    await (0, import_promises10.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_path12.join)(deployDirectory, ".dockerignore");
+  await (0, import_promises10.writeFile)(dockerIgnorePath, generateDockerIgnore(), "utf-8");
+  return dockerIgnorePath;
 }
 
-// src/commands/create/template-engine.ts
-var import_node_fs = require("fs");
-var import_promises2 = require("fs/promises");
-var import_node_path2 = require("path");
-var import_node_url = require("url");
-var import_meta = {};
-function substituteVariables(template, context) {
-  return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
-    const value = context[key];
-    return value !== void 0 ? value : `{{${key}}}`;
-  });
+// src/commands/deploy/state/deploy-state.ts
+var import_promises11 = require("fs/promises");
+var import_node_path13 = require("path");
+var KORA_DEPLOY_DIRECTORY = (0, import_node_path13.join)(".kora", "deploy");
+var DEPLOY_STATE_FILENAME = "deploy.json";
+function resolveDeployDirectory(projectRoot) {
+  return (0, import_node_path13.join)(projectRoot, KORA_DEPLOY_DIRECTORY);
 }
-function getTemplatePath(templateName) {
-  let dir = (0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
-  for (let i = 0; i < 5; i++) {
-    if ((0, import_node_fs.existsSync)((0, import_node_path2.resolve)(dir, "templates"))) {
-      return (0, import_node_path2.resolve)(dir, "templates", templateName);
-    }
-    dir = (0, import_node_path2.dirname)(dir);
+function resolveDeployStatePath(projectRoot) {
+  return (0, import_node_path13.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 parsed = JSON.parse(source);
+    return parseDeployState(parsed);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") return null;
+    throw error;
   }
-  const currentDir = (0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
-  return (0, import_node_path2.resolve)(currentDir, "..", "templates", templateName);
 }
-async function scaffoldTemplate(templateName, targetDir, context) {
-  const templateDir = getTemplatePath(templateName);
-  const vars = {
-    projectName: context.projectName,
-    packageManager: context.packageManager,
-    koraVersion: context.koraVersion
+async function writeDeployState(projectRoot, input, now = /* @__PURE__ */ new Date()) {
+  const timestamp = now.toISOString();
+  const state = {
+    platform: input.platform,
+    appName: input.appName,
+    region: input.region,
+    projectRoot: input.projectRoot,
+    liveUrl: input.liveUrl ?? null,
+    syncUrl: input.syncUrl ?? null,
+    databaseId: input.databaseId ?? null,
+    lastDeploymentId: input.lastDeploymentId ?? null,
+    createdAt: timestamp,
+    updatedAt: timestamp
   };
-  await copyDirectory(templateDir, targetDir, vars);
+  await persistDeployState(projectRoot, state);
+  return state;
 }
-async function copyDirectory(src, dest, vars) {
-  await (0, import_promises2.mkdir)(dest, { recursive: true });
-  const entries = await (0, import_promises2.readdir)(src);
-  for (const entry of entries) {
-    const srcPath = (0, import_node_path2.join)(src, entry);
-    const srcStat = await (0, import_promises2.stat)(srcPath);
-    if (srcStat.isDirectory()) {
-      await copyDirectory(srcPath, (0, import_node_path2.join)(dest, entry), vars);
-    } else if (entry.endsWith(".hbs")) {
-      const content = await (0, import_promises2.readFile)(srcPath, "utf-8");
-      const outputName = entry.slice(0, -4);
-      await (0, import_promises2.writeFile)((0, import_node_path2.join)(dest, outputName), substituteVariables(content, vars), "utf-8");
-    } else {
-      await (0, import_promises2.copyFile)(srcPath, (0, import_node_path2.join)(dest, entry));
-    }
+async function updateDeployState(projectRoot, patch, now = /* @__PURE__ */ new Date()) {
+  const existing = await readDeployState(projectRoot);
+  if (!existing) {
+    throw new Error("Cannot update deploy state because deploy.json does not exist yet.");
   }
+  const nextState = {
+    platform: patch.platform ?? existing.platform,
+    appName: patch.appName ?? existing.appName,
+    region: patch.region === void 0 ? existing.region : patch.region,
+    projectRoot: patch.projectRoot ?? existing.projectRoot,
+    liveUrl: patch.liveUrl === void 0 ? existing.liveUrl : patch.liveUrl,
+    syncUrl: patch.syncUrl === void 0 ? existing.syncUrl : patch.syncUrl,
+    databaseId: patch.databaseId === void 0 ? existing.databaseId : patch.databaseId,
+    lastDeploymentId: patch.lastDeploymentId === void 0 ? existing.lastDeploymentId : patch.lastDeploymentId,
+    createdAt: existing.createdAt,
+    updatedAt: now.toISOString()
+  };
+  await persistDeployState(projectRoot, nextState);
+  return nextState;
+}
+async function resetDeployState(projectRoot) {
+  await (0, import_promises11.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)}
+`, "utf-8");
+}
+function parseDeployState(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("Invalid deploy state: expected an object.");
+  }
+  const record = value;
+  const platform = readPlatform(record.platform);
+  const appName = readString(record.appName, "appName");
+  const region = readOptionalString(record.region, "region");
+  const projectRoot = readString(record.projectRoot, "projectRoot");
+  const liveUrl = readOptionalString(record.liveUrl, "liveUrl");
+  const syncUrl = readOptionalString(record.syncUrl, "syncUrl");
+  const databaseId = readOptionalString(record.databaseId, "databaseId");
+  const lastDeploymentId = readOptionalString(record.lastDeploymentId, "lastDeploymentId");
+  const createdAt = readString(record.createdAt, "createdAt");
+  const updatedAt = readString(record.updatedAt, "updatedAt");
+  return {
+    platform,
+    appName,
+    region,
+    projectRoot,
+    liveUrl,
+    syncUrl,
+    databaseId,
+    lastDeploymentId,
+    createdAt,
+    updatedAt
+  };
+}
+function readPlatform(value) {
+  if (typeof value !== "string" || !isDeployPlatform(value)) {
+    throw new Error('Invalid deploy state: "platform" must be a supported platform.');
+  }
+  return value;
+}
+function readString(value, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Invalid deploy state: "${field}" must be a non-empty string.`);
+  }
+  return value;
+}
+function readOptionalString(value, field) {
+  if (value === null) return null;
+  if (typeof value === "string") return value;
+  throw new Error(`Invalid deploy state: "${field}" must be a string or null.`);
 }
 
-// src/commands/create/create-command.ts
-var import_meta2 = {};
-var createCommand = (0, import_citty.defineCommand)({
+// src/commands/deploy/deploy-command.ts
+var deployCommand = (0, import_citty2.defineCommand)({
   meta: {
-    name: "create",
-    description: "Create a new Kora application"
+    name: "deploy",
+    description: "Deploy a Kora project to your selected platform"
   },
   args: {
-    name: {
-      type: "positional",
-      description: "Project directory name",
-      required: false
+    platform: {
+      type: "string",
+      description: `Deployment platform (${DEPLOY_PLATFORMS.join(", ")})`
     },
-    template: {
+    app: {
       type: "string",
-      description: "Project template (react-tailwind-sync, react-tailwind, react-sync, react-basic)"
+      description: "Application name used by the target platform"
     },
-    pm: {
+    region: {
       type: "string",
-      description: "Package manager (pnpm, npm, yarn, bun)"
+      description: "Preferred deployment region (for example: iad, lhr, syd)"
     },
-    "skip-install": {
+    prod: {
       type: "boolean",
-      description: "Skip installing dependencies",
+      description: "Deploy to production environment",
       default: false
     },
-    yes: {
+    confirm: {
       type: "boolean",
-      alias: "y",
-      description: "Accept all defaults (react-tailwind-sync + detected package manager)",
+      description: "Non-interactive mode (fail fast on missing required data)",
       default: false
     },
-    tailwind: {
-      type: "boolean",
-      description: "Use Tailwind CSS (use --no-tailwind to skip)"
-    },
-    sync: {
+    reset: {
       type: "boolean",
-      description: "Include sync server (use --no-sync to skip)"
+      description: "Delete .kora/deploy state and generated artifacts",
+      default: false
     }
   },
-  async run({ args }) {
+  subCommands: {
+    status: (0, import_citty2.defineCommand)({
+      meta: {
+        name: "status",
+        description: "Show current deployment status"
+      },
+      async run() {
+        const logger = createLogger();
+        const projectRoot = await requireProjectRoot();
+        const state = await readDeployState(projectRoot);
+        if (!state) {
+          logger.warn("No deployment state found. Run `kora deploy` first.");
+          return;
+        }
+        logger.banner();
+        logger.info(`Platform: ${state.platform}`);
+        logger.step(`App: ${state.appName}`);
+        logger.step(`Region: ${state.region ?? "n/a"}`);
+        logger.step(`Last deployment: ${state.lastDeploymentId ?? "n/a"}`);
+        const adapter = createDeployAdapter(state.platform);
+        configureAdapterContext(adapter, {
+          projectRoot,
+          appName: state.appName,
+          region: state.region
+        });
+        const adapterStatus = await adapter.status();
+        logger.step(`Status: ${adapterStatus.state}`);
+        logger.step(`Message: ${adapterStatus.message}`);
+        logger.step(`Live URL: ${adapterStatus.liveUrl ?? state.liveUrl ?? "n/a"}`);
+        logger.step(`Sync URL: ${state.syncUrl ?? "n/a"}`);
+      }
+    }),
+    rollback: (0, import_citty2.defineCommand)({
+      meta: {
+        name: "rollback",
+        description: "Rollback the current deployment"
+      },
+      args: {
+        id: {
+          type: "positional",
+          description: "Optional deployment identifier",
+          required: false
+        }
+      },
+      async run({ args }) {
+        const logger = createLogger();
+        const projectRoot = await requireProjectRoot();
+        const state = await readDeployState(projectRoot);
+        if (!state) {
+          logger.warn("No deployment state found. Run `kora deploy` first.");
+          return;
+        }
+        const adapter = createDeployAdapter(state.platform);
+        configureAdapterContext(adapter, {
+          projectRoot,
+          appName: state.appName,
+          region: state.region
+        });
+        const deploymentId = typeof args.id === "string" && args.id.length > 0 ? args.id : state.lastDeploymentId ?? "latest";
+        await adapter.rollback(deploymentId);
+        logger.success(`Rolled back ${state.platform} deployment to ${deploymentId}.`);
+      }
+    }),
+    logs: (0, import_citty2.defineCommand)({
+      meta: {
+        name: "logs",
+        description: "Read deployment logs"
+      },
+      async run() {
+        const logger = createLogger();
+        const projectRoot = await requireProjectRoot();
+        const state = await readDeployState(projectRoot);
+        if (!state) {
+          logger.warn("No deployment state found. Run `kora deploy` first.");
+          return;
+        }
+        const adapter = createDeployAdapter(state.platform);
+        configureAdapterContext(adapter, {
+          projectRoot,
+          appName: state.appName,
+          region: state.region
+        });
+        const logLines = adapter.logs({ tail: 200 });
+        let hasLines = false;
+        for await (const line of logLines) {
+          hasLines = true;
+          logger.step(`[${line.level}] ${line.message}`);
+        }
+        if (!hasLines) {
+          logger.warn(`No logs returned from ${state.platform}.`);
+        }
+      }
+    })
+  },
+  async run({ args, rawArgs }) {
+    const subCommandNames = ["status", "rollback", "logs"];
+    if (rawArgs.some((arg) => subCommandNames.includes(arg))) {
+      return;
+    }
     const logger = createLogger();
-    logger.banner();
-    const useDefaults = args.yes === true;
-    const projectName = args.name || (useDefaults ? "my-kora-app" : await promptText("Project name", "my-kora-app"));
-    if (!projectName) {
-      logger.error("Project name is required");
-      process.exitCode = 1;
+    const prompts = createPromptClient();
+    const projectRoot = await requireProjectRoot();
+    if (args.reset === true) {
+      await resetDeployState(projectRoot);
+      logger.success("Reset .kora/deploy state.");
       return;
     }
-    let template;
-    if (args.template && isValidTemplate(args.template)) {
-      template = args.template;
-    } else if (useDefaults) {
-      template = "react-tailwind-sync";
-    } else if (args.tailwind !== void 0 || args.sync !== void 0) {
-      template = resolveTemplateFromFlags(args.tailwind, args.sync);
-    } else {
-      template = await promptSelect(
-        "Select a template:",
-        TEMPLATE_INFO.map((t) => ({ label: `${t.label} \u2014 ${t.description}`, value: t.name }))
-      );
+    const existingState = await readDeployState(projectRoot);
+    const confirmMode = args.confirm === true;
+    const platform = await resolvePlatform({
+      promptClient: prompts,
+      platformArg: args.platform,
+      storedPlatform: existingState?.platform,
+      confirm: confirmMode
+    });
+    const appName = resolveAppName(args.app, existingState?.appName, projectRoot, confirmMode);
+    const region = resolveRegion(args.region, existingState?.region, confirmMode);
+    const deployDirectory = resolveDeployDirectory(projectRoot);
+    const environment = args.prod === true ? "production" : "preview";
+    const config = {
+      projectRoot,
+      appName,
+      region,
+      environment,
+      confirm: confirmMode
+    };
+    const adapter = createDeployAdapter(platform);
+    configureAdapterContext(adapter, {
+      projectRoot,
+      appName,
+      region
+    });
+    logger.banner();
+    logger.info(
+      `Deploying to ${platform} (${appName}${region ? `, ${region}` : ""}, ${environment})`
+    );
+    if (confirmMode) {
+      logger.step("Running in --confirm mode (non-interactive, fail-fast).");
     }
-    let pm;
-    if (args.pm && isValidPackageManager(args.pm)) {
-      pm = args.pm;
-    } else if (useDefaults) {
-      pm = detectPackageManager();
-    } else {
-      const detected = detectPackageManager();
-      pm = await promptSelect(
-        "Package manager:",
-        PACKAGE_MANAGERS.map((p) => ({
-          label: p === detected ? `${p} (detected)` : p,
-          value: p
-        }))
-      );
+    await writeDockerfileArtifact(deployDirectory, {
+      nativeDependencies: {
+        "better-sqlite3": "^11.0.0",
+        "drizzle-orm": "^0.45.2"
+      }
+    });
+    await writeDockerIgnoreArtifact(deployDirectory);
+    const detected = await adapter.detect();
+    if (!detected) {
+      await adapter.install();
     }
-    const targetDir = (0, import_node_path3.resolve)(process.cwd(), projectName);
-    if (await directoryExists(targetDir)) {
-      throw new ProjectExistsError(projectName);
+    await adapter.authenticate();
+    const provisionResult = await adapter.provision(config);
+    const artifacts = await adapter.build(config);
+    const deployResult = await adapter.deploy(artifacts);
+    if (existingState) {
+      await updateDeployState(projectRoot, {
+        platform,
+        appName,
+        region,
+        projectRoot,
+        liveUrl: deployResult.liveUrl,
+        syncUrl: deployResult.syncUrl,
+        databaseId: provisionResult.databaseId,
+        lastDeploymentId: deployResult.deploymentId
+      });
+    } else {
+      await writeDeployState(projectRoot, {
+        platform,
+        appName,
+        region,
+        projectRoot,
+        liveUrl: deployResult.liveUrl,
+        syncUrl: deployResult.syncUrl,
+        databaseId: provisionResult.databaseId,
+        lastDeploymentId: deployResult.deploymentId
+      });
     }
-    const koraVersion = resolveKoraVersion();
-    logger.step(`Creating ${projectName} with ${template} template...`);
-    await scaffoldTemplate(template, targetDir, {
-      projectName,
-      packageManager: pm,
-      koraVersion
-    });
-    logger.success("Project scaffolded");
-    if (!args["skip-install"]) {
-      logger.step("Installing dependencies...");
-      try {
-        (0, import_node_child_process2.execSync)(getInstallCommand(pm), { cwd: targetDir, stdio: "inherit" });
-        logger.success("Dependencies installed");
-      } catch {
-        logger.warn("Failed to install dependencies. Run install manually.");
-      }
+    logger.success(`Deployment completed: ${deployResult.liveUrl}`);
+    if (deployResult.syncUrl) {
+      logger.step(`Sync endpoint: ${deployResult.syncUrl}`);
     }
-    logger.blank();
-    logger.info("Done! Next steps:");
-    logger.blank();
-    logger.step(`  cd ${projectName}`);
-    logger.step(`  ${getRunDevCommand(pm)}`);
-    logger.blank();
   }
 });
-function isValidTemplate(value) {
-  return TEMPLATES.includes(value);
+async function resolvePlatform(options) {
+  if (typeof options.platformArg === "string") {
+    if (!isDeployPlatform(options.platformArg)) {
+      throw new Error(
+        `Invalid --platform value "${options.platformArg}". Valid options: ${DEPLOY_PLATFORMS.join(", ")}`
+      );
+    }
+    return options.platformArg;
+  }
+  if (options.storedPlatform) {
+    return options.storedPlatform;
+  }
+  if (options.confirm || !isInteractiveTerminal()) {
+    throw new Error(
+      "Missing deploy platform in --confirm mode. Provide --platform or run an interactive deploy first."
+    );
+  }
+  return await options.promptClient.select("Where do you want to deploy?", [
+    {
+      label: "Fly.io (recommended for sync apps)",
+      value: "fly"
+    },
+    {
+      label: "Railway",
+      value: "railway"
+    },
+    {
+      label: "Render",
+      value: "render"
+    },
+    {
+      label: "Docker (self-hosted)",
+      value: "docker"
+    },
+    {
+      label: "Kora Cloud (coming soon)",
+      value: "kora-cloud"
+    }
+  ]);
 }
-function isValidPackageManager(value) {
-  return PACKAGE_MANAGERS.includes(value);
+function resolveAppName(argValue, storedValue, projectRoot, confirm) {
+  if (typeof argValue === "string" && argValue.length > 0) {
+    return sanitizeAppName(argValue);
+  }
+  if (storedValue && storedValue.length > 0) {
+    return storedValue;
+  }
+  if (confirm) {
+    throw new Error(
+      "Missing app name in --confirm mode. Provide --app or run an interactive deploy first."
+    );
+  }
+  return sanitizeAppName((0, import_node_path14.basename)(projectRoot));
 }
-function resolveTemplateFromFlags(tailwind, sync) {
-  const useTailwind = tailwind !== false;
-  const useSync = sync !== false;
-  if (useTailwind && useSync) return "react-tailwind-sync";
-  if (useTailwind && !useSync) return "react-tailwind";
-  if (!useTailwind && useSync) return "react-sync";
-  return "react-basic";
+function resolveRegion(argValue, storedValue, confirm) {
+  if (typeof argValue === "string" && argValue.length > 0) return argValue;
+  if (storedValue !== void 0) return storedValue;
+  if (confirm) {
+    throw new Error(
+      "Missing region in --confirm mode. Provide --region or run an interactive deploy first."
+    );
+  }
+  return "iad";
 }
-function resolveKoraVersion() {
-  try {
-    let dir = (0, import_node_path3.dirname)((0, import_node_url2.fileURLToPath)(import_meta2.url));
-    for (let i = 0; i < 5; i++) {
-      const pkgPath = (0, import_node_path3.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") {
-          if (pkg.version === "0.0.0") return "latest";
-          const parts = pkg.version.split(".");
-          return `^${parts[0]}.${parts[1]}.0`;
-        }
-      }
-      dir = (0, import_node_path3.dirname)(dir);
-    }
-    return "latest";
-  } catch {
-    return "latest";
+function sanitizeAppName(value) {
+  const normalized = value.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-{2,}/g, "-").replace(/^-|-$/g, "");
+  if (normalized.length === 0) {
+    return "kora-app";
+  }
+  return normalized;
+}
+async function requireProjectRoot() {
+  const projectRoot = await findProjectRoot();
+  if (!projectRoot) {
+    throw new InvalidProjectError(process.cwd());
+  }
+  return projectRoot;
+}
+function isInteractiveTerminal() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function configureAdapterContext(adapter, context) {
+  if (hasContextSetter(adapter)) {
+    adapter.setContext(context);
   }
 }
+function hasContextSetter(adapter) {
+  return typeof adapter.setContext === "function";
+}
 
 // src/commands/dev/dev-command.ts
-var import_promises4 = require("fs/promises");
-var import_node_path6 = require("path");
-var import_node_path7 = require("path");
-var import_citty2 = require("citty");
+var import_promises13 = require("fs/promises");
+var import_node_path17 = require("path");
+var import_node_path18 = require("path");
+var import_citty3 = require("citty");
 
 // src/commands/dev/kora-config.ts
-var import_node_child_process3 = require("child_process");
-var import_promises3 = require("fs/promises");
-var import_node_path4 = require("path");
+var import_node_child_process6 = require("child_process");
+var import_promises12 = require("fs/promises");
+var import_node_path15 = require("path");
 var import_node_url3 = require("url");
 var CONFIG_CANDIDATES = [
   "kora.config.ts",
@@ -552,7 +2736,7 @@ var CONFIG_CANDIDATES = [
 async function loadKoraConfig(projectRoot) {
   const configPath = await findKoraConfigFile(projectRoot);
   if (!configPath) return null;
-  const ext = (0, import_node_path4.extname)(configPath);
+  const ext = (0, import_node_path15.extname)(configPath);
   if (ext === ".ts" || ext === ".mts" || ext === ".cts") {
     const loaded2 = await loadTypeScriptConfig(configPath, projectRoot);
     return toConfigObject(loaded2);
@@ -562,9 +2746,9 @@ async function loadKoraConfig(projectRoot) {
 }
 async function findKoraConfigFile(projectRoot) {
   for (const file of CONFIG_CANDIDATES) {
-    const candidate = (0, import_node_path4.join)(projectRoot, file);
+    const candidate = (0, import_node_path15.join)(projectRoot, file);
     try {
-      await (0, import_promises3.access)(candidate);
+      await (0, import_promises12.access)(candidate);
       return candidate;
     } catch {
     }
@@ -590,8 +2774,8 @@ async function loadTypeScriptConfig(configPath, projectRoot) {
   }
 }
 async function runCommand(command, args, cwd) {
-  return await new Promise((resolve7, reject) => {
-    const child = (0, import_node_child_process3.spawn)(command, args, {
+  return await new Promise((resolve9, reject) => {
+    const child = (0, import_node_child_process6.spawn)(command, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env
@@ -609,7 +2793,7 @@ async function runCommand(command, args, cwd) {
     });
     child.on("exit", (code) => {
       if (code === 0) {
-        resolve7(stdout.trim());
+        resolve9(stdout.trim());
         return;
       }
       reject(new Error(`Failed to load kora config (exit ${code ?? "unknown"}): ${stderr.trim()}`));
@@ -628,7 +2812,7 @@ function toConfigObject(mod) {
 }
 
 // src/commands/dev/process-manager.ts
-var import_node_child_process4 = require("child_process");
+var import_node_child_process7 = require("child_process");
 var ProcessManager = class {
   processes = /* @__PURE__ */ new Map();
   spawn(config) {
@@ -637,12 +2821,12 @@ var ProcessManager = class {
       env: { ...process.env, ...config.env },
       stdio: ["ignore", "pipe", "pipe"]
     };
-    const child = (0, import_node_child_process4.spawn)(config.command, config.args, options);
+    const child = (0, import_node_child_process7.spawn)(config.command, config.args, options);
     let resolveExit;
     const runningProcess = {
       child,
-      exitPromise: new Promise((resolve7) => {
-        resolveExit = resolve7;
+      exitPromise: new Promise((resolve9) => {
+        resolveExit = resolve9;
       }),
       stdoutBuffer: "",
       stderrBuffer: ""
@@ -709,15 +2893,15 @@ var ProcessManager = class {
   }
 };
 function delay(ms) {
-  return new Promise((resolve7) => {
-    setTimeout(resolve7, ms);
+  return new Promise((resolve9) => {
+    setTimeout(resolve9, ms);
   });
 }
 
 // src/commands/dev/schema-watcher.ts
-var import_node_child_process5 = require("child_process");
-var import_node_fs3 = require("fs");
-var import_node_path5 = require("path");
+var import_node_child_process8 = require("child_process");
+var import_node_fs4 = require("fs");
+var import_node_path16 = require("path");
 var SchemaWatcher = class {
   constructor(config) {
     this.config = config;
@@ -729,7 +2913,7 @@ var SchemaWatcher = class {
   debounceTimer = null;
   start() {
     if (this.watcher) return;
-    this.watcher = (0, import_node_fs3.watch)(this.config.schemaPath, () => {
+    this.watcher = (0, import_node_fs4.watch)(this.config.schemaPath, () => {
       this.scheduleRegeneration();
     });
     this.watcher.on("error", (error) => {
@@ -745,7 +2929,7 @@ var SchemaWatcher = class {
     this.watcher = null;
   }
   async regenerate() {
-    const koraBinJs = (0, import_node_path5.join)(this.config.projectRoot, "node_modules", "@korajs", "cli", "dist", "bin.js");
+    const koraBinJs = (0, import_node_path16.join)(this.config.projectRoot, "node_modules", "@korajs", "cli", "dist", "bin.js");
     const hasTsx = await hasTsxInstalled(this.config.projectRoot);
     const command = process.execPath;
     const args = hasTsx ? ["--import", "tsx", koraBinJs, "generate", "types", "--schema", this.config.schemaPath] : [koraBinJs, "generate", "types", "--schema", this.config.schemaPath];
@@ -765,8 +2949,8 @@ var SchemaWatcher = class {
   }
 };
 async function spawnCommand(command, args, cwd) {
-  await new Promise((resolve7, reject) => {
-    const child = (0, import_node_child_process5.spawn)(command, args, {
+  await new Promise((resolve9, reject) => {
+    const child = (0, import_node_child_process8.spawn)(command, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env
@@ -782,7 +2966,7 @@ async function spawnCommand(command, args, cwd) {
     });
     child.on("exit", (code) => {
       if (code === 0) {
-        resolve7();
+        resolve9();
         return;
       }
       reject(new Error(`Type generation exited with code ${code ?? "unknown"}.`));
@@ -804,7 +2988,7 @@ function toError(error) {
 }
 
 // src/commands/dev/dev-command.ts
-var devCommand = (0, import_citty2.defineCommand)({
+var devCommand = (0, import_citty3.defineCommand)({
   meta: {
     name: "dev",
     description: "Start the Kora development environment"
@@ -844,7 +3028,7 @@ var devCommand = (0, import_citty2.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_path6.join)(projectRoot, "node_modules", ".bin", "vite"));
+      throw new DevServerError("vite", (0, import_node_path17.join)(projectRoot, "node_modules", ".bin", "vite"));
     }
     const syncServerFile = await findSyncServerFile(projectRoot);
     let managedSyncStore = normalizeManagedSyncStore(config, projectRoot);
@@ -859,8 +3043,8 @@ var devCommand = (0, import_citty2.defineCommand)({
       }
     }
     if (shouldStartSync && syncServerFile === null && managedSyncStore) {
-      const hasServerPackage = await fileExists(
-        (0, import_node_path6.join)(projectRoot, "node_modules", "@korajs", "server", "package.json")
+      const hasServerPackage = await fileExists2(
+        (0, import_node_path17.join)(projectRoot, "node_modules", "@korajs", "server", "package.json")
       );
       if (!hasServerPackage) {
         logger.warn(
@@ -877,8 +3061,8 @@ var devCommand = (0, import_citty2.defineCommand)({
     }
     let configuredSchemaPath = null;
     if (typeof config?.schema === "string") {
-      const candidate = (0, import_node_path7.resolve)(projectRoot, config.schema);
-      if (await fileExists(candidate)) {
+      const candidate = (0, import_node_path18.resolve)(projectRoot, config.schema);
+      if (await fileExists2(candidate)) {
         configuredSchemaPath = candidate;
       } else {
         logger.warn(`Configured schema file not found: ${candidate}. Falling back to auto-detection.`);
@@ -890,8 +3074,8 @@ var devCommand = (0, import_citty2.defineCommand)({
     let schemaWatcher = null;
     let shuttingDown = false;
     let resolveFinished;
-    const finished = new Promise((resolve7) => {
-      resolveFinished = resolve7;
+    const finished = new Promise((resolve9) => {
+      resolveFinished = resolve9;
     });
     const onManagedProcessExit = () => {
       if (!processManager.hasRunning() && !shuttingDown) {
@@ -989,19 +3173,19 @@ var devCommand = (0, import_citty2.defineCommand)({
   }
 });
 async function findSyncServerFile(projectRoot) {
-  const candidates = [(0, import_node_path6.join)(projectRoot, "server.ts"), (0, import_node_path6.join)(projectRoot, "server.js")];
+  const candidates = [(0, import_node_path17.join)(projectRoot, "server.ts"), (0, import_node_path17.join)(projectRoot, "server.js")];
   for (const candidate of candidates) {
     try {
-      await (0, import_promises4.access)(candidate);
+      await (0, import_promises13.access)(candidate);
       return candidate;
     } catch {
     }
   }
   return null;
 }
-async function fileExists(path) {
+async function fileExists2(path) {
   try {
-    await (0, import_promises4.access)(path);
+    await (0, import_promises13.access)(path);
     return true;
   } catch {
     return false;
@@ -1013,7 +3197,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_path6.join)(projectRoot, "kora-sync.db") };
+  if (store === "sqlite") return { type: "sqlite", filename: (0, import_node_path17.join)(projectRoot, "kora-sync.db") };
   if (store === "postgres") {
     const connectionString = process.env.DATABASE_URL;
     if (!connectionString) return null;
@@ -1022,7 +3206,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_path7.resolve)(projectRoot, store.filename) : (0, import_node_path6.join)(projectRoot, "kora-sync.db");
+      const filename = typeof store.filename === "string" && store.filename.length > 0 ? (0, import_node_path18.resolve)(projectRoot, store.filename) : (0, import_node_path17.join)(projectRoot, "kora-sync.db");
       return { type: "sqlite", filename };
     }
     if (store.type === "postgres" && typeof store.connectionString === "string") {
@@ -1085,9 +3269,9 @@ await new Promise(() => {});
 `;
 
 // src/commands/generate/generate-command.ts
-var import_promises5 = require("fs/promises");
-var import_node_path8 = require("path");
-var import_citty3 = require("citty");
+var import_promises14 = require("fs/promises");
+var import_node_path19 = require("path");
+var import_citty4 = require("citty");
 
 // src/commands/generate/type-generator.ts
 function generateTypes(schema) {
@@ -1187,13 +3371,13 @@ function toPascalCase(name) {
 }
 
 // src/commands/generate/generate-command.ts
-var generateCommand = (0, import_citty3.defineCommand)({
+var generateCommand = (0, import_citty4.defineCommand)({
   meta: {
     name: "generate",
     description: "Generate code from your Kora schema"
   },
   subCommands: {
-    types: (0, import_citty3.defineCommand)({
+    types: (0, import_citty4.defineCommand)({
       meta: {
         name: "types",
         description: "Generate TypeScript types from your schema"
@@ -1217,7 +3401,7 @@ var generateCommand = (0, import_citty3.defineCommand)({
         }
         let schemaPath;
         if (args.schema && typeof args.schema === "string") {
-          schemaPath = (0, import_node_path8.resolve)(args.schema);
+          schemaPath = (0, import_node_path19.resolve)(args.schema);
         } else {
           const found = await findSchemaFile(projectRoot);
           if (!found) {
@@ -1240,9 +3424,9 @@ var generateCommand = (0, import_citty3.defineCommand)({
         }
         const output = generateTypes(schema);
         const outputFile = typeof args.output === "string" ? args.output : "kora/generated/types.ts";
-        const outputPath = (0, import_node_path8.resolve)(projectRoot, outputFile);
-        await (0, import_promises5.mkdir)((0, import_node_path8.dirname)(outputPath), { recursive: true });
-        await (0, import_promises5.writeFile)(outputPath, output, "utf-8");
+        const outputPath = (0, import_node_path19.resolve)(projectRoot, outputFile);
+        await (0, import_promises14.mkdir)((0, import_node_path19.dirname)(outputPath), { recursive: true });
+        await (0, import_promises14.writeFile)(outputPath, output, "utf-8");
         logger.success(`Generated types at ${outputPath}`);
       }
     })
@@ -1262,9 +3446,9 @@ function isSchemaDefinition(value) {
 }
 
 // src/commands/migrate/migrate-command.ts
-var import_promises6 = require("fs/promises");
-var import_node_path10 = require("path");
-var import_citty4 = require("citty");
+var import_promises15 = require("fs/promises");
+var import_node_path21 = require("path");
+var import_citty5 = require("citty");
 
 // src/commands/migrate/migration-generator.ts
 var import_core2 = require("@korajs/core");
@@ -1832,11 +4016,11 @@ async function loadPostgresModule() {
 }
 
 // src/commands/migrate/schema-loader.ts
-var import_node_child_process6 = require("child_process");
-var import_node_path9 = require("path");
+var import_node_child_process9 = require("child_process");
+var import_node_path20 = require("path");
 var import_node_url4 = require("url");
 async function loadSchemaDefinition(schemaPath, projectRoot) {
-  const ext = (0, import_node_path9.extname)(schemaPath);
+  const ext = (0, import_node_path20.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);
 }
@@ -1875,8 +4059,8 @@ async function loadTypeScriptModule(schemaPath, projectRoot) {
   }
 }
 async function runCommand2(command, args, cwd) {
-  return await new Promise((resolve7, reject) => {
-    const child = (0, import_node_child_process6.spawn)(command, args, {
+  return await new Promise((resolve9, reject) => {
+    const child = (0, import_node_child_process9.spawn)(command, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env
@@ -1894,7 +4078,7 @@ async function runCommand2(command, args, cwd) {
     });
     child.on("exit", (code) => {
       if (code === 0) {
-        resolve7(stdout.trim());
+        resolve9(stdout.trim());
         return;
       }
       reject(
@@ -1907,7 +4091,7 @@ async function runCommand2(command, args, cwd) {
 // src/commands/migrate/migrate-command.ts
 var SNAPSHOT_PATH = "kora/schema.snapshot.json";
 var MIGRATIONS_DIR = "kora/migrations";
-var migrateCommand = (0, import_citty4.defineCommand)({
+var migrateCommand = (0, import_citty5.defineCommand)({
   meta: {
     name: "migrate",
     description: "Detect schema changes and generate/apply migrations"
@@ -1949,12 +4133,12 @@ var migrateCommand = (0, import_citty4.defineCommand)({
       throw new InvalidProjectError(process.cwd());
     }
     const config = await loadKoraConfig(projectRoot);
-    const resolvedSchemaPath = typeof args.schema === "string" ? (0, import_node_path10.resolve)(projectRoot, args.schema) : typeof config?.schema === "string" ? (0, import_node_path10.resolve)(projectRoot, config.schema) : await findSchemaFile(projectRoot);
+    const resolvedSchemaPath = typeof args.schema === "string" ? (0, import_node_path21.resolve)(projectRoot, args.schema) : typeof config?.schema === "string" ? (0, import_node_path21.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_path10.join)(projectRoot, SNAPSHOT_PATH);
+    const snapshotFile = (0, import_node_path21.join)(projectRoot, SNAPSHOT_PATH);
     const previousSchema = await readSchemaSnapshot(snapshotFile);
     if (!previousSchema) {
       if (args["dry-run"] === true) {
@@ -1967,7 +4151,7 @@ var migrateCommand = (0, import_citty4.defineCommand)({
       return;
     }
     const diff = diffSchemas(previousSchema, currentSchema);
-    const outputDir = typeof args["output-dir"] === "string" ? (0, import_node_path10.resolve)(projectRoot, args["output-dir"]) : (0, import_node_path10.resolve)(projectRoot, MIGRATIONS_DIR);
+    const outputDir = typeof args["output-dir"] === "string" ? (0, import_node_path21.resolve)(projectRoot, args["output-dir"]) : (0, import_node_path21.resolve)(projectRoot, MIGRATIONS_DIR);
     if (!diff.hasChanges) {
       logger.success("No schema changes detected.");
       if (args.apply === true) {
@@ -2019,7 +4203,7 @@ var migrateCommand = (0, import_citty4.defineCommand)({
       logger.warn("Dry run enabled: no files written, no migrations applied.");
       return;
     }
-    await (0, import_promises6.mkdir)(outputDir, { recursive: true });
+    await (0, import_promises15.mkdir)(outputDir, { recursive: true });
     const migrationPath = await writeMigrationFile(outputDir, diff.fromVersion, diff.toVersion, generated);
     await writeSchemaSnapshot(snapshotFile, currentSchema);
     logger.blank();
@@ -2050,7 +4234,7 @@ var migrateCommand = (0, import_citty4.defineCommand)({
 });
 async function readSchemaSnapshot(path) {
   try {
-    const content = await (0, import_promises6.readFile)(path, "utf-8");
+    const content = await (0, import_promises15.readFile)(path, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -2060,26 +4244,26 @@ async function confirmBreakingChanges(force) {
   if (force) {
     return true;
   }
-  if (!isInteractiveTerminal()) {
+  if (!isInteractiveTerminal2()) {
     throw new Error(
       "Breaking schema changes require confirmation. Re-run with --force to continue or --dry-run to preview."
     );
   }
   return await promptConfirm("Continue and generate a breaking migration?", false);
 }
-function isInteractiveTerminal() {
+function isInteractiveTerminal2() {
   return process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
 async function writeSchemaSnapshot(path, schema) {
-  await (0, import_promises6.mkdir)((0, import_node_path10.dirname)(path), { recursive: true });
-  await (0, import_promises6.writeFile)(path, `${JSON.stringify(schema, null, 2)}
+  await (0, import_promises15.mkdir)((0, import_node_path21.dirname)(path), { recursive: true });
+  await (0, import_promises15.writeFile)(path, `${JSON.stringify(schema, null, 2)}
 `, "utf-8");
 }
 async function writeMigrationFile(outputDir, fromVersion, toVersion, generated) {
-  const existing = await (0, import_promises6.readdir)(outputDir).catch(() => []);
+  const existing = await (0, import_promises15.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_path10.join)(outputDir, filename);
+  const path = (0, import_node_path21.join)(outputDir, filename);
   const migrationId = filename.replace(/\.ts$/, "");
   const fileContent = [
     `export const up = ${JSON.stringify(generated.up, null, 2)} as const`,
@@ -2091,8 +4275,8 @@ async function writeMigrationFile(outputDir, fromVersion, toVersion, generated)
     `export const containsBreakingChanges = ${generated.containsBreakingChanges}`,
     ""
   ].join("\n");
-  await (0, import_promises6.writeFile)(path, fileContent, "utf-8");
-  await writeMigrationManifest((0, import_node_path10.join)(outputDir, `${migrationId}.json`), {
+  await (0, import_promises15.writeFile)(path, fileContent, "utf-8");
+  await writeMigrationManifest((0, import_node_path21.join)(outputDir, `${migrationId}.json`), {
     id: migrationId,
     fromVersion,
     toVersion,
@@ -2104,22 +4288,22 @@ async function writeMigrationFile(outputDir, fromVersion, toVersion, generated)
   return path;
 }
 async function writeMigrationManifest(path, manifest) {
-  await (0, import_promises6.writeFile)(path, `${JSON.stringify(manifest, null, 2)}
+  await (0, import_promises15.writeFile)(path, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
 }
 async function listMigrationManifests(outputDir) {
-  const files = await (0, import_promises6.readdir)(outputDir).catch(() => []);
+  const files = await (0, import_promises15.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_path10.join)(outputDir, `${id}.json`);
+    const manifestPath = (0, import_node_path21.join)(outputDir, `${id}.json`);
     const jsonManifest = await readMigrationManifest(manifestPath);
     if (jsonManifest) {
       manifests.push({ ...jsonManifest, id });
       continue;
     }
-    const migrationPath = (0, import_node_path10.join)(outputDir, file);
+    const migrationPath = (0, import_node_path21.join)(outputDir, file);
     const sourceManifest = await readMigrationManifestFromSource(migrationPath, id);
     manifests.push(sourceManifest);
   }
@@ -2127,7 +4311,7 @@ async function listMigrationManifests(outputDir) {
 }
 async function readMigrationManifest(path) {
   try {
-    const content = await (0, import_promises6.readFile)(path, "utf-8");
+    const content = await (0, import_promises15.readFile)(path, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     const code = error.code;
@@ -2138,7 +4322,7 @@ async function readMigrationManifest(path) {
   }
 }
 async function readMigrationManifestFromSource(path, id) {
-  const content = await (0, import_promises6.readFile)(path, "utf-8");
+  const content = await (0, import_promises15.readFile)(path, "utf-8");
   const versions = parseVersionsFromMigrationId(id);
   return {
     id,
@@ -2195,18 +4379,18 @@ function parseLiteralExport(source, exportName) {
 }
 function resolveSqliteApplyPath(dbArg, projectRoot, config) {
   if (typeof dbArg === "string") {
-    return (0, import_node_path10.resolve)(projectRoot, dbArg);
+    return (0, import_node_path21.resolve)(projectRoot, dbArg);
   }
   const sync = config?.dev?.sync;
   if (typeof sync === "object" && sync !== null) {
     if (sync.store === "sqlite") {
-      return (0, import_node_path10.join)(projectRoot, "kora-sync.db");
+      return (0, import_node_path21.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_path10.resolve)(projectRoot, sync.store.filename);
+        return (0, import_node_path21.resolve)(projectRoot, sync.store.filename);
       }
-      return (0, import_node_path10.join)(projectRoot, "kora-sync.db");
+      return (0, import_node_path21.join)(projectRoot, "kora-sync.db");
     }
   }
   return void 0;
@@ -2224,7 +4408,7 @@ function resolvePostgresConnectionString(config) {
 }
 
 // src/bin.ts
-var main = (0, import_citty5.defineCommand)({
+var main = (0, import_citty6.defineCommand)({
   meta: {
     name: "kora",
     description: "Kora.js \u2014 Offline-first application framework"
@@ -2232,9 +4416,10 @@ var main = (0, import_citty5.defineCommand)({
   subCommands: {
     create: createCommand,
     dev: devCommand,
+    deploy: deployCommand,
     generate: generateCommand,
     migrate: migrateCommand
   }
 });
-(0, import_citty5.runMain)(main);
+(0, import_citty6.runMain)(main);
 //# sourceMappingURL=bin.cjs.map