@korajs/cli 0.0.0-canary-20261008174129

package/dist/index.cjs

@@ -0,0 +1,3489 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AGENTS_FRAMEWORKS: () => AGENTS_FRAMEWORKS,
+  ClackPromptClient: () => ClackPromptClient,
+  CliError: () => CliError,
+  DEPLOY_PLATFORMS: () => DEPLOY_PLATFORMS,
+  DeployPlatformUnavailableError: () => DeployPlatformUnavailableError,
+  DevServerError: () => DevServerError,
+  FlyAdapter: () => FlyAdapter,
+  IMPLEMENTED_DEPLOY_PLATFORMS: () => IMPLEMENTED_DEPLOY_PLATFORMS,
+  InvalidProjectError: () => InvalidProjectError,
+  NodeFlyCommandRunner: () => NodeFlyCommandRunner,
+  NodeRailwayCommandRunner: () => NodeRailwayCommandRunner,
+  PACKAGE_MANAGERS: () => PACKAGE_MANAGERS,
+  PreferenceStore: () => PreferenceStore,
+  ProjectExistsError: () => ProjectExistsError,
+  PromptCancelledError: () => PromptCancelledError,
+  RailwayAdapter: () => RailwayAdapter,
+  ReadlinePromptClient: () => ReadlinePromptClient,
+  SchemaNotFoundError: () => SchemaNotFoundError,
+  StubDeployAdapter: () => StubDeployAdapter,
+  TEMPLATES: () => TEMPLATES,
+  TEMPLATE_INFO: () => TEMPLATE_INFO,
+  agentsCommand: () => agentsCommand,
+  applySyncProviderPreset: () => applySyncProviderPreset,
+  buildClient: () => buildClient,
+  bundleServer: () => bundleServer,
+  createDeployAdapter: () => createDeployAdapter,
+  createPromptClient: () => createPromptClient,
+  deployCommand: () => deployCommand,
+  detectFrameworkFromManifest: () => detectFrameworkFromManifest,
+  determineTemplateFromSelections: () => determineTemplateFromSelections,
+  generateAgentsMd: () => generateAgentsMd,
+  generateDeployPackageJson: () => generateDeployPackageJson,
+  generateDockerIgnore: () => generateDockerIgnore,
+  generateDockerfile: () => generateDockerfile,
+  generateFlyToml: () => generateFlyToml,
+  generateRailwayJson: () => generateRailwayJson,
+  generateTypes: () => generateTypes,
+  getCreatePreferencesOrDefault: () => getCreatePreferencesOrDefault,
+  getDefaultCreatePreferences: () => getDefaultCreatePreferences,
+  isAgentsFramework: () => isAgentsFramework,
+  isAuthValue: () => isAuthValue,
+  isDatabaseProviderValue: () => isDatabaseProviderValue,
+  isDatabaseValue: () => isDatabaseValue,
+  isDeployPlatform: () => isDeployPlatform,
+  isFrameworkValue: () => isFrameworkValue,
+  isImplementedDeployPlatform: () => isImplementedDeployPlatform,
+  readDeployState: () => readDeployState,
+  resetDeployState: () => resetDeployState,
+  resolveCreatePreferencesFlow: () => resolveCreatePreferencesFlow,
+  resolveDeployDirectory: () => resolveDeployDirectory,
+  resolveDeployStatePath: () => resolveDeployStatePath,
+  saveResolvedPreferences: () => saveResolvedPreferences,
+  shouldSavePreferences: () => shouldSavePreferences,
+  updateDeployState: () => updateDeployState,
+  validateProjectName: () => validateProjectName,
+  writeDeployState: () => writeDeployState,
+  writeDockerIgnoreArtifact: () => writeDockerIgnoreArtifact,
+  writeDockerfileArtifact: () => writeDockerfileArtifact,
+  writeFlyTomlArtifact: () => writeFlyTomlArtifact,
+  writeRailwayJsonArtifact: () => writeRailwayJsonArtifact
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/types.ts
+var PACKAGE_MANAGERS = ["pnpm", "npm", "yarn", "bun"];
+var TEMPLATES = [
+  "react-tailwind-sync",
+  "react-tailwind",
+  "react-sync",
+  "react-basic",
+  "vue-sync",
+  "vue-basic",
+  "vue-tailwind-sync",
+  "vue-tailwind",
+  "svelte-sync",
+  "svelte-basic",
+  "svelte-tailwind-sync",
+  "svelte-tailwind",
+  "tauri-react"
+];
+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"
+  },
+  {
+    name: "vue-sync",
+    label: "Vue 3 + CSS (with sync)",
+    description: "Vue composables with sync server included"
+  },
+  {
+    name: "vue-basic",
+    label: "Vue 3 + CSS (local-only)",
+    description: "Vue composables \u2014 no sync server"
+  },
+  {
+    name: "vue-tailwind-sync",
+    label: "Vue 3 + Tailwind (with sync)",
+    description: "Polished Vue app with Tailwind CSS and sync server"
+  },
+  {
+    name: "vue-tailwind",
+    label: "Vue 3 + Tailwind (local-only)",
+    description: "Polished Vue app with Tailwind CSS \u2014 no sync server"
+  },
+  {
+    name: "svelte-sync",
+    label: "Svelte 5 + CSS (with sync)",
+    description: "Svelte stores with sync server included"
+  },
+  {
+    name: "svelte-basic",
+    label: "Svelte 5 + CSS (local-only)",
+    description: "Svelte stores \u2014 no sync server"
+  },
+  {
+    name: "svelte-tailwind-sync",
+    label: "Svelte 5 + Tailwind (with sync)",
+    description: "Polished Svelte app with Tailwind CSS and sync server"
+  },
+  {
+    name: "svelte-tailwind",
+    label: "Svelte 5 + Tailwind (local-only)",
+    description: "Polished Svelte app with Tailwind CSS \u2014 no sync server"
+  },
+  {
+    name: "tauri-react",
+    label: "Tauri Desktop (native SQLite)",
+    description: "Desktop app with native SQLite \u2014 no WASM, includes sync server"
+  }
+];
+
+// src/errors.ts
+var import_core = require("@korajs/core");
+var CliError = class extends import_core.KoraError {
+  constructor(message, context) {
+    super(message, "CLI_ERROR", context);
+    this.name = "CliError";
+  }
+};
+var DeployPlatformUnavailableError = class extends import_core.KoraError {
+  constructor(platform, available) {
+    super(
+      `Deploying to "${platform}" is coming soon and not available yet. Choose one of: ${available.join(", ")}. To self-host, run the production server (\`pnpm build && pnpm start\`) in any Node 20+ environment.`,
+      "DEPLOY_PLATFORM_UNAVAILABLE",
+      { platform, available }
+    );
+    this.platform = platform;
+    this.available = available;
+    this.name = "DeployPlatformUnavailableError";
+  }
+  platform;
+  available;
+};
+var ProjectExistsError = class extends import_core.KoraError {
+  constructor(directory) {
+    super(
+      `Directory "${directory}" already exists. Choose a different name or remove the existing directory.`,
+      "PROJECT_EXISTS",
+      { directory }
+    );
+    this.directory = directory;
+    this.name = "ProjectExistsError";
+  }
+  directory;
+};
+var SchemaNotFoundError = class extends import_core.KoraError {
+  constructor(searchedPaths) {
+    super(
+      `Could not find a schema file. Searched: ${searchedPaths.join(", ")}. Create a schema file using defineSchema() from @korajs/core.`,
+      "SCHEMA_NOT_FOUND",
+      { searchedPaths }
+    );
+    this.searchedPaths = searchedPaths;
+    this.name = "SchemaNotFoundError";
+  }
+  searchedPaths;
+};
+var InvalidProjectError = class extends import_core.KoraError {
+  constructor(directory) {
+    super(
+      `"${directory}" is not a valid Kora project. No package.json with a kora dependency found. Run this command from inside a Kora project.`,
+      "INVALID_PROJECT",
+      { directory }
+    );
+    this.directory = directory;
+    this.name = "InvalidProjectError";
+  }
+  directory;
+};
+var DevServerError = class extends import_core.KoraError {
+  constructor(binary, searchPath) {
+    super(
+      `Could not find required binary "${binary}" at ${searchPath}. Install project dependencies and try again.`,
+      "DEV_SERVER_ERROR",
+      { binary, searchPath }
+    );
+    this.binary = binary;
+    this.searchPath = searchPath;
+    this.name = "DevServerError";
+  }
+  binary;
+  searchPath;
+};
+
+// src/commands/agents/agents-command.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+var import_citty = require("citty");
+
+// src/utils/fs-helpers.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+async function findProjectRoot(startDir) {
+  let current = (0, import_node_path.resolve)(startDir ?? process.cwd());
+  for (; ; ) {
+    const pkgPath = (0, import_node_path.join)(current, "package.json");
+    try {
+      const content = await (0, import_promises.readFile)(pkgPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (isKoraProject(pkg)) {
+        return current;
+      }
+    } catch {
+    }
+    const parent = (0, import_node_path.dirname)(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+async function resolveProjectBinaryEntryPoint(projectRoot, packageName, binaryName) {
+  const pkgJsonPath = (0, import_node_path.join)(projectRoot, "node_modules", packageName, "package.json");
+  try {
+    const content = await (0, import_promises.readFile)(pkgJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    let binPath;
+    if (typeof pkg.bin === "string") {
+      binPath = pkg.bin;
+    } else if (typeof pkg.bin === "object" && pkg.bin !== null) {
+      binPath = pkg.bin[binaryName];
+    }
+    if (!binPath) return null;
+    const fullPath = (0, import_node_path.join)(projectRoot, "node_modules", packageName, binPath);
+    await (0, import_promises.access)(fullPath);
+    return fullPath;
+  } catch {
+    return null;
+  }
+}
+function isKoraProject(pkg) {
+  if (typeof pkg !== "object" || pkg === null) return false;
+  const record = pkg;
+  return hasKoraDep(record.dependencies) || hasKoraDep(record.devDependencies);
+}
+function hasKoraDep(deps) {
+  if (typeof deps !== "object" || deps === null) return false;
+  return Object.keys(deps).some((key) => key === "kora" || key.startsWith("@korajs/"));
+}
+
+// src/utils/logger.ts
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var CYAN = "\x1B[36m";
+function createLogger(options) {
+  const colorDisabled = options?.noColor === true || process.env.NO_COLOR !== void 0 || !process.stdout.isTTY;
+  function color(code, text) {
+    return colorDisabled ? text : `${code}${text}${RESET}`;
+  }
+  return {
+    info(message) {
+      console.log(color(CYAN, message));
+    },
+    success(message) {
+      console.log(color(GREEN, `  \u2713 ${message}`));
+    },
+    warn(message) {
+      console.warn(color(YELLOW, `  \u26A0 ${message}`));
+    },
+    error(message) {
+      console.error(color(RED, `  \u2717 ${message}`));
+    },
+    step(message) {
+      console.log(color(DIM, `  ${message}`));
+    },
+    blank() {
+      console.log();
+    },
+    banner() {
+      console.log();
+      console.log(
+        color(BOLD + CYAN, "  Kora.js") + color(DIM, ", the offline-first application framework")
+      );
+      console.log();
+    }
+  };
+}
+
+// src/commands/agents/agents-md-content.ts
+var AGENTS_FRAMEWORKS = ["react", "vue", "svelte"];
+function isAgentsFramework(value) {
+  return AGENTS_FRAMEWORKS.includes(value);
+}
+function detectFrameworkFromManifest(manifest) {
+  if (typeof manifest !== "object" || manifest === null) return null;
+  const record = manifest;
+  const deps = collectDependencyNames(record.dependencies, record.devDependencies);
+  if (deps.has("@korajs/react")) return "react";
+  if (deps.has("@korajs/vue")) return "vue";
+  if (deps.has("@korajs/svelte")) return "svelte";
+  return null;
+}
+function collectDependencyNames(...groups) {
+  const names = /* @__PURE__ */ new Set();
+  for (const group of groups) {
+    if (typeof group !== "object" || group === null) continue;
+    for (const name of Object.keys(group)) {
+      names.add(name);
+    }
+  }
+  return names;
+}
+var FRAMEWORK_BINDINGS = {
+  react: `## React bindings
+
+\`\`\`tsx
+import { KoraProvider, useCollection, useMutation, useQuery, useSyncStatus } from '@korajs/react'
+
+// Wrap the tree once near your app entry: <KoraProvider app={app}><App /></KoraProvider>
+
+const todos = useCollection('todos')
+const rows = useQuery(todos.where({ completed: false }).orderBy('createdAt'))
+const addTodo = useMutation((data) => todos.insert(data))
+addTodo.mutate({ title: 'x' })                // fire-and-forget; errors land in addTodo.error
+await addTodo.mutateAsync({ title: 'x' })     // resolves with the result; throws on failure
+const status = useSyncStatus()                // status.status, status.pendingOperations
+\`\`\`
+
+Rules: always render \`mutation.error\` somewhere. Keep \`<StrictMode>\` in place; the hooks are StrictMode-safe. \`useQuery\` reads the local store: no network, no spinner. Its very first render returns \`[]\` before the local query has run; use \`useQueryState\` when you must tell "loading" from "no rows".`,
+  vue: `## Vue bindings
+
+\`\`\`ts
+import { useCollection, useMutation, useQuery, useSyncStatus } from '@korajs/vue'
+
+const todos = useCollection('todos')
+const rows = useQuery(todos.where({ completed: false }).orderBy('createdAt'))  // readonly reactive ref
+const addTodo = useMutation((data) => todos.insert(data))
+addTodo.mutate({ title: 'x' })                // fire-and-forget; errors land in addTodo.error
+const status = useSyncStatus()                // status.status, status.pendingOperations
+\`\`\`
+
+Rules: surface the mutation's error state in the UI. \`useQuery\` reads the local store (no network, no spinner); the ref holds \`[]\` until the first local result. The Kora context comes from \`KoraProvider\`, wired in your app entry (for example \`src/main.ts\`).`,
+  svelte: `## Svelte bindings
+
+Kora's Svelte bindings from \`@korajs/svelte\` expose \`useCollection\`, \`useQuery\`, \`useMutation\`, and \`useSyncStatus\`, wired through the provider set up in your app entry.
+
+\`\`\`ts
+import { useCollection, useMutation, useQuery, useSyncStatus } from '@korajs/svelte'
+
+const todos = useCollection('todos')
+const rows = useQuery(todos.where({ completed: false }).orderBy('createdAt'))  // reactive store
+const addTodo = useMutation((data) => todos.insert(data))
+addTodo.mutate({ title: 'x' })                // fire-and-forget; errors land in addTodo.error
+const status = useSyncStatus()                // readable store; read $status.status in markup
+\`\`\`
+
+Rules: queries are reactive stores over the local database (no network, no spinner; \`[]\` until the first local result). Mutations expose an \`error\` state that must be surfaced in the UI.`
+};
+function generateAgentsMd(framework) {
+  return `# AGENTS.md
+
+Guidance for AI coding agents working in this project. Humans: this is useful for you too.
+
+## What this project is
+
+This project uses **Kora.js**, an offline-first application framework. All application data lives in a local SQLite database (WASM + OPFS in the browser, native SQLite on desktop and server) and optionally syncs across devices through a Kora sync server. Offline is the normal state, not an error state. Full docs live at https://korajs.dev, with a machine-readable index at https://korajs.dev/llms.txt and the complete docs in one file at https://korajs.dev/llms-full.txt. Any documentation page is available as raw markdown by appending \`.md\` to its URL.
+
+## Golden rules
+
+1. **The schema is the source of truth.** Collections are defined with \`defineSchema\` and the \`t.*\` field builders (by convention in \`src/schema.ts\`). To add or change data shapes, edit the schema first; types flow from it automatically. Never hand-write types for records.
+2. **Never fetch application data over HTTP.** Do not add REST or GraphQL calls for app data, and do not talk to the sync server directly. Read and write through Kora collections only; sync happens automatically in the background.
+3. **Await readiness before direct collection access.** Outside the UI bindings, \`await app.ready\` before calling \`app.<collection>\` methods. The framework bindings handle this for you inside components.
+4. **Offline must keep working.** Any feature you add must function with the network off. Never gate a read or write on connectivity. If you are checking \`navigator.onLine\` before a data operation, you are doing it wrong.
+5. **Surface mutation errors.** Fire-and-forget \`mutate\` calls put errors into the mutation state. Always render the mutation's \`error\`, or handle the promise from the \`mutateAsync\` variant. Silent failure is the worst failure.
+6. **Do not add a state library for server or app data.** Kora's reactive queries are the store. Do not reach for react-query, SWR, Redux, Zustand, or similar for data that lives in a collection. Local UI state (form inputs, toggles) can use your framework's normal state tools.
+7. **Do not add network-style loading states for local reads.** \`useQuery\` reads the local database, which answers within a frame; its very first render returns an empty result. Use \`useQueryState\` only where "loading" and "no rows" must look different.
+
+## Data API cheat sheet
+
+\`\`\`ts
+await app.ready
+const rec = await app.todos.insert({ title: 'x' })   // defaults and .auto() fields applied
+await app.todos.update(rec.id, { completed: true })  // partial update, changed fields only
+await app.todos.delete(rec.id)
+const one = await app.todos.findById(rec.id)
+const unsubscribe = app.todos
+  .where({ completed: false })
+  .orderBy('createdAt', 'desc')
+  .subscribe((rows) => {/* fires immediately, then on every change */})
+\`\`\`
+
+Schema example (\`src/schema.ts\`):
+
+\`\`\`ts
+import { defineSchema, t } from 'korajs'
+
+export default defineSchema({
+  version: 1,
+  collections: {
+    todos: {
+      fields: {
+        title: t.string(),
+        completed: t.boolean().default(false),
+        tags: t.array(t.string()).default([]),
+        priority: t.enum(['low', 'medium', 'high']).default('medium'),
+        createdAt: t.timestamp().auto(), // set automatically; never pass it on insert
+      },
+      indexes: ['completed', 'createdAt'],
+    },
+  },
+})
+\`\`\`
+
+If you change a collection's shape, increment \`version\` and add a \`migrations\` entry for it (\`migrate().addField(...)\`): each device migrates its local database on its next open. \`npx kora migrate\` generates the matching migration for server databases and a transform stub for clients still on the older version.
+
+## Conflict handling
+
+Concurrent edits merge automatically: last-write-wins per field, arrays as multisets that keep every device's additions and removals, objects per top-level key, and character-level CRDT for \`t.richtext()\` fields. When a field needs domain-specific merging (counters, quantities), add a \`resolve\` function in the schema rather than writing sync logic by hand. Never write your own conflict or merge code.
+
+## Sync and auth
+
+Enable sync with one option on \`createApp\`: \`createApp({ schema, sync: { url, autoConnect: true } })\` (without \`autoConnect\`, call \`await app.sync?.connect()\` after \`app.ready\`). When the app is offline, writes queue locally and sync when connectivity returns. If the project uses \`@korajs/auth\`, pass its binding as \`createApp({ schema, sync: { url, authClient: createKoraAuthSync({ authClient, schema }) } })\`; the server grants what each user may sync. Local writes work without sign-in; sync requires the server to accept the connection.
+
+${FRAMEWORK_BINDINGS[framework]}
+
+## Commands
+
+- \`npx kora dev\` runs the dev environment (app server, local sync server when configured, schema watcher).
+- \`npx kora doctor\` diagnoses a broken setup.
+- \`npx kora migrate\` generates a migration from a schema change (\`--apply\` runs it against a SQLite or Postgres database).
+- In a running app, the DevTools overlay (Ctrl+Shift+K, Cmd+Shift+K on macOS) inspects operations, merges, and sync status.
+`;
+}
+
+// src/commands/agents/agents-command.ts
+async function fileExists(path) {
+  try {
+    await (0, import_promises2.access)(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readManifest(root) {
+  try {
+    return JSON.parse(await (0, import_promises2.readFile)((0, import_node_path2.join)(root, "package.json"), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function resolveFramework(override, manifest) {
+  if (override !== void 0 && isAgentsFramework(override)) return override;
+  return detectFrameworkFromManifest(manifest) ?? "react";
+}
+var agentsCommand = (0, import_citty.defineCommand)({
+  meta: {
+    name: "agents-md",
+    description: "Write an AGENTS.md with Kora rules for AI coding agents into this project"
+  },
+  args: {
+    force: {
+      type: "boolean",
+      description: "Overwrite an existing AGENTS.md",
+      default: false
+    },
+    framework: {
+      type: "string",
+      description: "Override framework detection (react, vue, or svelte)"
+    }
+  },
+  async run({ args }) {
+    const logger = createLogger();
+    const projectRoot = await findProjectRoot() ?? process.cwd();
+    const manifest = await readManifest(projectRoot);
+    const override = typeof args.framework === "string" ? args.framework : void 0;
+    if (override !== void 0 && !isAgentsFramework(override)) {
+      logger.error(`Unknown framework "${override}". Use one of: react, vue, svelte.`);
+      process.exitCode = 1;
+      return;
+    }
+    const framework = resolveFramework(override, manifest);
+    const target = (0, import_node_path2.join)(projectRoot, "AGENTS.md");
+    const force = args.force === true;
+    if (await fileExists(target) && !force) {
+      logger.warn("AGENTS.md already exists. Re-run with --force to overwrite it.");
+      process.exitCode = 1;
+      return;
+    }
+    await (0, import_promises2.writeFile)(target, generateAgentsMd(framework), "utf-8");
+    logger.banner();
+    logger.success(`Wrote AGENTS.md (${framework} bindings) to ${target}`);
+    logger.step("Commit it so coding agents pick up Kora conventions automatically.");
+    logger.blank();
+  }
+});
+
+// src/commands/generate/type-generator.ts
+function generateTypes(schema) {
+  const lines = [
+    "// Auto-generated by @korajs/cli \u2014 do not edit manually",
+    `// Generated from schema version ${String(schema.version)}`,
+    ""
+  ];
+  const collectionNames = Object.keys(schema.collections);
+  if (collectionNames.length === 0) {
+    return lines.join("\n");
+  }
+  for (const [name, collection] of Object.entries(schema.collections)) {
+    const pascal = toPascalCase(name);
+    const fields = collection.fields;
+    lines.push(`export interface ${pascal}Record {`);
+    lines.push("	readonly id: string");
+    for (const [fieldName, descriptor] of Object.entries(fields)) {
+      const tsType = fieldKindToTypeScript(descriptor);
+      const optional = !descriptor.required && !descriptor.auto ? "?" : "";
+      lines.push(`	readonly ${fieldName}${optional}: ${tsType}`);
+    }
+    lines.push("}");
+    lines.push("");
+    lines.push(`export interface ${pascal}InsertInput {`);
+    for (const [fieldName, descriptor] of Object.entries(fields)) {
+      if (descriptor.auto) continue;
+      const tsType = fieldKindToTypeScript(descriptor);
+      const optional = !descriptor.required || descriptor.defaultValue !== void 0 ? "?" : "";
+      lines.push(`	${fieldName}${optional}: ${tsType}`);
+    }
+    lines.push("}");
+    lines.push("");
+    lines.push(`export interface ${pascal}UpdateInput {`);
+    for (const [fieldName, descriptor] of Object.entries(fields)) {
+      if (descriptor.auto) continue;
+      const tsType = fieldKindToTypeScript(descriptor);
+      lines.push(`	${fieldName}?: ${tsType}`);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function fieldKindToTypeScript(descriptor) {
+  switch (descriptor.kind) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "timestamp":
+      return "number";
+    case "richtext":
+      return "string";
+    case "enum": {
+      if (descriptor.enumValues && descriptor.enumValues.length > 0) {
+        return descriptor.enumValues.map((v) => `'${v}'`).join(" | ");
+      }
+      return "string";
+    }
+    case "array": {
+      const itemType = itemKindToTypeScript(descriptor.itemKind);
+      return `Array<${itemType}>`;
+    }
+    default:
+      return "unknown";
+  }
+}
+function itemKindToTypeScript(kind) {
+  switch (kind) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "timestamp":
+      return "number";
+    case "richtext":
+      return "string";
+    case "enum":
+      return "string";
+    case "array":
+      return "unknown[]";
+    default:
+      return "unknown";
+  }
+}
+function toPascalCase(name) {
+  return name.split(/[_-]/).map((part) => {
+    if (part.length === 0) return "";
+    const first = part[0];
+    return first ? first.toUpperCase() + part.slice(1) : "";
+  }).join("");
+}
+
+// src/commands/deploy/deploy-command.ts
+var import_node_fs2 = require("fs");
+var import_node_path13 = require("path");
+var import_citty2 = require("citty");
+
+// 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((resolve3) => {
+    const rl = createReadline(options);
+    const suffix = defaultValue !== void 0 ? ` (${defaultValue})` : "";
+    rl.question(`  ? ${message}${suffix}: `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      resolve3(trimmed || defaultValue || "");
+    });
+  });
+}
+function promptSelect(message, choices, options) {
+  return new Promise((resolve3) => {
+    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();
+          resolve3(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((resolve3) => {
+    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();
+          resolve3(defaultValue);
+          return;
+        }
+        if (normalized === "y" || normalized === "yes") {
+          rl.close();
+          resolve3(true);
+          return;
+        }
+        if (normalized === "n" || normalized === "no") {
+          rl.close();
+          resolve3(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/commands/deploy/adapters/adapter.ts
+var DEPLOY_PLATFORMS = [
+  "fly",
+  "railway",
+  "aws-ecs",
+  "aws-lightsail",
+  "render",
+  "docker",
+  "kora-cloud"
+];
+var IMPLEMENTED_DEPLOY_PLATFORMS = ["fly", "railway", "aws-ecs", "aws-lightsail"];
+function isImplementedDeployPlatform(platform) {
+  return IMPLEMENTED_DEPLOY_PLATFORMS.includes(platform);
+}
+function isDeployPlatform(value) {
+  return DEPLOY_PLATFORMS.includes(value);
+}
+
+// src/commands/deploy/adapters/aws-ecs-adapter.ts
+var import_node_child_process2 = require("child_process");
+var import_node_path5 = require("path");
+
+// src/commands/deploy/builder/client-builder.ts
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_promises3 = require("fs/promises");
+var import_node_path3 = 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_path3.join)(outDir, "assets");
+  if (!(0, import_node_fs.existsSync)(assetsDir)) return;
+  const files = await (0, import_promises3.readdir)(assetsDir);
+  const hashedWasm = files.find((f) => /^sqlite3-.+\.wasm$/.test(f));
+  if (hashedWasm && !files.includes("sqlite3.wasm")) {
+    await (0, import_promises3.copyFile)((0, import_node_path3.join)(assetsDir, hashedWasm), (0, import_node_path3.join)(assetsDir, "sqlite3.wasm"));
+  }
+  if (!files.includes("sqlite3-opfs-async-proxy.js")) {
+    const proxyFile = (0, import_node_path3.resolve)(
+      projectRoot,
+      "node_modules",
+      "@sqlite.org",
+      "sqlite-wasm",
+      "sqlite-wasm",
+      "jswasm",
+      "sqlite3-opfs-async-proxy.js"
+    );
+    if ((0, import_node_fs.existsSync)(proxyFile)) {
+      await (0, import_promises3.copyFile)(proxyFile, (0, import_node_path3.join)(assetsDir, "sqlite3-opfs-async-proxy.js"));
+    }
+  }
+}
+async function runProcess(command, args, cwd) {
+  await new Promise((resolve3, reject) => {
+    const child = (0, import_node_child_process.spawn)(command, args, {
+      cwd,
+      stdio: "inherit",
+      env: process.env
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve3();
+        return;
+      }
+      reject(new Error(`Client build failed with exit code ${String(code ?? "unknown")}.`));
+    });
+  });
+}
+
+// src/commands/deploy/builder/server-bundler.ts
+var import_promises4 = require("fs/promises");
+var import_promises5 = require("fs/promises");
+var import_node_path4 = 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_promises4.mkdir)(options.deployDirectory, { recursive: true });
+  const outputFilePath = (0, import_node_path4.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_path4.join)(projectRoot, candidate);
+    try {
+      await (0, import_promises5.access)(fullPath);
+      return fullPath;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/commands/deploy/adapters/aws-ecs-adapter.ts
+var AwsEcsAdapter = class {
+  name = "aws-ecs";
+  logger = createLogger();
+  runner;
+  currentContext;
+  constructor(options = {}) {
+    this.runner = options.runner ?? new NodeAwsCommandRunner();
+    this.currentContext = options.context ?? null;
+  }
+  setContext(context) {
+    this.currentContext = context;
+  }
+  async detect() {
+    const result = await this.runner.run("aws", ["--version"], process.cwd());
+    return result.exitCode === 0;
+  }
+  async install() {
+    const available = await this.detect();
+    if (!available) {
+      throw new Error(
+        "AWS CLI is required but not installed. Install from https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html"
+      );
+    }
+  }
+  async authenticate() {
+    const cwd = this.currentContext?.projectRoot ?? process.cwd();
+    const result = await this.runner.run("aws", ["sts", "get-caller-identity"], cwd);
+    if (result.exitCode !== 0) {
+      throw new Error(
+        "AWS CLI is not authenticated. Run `aws configure` or set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables."
+      );
+    }
+  }
+  async provision(config) {
+    this.currentContext = {
+      projectRoot: config.projectRoot,
+      appName: config.appName,
+      region: config.region ?? "us-east-1"
+    };
+    const region = config.region ?? "us-east-1";
+    const repoName = `kora/${config.appName}`;
+    const createRepo = await this.runner.run(
+      "aws",
+      [
+        "ecr",
+        "create-repository",
+        "--repository-name",
+        repoName,
+        "--region",
+        region,
+        "--image-scanning-configuration",
+        "scanOnPush=true"
+      ],
+      config.projectRoot
+    );
+    if (createRepo.exitCode !== 0 && !createRepo.stderr.includes("RepositoryAlreadyExistsException")) {
+      throw new Error(`Failed to create ECR repository: ${createRepo.stderr}`);
+    }
+    const identity = await this.runner.run(
+      "aws",
+      ["sts", "get-caller-identity", "--query", "Account", "--output", "text"],
+      config.projectRoot
+    );
+    const accountId = identity.stdout.trim();
+    await this.runner.run(
+      "aws",
+      ["ecs", "create-cluster", "--cluster-name", config.appName, "--region", region],
+      config.projectRoot
+    );
+    await this.runner.run(
+      "aws",
+      [
+        "logs",
+        "create-log-group",
+        "--log-group-name",
+        `/ecs/${config.appName}`,
+        "--region",
+        region
+      ],
+      config.projectRoot
+    );
+    return {
+      applicationId: `${accountId}.dkr.ecr.${region}.amazonaws.com/${repoName}`,
+      databaseId: null,
+      secretsSet: ["PORT"]
+    };
+  }
+  async build(config) {
+    this.currentContext = {
+      projectRoot: config.projectRoot,
+      appName: config.appName,
+      region: config.region
+    };
+    const deployDirectory = (0, import_node_path5.join)(config.projectRoot, ".kora", "deploy");
+    await bundleServer({
+      projectRoot: config.projectRoot,
+      deployDirectory
+    });
+    const client = config.deployTarget === "sync-server" ? null : await buildClient({
+      projectRoot: config.projectRoot,
+      outDir: (0, import_node_path5.join)(deployDirectory, "dist"),
+      mode: "production"
+    });
+    return {
+      clientDirectory: client?.outDir ?? null,
+      serverBundlePath: (0, import_node_path5.join)(deployDirectory, "server-bundled.js"),
+      deployDirectory
+    };
+  }
+  async deploy(artifacts) {
+    const context = this.requireContext();
+    const region = context.region ?? "us-east-1";
+    const repoName = `kora/${context.appName}`;
+    const loginPassword = await this.runner.run(
+      "aws",
+      ["ecr", "get-login-password", "--region", region],
+      context.projectRoot
+    );
+    if (loginPassword.exitCode !== 0) {
+      throw new Error(`ECR login failed: ${loginPassword.stderr}`);
+    }
+    const identity = await this.runner.run(
+      "aws",
+      ["sts", "get-caller-identity", "--query", "Account", "--output", "text"],
+      context.projectRoot
+    );
+    const accountId = identity.stdout.trim();
+    const ecrUri = `${accountId}.dkr.ecr.${region}.amazonaws.com`;
+    const imageUri = `${ecrUri}/${repoName}:latest`;
+    const dockerLogin = await this.runner.run(
+      "docker",
+      ["login", "--username", "AWS", "--password-stdin", ecrUri],
+      artifacts.deployDirectory
+    );
+    this.logger.step("Building Docker image...");
+    const dockerBuild = await this.runner.run(
+      "docker",
+      ["build", "--platform", "linux/amd64", "-t", imageUri, "."],
+      artifacts.deployDirectory
+    );
+    if (dockerBuild.exitCode !== 0) {
+      throw new Error(`Docker build failed: ${dockerBuild.stderr}`);
+    }
+    this.logger.step("Pushing image to ECR...");
+    const dockerPush = await this.runner.run(
+      "docker",
+      ["push", imageUri],
+      artifacts.deployDirectory
+    );
+    if (dockerPush.exitCode !== 0) {
+      throw new Error(`Docker push failed: ${dockerPush.stderr}`);
+    }
+    const taskDef = JSON.stringify({
+      family: context.appName,
+      networkMode: "awsvpc",
+      requiresCompatibilities: ["FARGATE"],
+      cpu: "256",
+      memory: "512",
+      executionRoleArn: `arn:aws:iam::${accountId}:role/ecsTaskExecutionRole`,
+      containerDefinitions: [
+        {
+          name: context.appName,
+          image: imageUri,
+          essential: true,
+          portMappings: [{ containerPort: 3001, protocol: "tcp" }],
+          logConfiguration: {
+            logDriver: "awslogs",
+            options: {
+              "awslogs-group": `/ecs/${context.appName}`,
+              "awslogs-region": region,
+              "awslogs-stream-prefix": "ecs"
+            }
+          },
+          healthCheck: {
+            command: ["CMD-SHELL", "curl -f http://localhost:3001/health || exit 1"],
+            interval: 30,
+            timeout: 5,
+            retries: 3,
+            startPeriod: 60
+          }
+        }
+      ]
+    });
+    const registerTask = await this.runner.run(
+      "aws",
+      ["ecs", "register-task-definition", "--cli-input-json", taskDef, "--region", region],
+      context.projectRoot
+    );
+    if (registerTask.exitCode !== 0) {
+      throw new Error(`Task definition registration failed: ${registerTask.stderr}`);
+    }
+    const updateService = await this.runner.run(
+      "aws",
+      [
+        "ecs",
+        "update-service",
+        "--cluster",
+        context.appName,
+        "--service",
+        context.appName,
+        "--task-definition",
+        context.appName,
+        "--force-new-deployment",
+        "--region",
+        region
+      ],
+      context.projectRoot
+    );
+    const deploymentId = (/* @__PURE__ */ new Date()).toISOString();
+    if (updateService.exitCode !== 0) {
+      this.logger.step("Service not found, creating new service...");
+      this.logger.step(
+        `Task definition registered. Create the ECS service with:
+  aws ecs create-service \\
+    --cluster ${context.appName} \\
+    --service-name ${context.appName} \\
+    --task-definition ${context.appName} \\
+    --desired-count 1 \\
+    --launch-type FARGATE \\
+    --network-configuration "awsvpcConfiguration={subnets=[<subnet-id>],securityGroups=[<sg-id>],assignPublicIp=ENABLED}" \\
+    --region ${region}`
+      );
+    }
+    return {
+      deploymentId,
+      liveUrl: `https://${context.appName}.${region}.amazonaws.com`,
+      syncUrl: `wss://${context.appName}.${region}.amazonaws.com/kora-sync`
+    };
+  }
+  async rollback(deploymentId) {
+    const context = this.requireContext();
+    const region = context.region ?? "us-east-1";
+    const result = await this.runner.run(
+      "aws",
+      [
+        "ecs",
+        "update-service",
+        "--cluster",
+        context.appName,
+        "--service",
+        context.appName,
+        "--task-definition",
+        `${context.appName}:${deploymentId}`,
+        "--force-new-deployment",
+        "--region",
+        region
+      ],
+      context.projectRoot
+    );
+    if (result.exitCode !== 0) {
+      throw new Error(`ECS rollback failed: ${result.stderr}`);
+    }
+  }
+  async *logs(options) {
+    const context = this.requireContext();
+    const region = context.region ?? "us-east-1";
+    const args = [
+      "logs",
+      "get-log-events",
+      "--log-group-name",
+      `/ecs/${context.appName}`,
+      "--log-stream-name",
+      "ecs/latest",
+      "--region",
+      region
+    ];
+    if (options.tail) {
+      args.push("--limit", String(options.tail));
+    }
+    const result = await this.runner.run("aws", args, context.projectRoot);
+    if (result.exitCode !== 0) {
+      return;
+    }
+    try {
+      const parsed = JSON.parse(result.stdout);
+      for (const event of parsed.events ?? []) {
+        yield {
+          timestamp: new Date(event.timestamp).toISOString(),
+          level: inferLogLevel(event.message),
+          message: event.message
+        };
+      }
+    } catch {
+      for (const line of result.stdout.split("\n").filter(Boolean)) {
+        yield { timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", message: line };
+      }
+    }
+  }
+  async status() {
+    const context = this.requireContext();
+    const region = context.region ?? "us-east-1";
+    const result = await this.runner.run(
+      "aws",
+      [
+        "ecs",
+        "describe-services",
+        "--cluster",
+        context.appName,
+        "--services",
+        context.appName,
+        "--region",
+        region
+      ],
+      context.projectRoot
+    );
+    if (result.exitCode !== 0) {
+      return { state: "failed", message: result.stderr };
+    }
+    try {
+      const parsed = JSON.parse(result.stdout);
+      const service = parsed.services?.[0];
+      if (!service) {
+        return { state: "unknown", message: "Service not found" };
+      }
+      if (service.status === "ACTIVE" && service.runningCount > 0) {
+        return {
+          state: "healthy",
+          message: `Running ${service.runningCount}/${service.desiredCount} tasks`
+        };
+      }
+      return {
+        state: service.runningCount === 0 ? "pending" : "healthy",
+        message: `Status: ${service.status}, running: ${service.runningCount}/${service.desiredCount}`
+      };
+    } catch {
+      return { state: "unknown", message: "Could not parse service status" };
+    }
+  }
+  requireContext() {
+    if (!this.currentContext) {
+      throw new Error("AWS ECS adapter context is not initialized. Run provision() first.");
+    }
+    return this.currentContext;
+  }
+};
+var NodeAwsCommandRunner = class {
+  async run(command, args, cwd) {
+    return new Promise((resolve3) => {
+      const child = (0, import_node_child_process2.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) => {
+        resolve3({ exitCode: 1, stdout, stderr: `${stderr}
+${error.message}` });
+      });
+      child.on("exit", (code) => {
+        resolve3({ exitCode: code ?? 1, stdout: stdout.trim(), stderr: stderr.trim() });
+      });
+    });
+  }
+};
+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";
+}
+
+// src/commands/deploy/adapters/aws-lightsail-adapter.ts
+var import_node_child_process3 = require("child_process");
+var import_node_path6 = require("path");
+var AwsLightsailAdapter = class {
+  name = "aws-lightsail";
+  logger = createLogger();
+  runner;
+  currentContext;
+  constructor(options = {}) {
+    this.runner = options.runner ?? new NodeAwsLightsailCommandRunner();
+    this.currentContext = options.context ?? null;
+  }
+  setContext(context) {
+    this.currentContext = context;
+  }
+  async detect() {
+    const result = await this.runner.run("aws", ["--version"], process.cwd());
+    return result.exitCode === 0;
+  }
+  async install() {
+    const available = await this.detect();
+    if (!available) {
+      throw new Error(
+        "AWS CLI is required but not installed. Install from https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html"
+      );
+    }
+  }
+  async authenticate() {
+    const cwd = this.currentContext?.projectRoot ?? process.cwd();
+    const result = await this.runner.run("aws", ["sts", "get-caller-identity"], cwd);
+    if (result.exitCode !== 0) {
+      throw new Error(
+        "AWS CLI is not authenticated. Run `aws configure` or set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables."
+      );
+    }
+  }
+  async provision(config) {
+    this.currentContext = {
+      projectRoot: config.projectRoot,
+      appName: config.appName,
+      region: config.region ?? "us-east-1"
+    };
+    const region = config.region ?? "us-east-1";
+    const serviceName = sanitizeLightsailName(config.appName);
+    const createService = await this.runner.run(
+      "aws",
+      [
+        "lightsail",
+        "create-container-service",
+        "--service-name",
+        serviceName,
+        "--power",
+        "nano",
+        "--scale",
+        "1",
+        "--region",
+        region
+      ],
+      config.projectRoot
+    );
+    if (createService.exitCode !== 0 && !createService.stderr.includes("already exists")) {
+      throw new Error(`Failed to create Lightsail container service: ${createService.stderr}`);
+    }
+    return {
+      applicationId: serviceName,
+      databaseId: null,
+      secretsSet: ["PORT"]
+    };
+  }
+  async build(config) {
+    this.currentContext = {
+      projectRoot: config.projectRoot,
+      appName: config.appName,
+      region: config.region
+    };
+    const deployDirectory = (0, import_node_path6.join)(config.projectRoot, ".kora", "deploy");
+    await bundleServer({
+      projectRoot: config.projectRoot,
+      deployDirectory
+    });
+    const client = config.deployTarget === "sync-server" ? null : await buildClient({
+      projectRoot: config.projectRoot,
+      outDir: (0, import_node_path6.join)(deployDirectory, "dist"),
+      mode: "production"
+    });
+    return {
+      clientDirectory: client?.outDir ?? null,
+      serverBundlePath: (0, import_node_path6.join)(deployDirectory, "server-bundled.js"),
+      deployDirectory
+    };
+  }
+  async deploy(artifacts) {
+    const context = this.requireContext();
+    const region = context.region ?? "us-east-1";
+    const serviceName = sanitizeLightsailName(context.appName);
+    const imageTag = `${serviceName}:latest`;
+    this.logger.step("Building Docker image...");
+    const dockerBuild = await this.runner.run(
+      "docker",
+      ["build", "--platform", "linux/amd64", "-t", imageTag, "."],
+      artifacts.deployDirectory
+    );
+    if (dockerBuild.exitCode !== 0) {
+      throw new Error(`Docker build failed: ${dockerBuild.stderr}`);
+    }
+    this.logger.step("Pushing image to Lightsail...");
+    const pushImage = await this.runner.run(
+      "aws",
+      [
+        "lightsail",
+        "push-container-image",
+        "--service-name",
+        serviceName,
+        "--label",
+        "latest",
+        "--image",
+        imageTag,
+        "--region",
+        region
+      ],
+      artifacts.deployDirectory
+    );
+    if (pushImage.exitCode !== 0) {
+      throw new Error(`Lightsail image push failed: ${pushImage.stderr}`);
+    }
+    const lightsailImage = parseLightsailImageRef(pushImage.stdout) ?? `:${serviceName}.latest.1`;
+    this.logger.step("Creating Lightsail deployment...");
+    const environment = { PORT: "3001" };
+    for (const key of PASSTHROUGH_ENV_VARS) {
+      const value = process.env[key];
+      if (value) {
+        environment[key] = value;
+      }
+    }
+    const containers = JSON.stringify({
+      [serviceName]: {
+        image: lightsailImage,
+        ports: { "3001": "HTTP" },
+        environment
+      }
+    });
+    const publicEndpoint = JSON.stringify({
+      containerName: serviceName,
+      containerPort: 3001,
+      healthCheck: {
+        path: "/health",
+        intervalSeconds: 30,
+        timeoutSeconds: 5,
+        healthyThreshold: 2,
+        unhealthyThreshold: 3
+      }
+    });
+    const createDeploy = await this.runner.run(
+      "aws",
+      [
+        "lightsail",
+        "create-container-service-deployment",
+        "--service-name",
+        serviceName,
+        "--containers",
+        containers,
+        "--public-endpoint",
+        publicEndpoint,
+        "--region",
+        region
+      ],
+      context.projectRoot
+    );
+    if (createDeploy.exitCode !== 0) {
+      throw new Error(`Lightsail deployment failed: ${createDeploy.stderr}`);
+    }
+    const serviceInfo = await this.runner.run(
+      "aws",
+      ["lightsail", "get-container-services", "--service-name", serviceName, "--region", region],
+      context.projectRoot
+    );
+    const rawUrl = parseLightsailUrl(serviceInfo.stdout) ?? `https://${serviceName}.${region}.cs.amazonlightsail.com`;
+    const serviceUrl = rawUrl.replace(/\/+$/, "");
+    const deploymentId = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      deploymentId,
+      liveUrl: serviceUrl,
+      syncUrl: `${serviceUrl.replace("https://", "wss://")}/kora-sync`
+    };
+  }
+  async rollback(_deploymentId) {
+    const context = this.requireContext();
+    const region = context.region ?? "us-east-1";
+    const serviceName = sanitizeLightsailName(context.appName);
+    const deployments = await this.runner.run(
+      "aws",
+      [
+        "lightsail",
+        "get-container-service-deployments",
+        "--service-name",
+        serviceName,
+        "--region",
+        region
+      ],
+      context.projectRoot
+    );
+    if (deployments.exitCode !== 0) {
+      throw new Error(`Lightsail rollback failed: ${deployments.stderr}`);
+    }
+    const previousDeployment = parsePreviousDeployment(deployments.stdout, serviceName);
+    if (!previousDeployment) {
+      throw new Error("No previous deployment found to rollback to.");
+    }
+    const redeploy = await this.runner.run(
+      "aws",
+      [
+        "lightsail",
+        "create-container-service-deployment",
+        "--service-name",
+        serviceName,
+        "--containers",
+        JSON.stringify(previousDeployment.containers),
+        "--public-endpoint",
+        JSON.stringify(previousDeployment.publicEndpoint),
+        "--region",
+        region
+      ],
+      context.projectRoot
+    );
+    if (redeploy.exitCode !== 0) {
+      throw new Error(`Lightsail rollback deployment failed: ${redeploy.stderr}`);
+    }
+  }
+  async *logs(options) {
+    const context = this.requireContext();
+    const region = context.region ?? "us-east-1";
+    const serviceName = sanitizeLightsailName(context.appName);
+    const args = [
+      "lightsail",
+      "get-container-log",
+      "--service-name",
+      serviceName,
+      "--container-name",
+      serviceName,
+      "--region",
+      region
+    ];
+    if (options.since) {
+      args.push("--start-time", options.since);
+    }
+    const result = await this.runner.run("aws", args, context.projectRoot);
+    if (result.exitCode !== 0) {
+      return;
+    }
+    try {
+      const parsed = JSON.parse(result.stdout);
+      const events = parsed.logEvents ?? [];
+      const limited = options.tail ? events.slice(-options.tail) : events;
+      for (const event of limited) {
+        yield {
+          timestamp: event.createdAt,
+          level: inferLogLevel2(event.message),
+          message: event.message
+        };
+      }
+    } catch {
+      for (const line of result.stdout.split("\n").filter(Boolean)) {
+        yield { timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", message: line };
+      }
+    }
+  }
+  async status() {
+    const context = this.requireContext();
+    const region = context.region ?? "us-east-1";
+    const serviceName = sanitizeLightsailName(context.appName);
+    const result = await this.runner.run(
+      "aws",
+      ["lightsail", "get-container-services", "--service-name", serviceName, "--region", region],
+      context.projectRoot
+    );
+    if (result.exitCode !== 0) {
+      return { state: "failed", message: result.stderr };
+    }
+    try {
+      const parsed = JSON.parse(result.stdout);
+      const service = parsed.containerServices?.[0];
+      if (!service) {
+        return { state: "unknown", message: "Container service not found" };
+      }
+      const deployState = service.currentDeployment?.state ?? "UNKNOWN";
+      if (service.state === "RUNNING" && deployState === "ACTIVE") {
+        return {
+          state: "healthy",
+          message: "Lightsail container service is running",
+          liveUrl: service.url
+        };
+      }
+      if (service.state === "DEPLOYING" || deployState === "ACTIVATING") {
+        return {
+          state: "pending",
+          message: `Service: ${service.state}, Deployment: ${deployState}`
+        };
+      }
+      return {
+        state: service.state === "DISABLED" ? "failed" : "unknown",
+        message: `Service: ${service.state}, Deployment: ${deployState}`
+      };
+    } catch {
+      return { state: "unknown", message: "Could not parse service status" };
+    }
+  }
+  requireContext() {
+    if (!this.currentContext) {
+      throw new Error("AWS Lightsail adapter context is not initialized. Run provision() first.");
+    }
+    return this.currentContext;
+  }
+};
+var NodeAwsLightsailCommandRunner = class {
+  async run(command, args, cwd) {
+    return new Promise((resolve3) => {
+      const child = (0, import_node_child_process3.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) => {
+        resolve3({ exitCode: 1, stdout, stderr: `${stderr}
+${error.message}` });
+      });
+      child.on("exit", (code) => {
+        resolve3({ exitCode: code ?? 1, stdout: stdout.trim(), stderr: stderr.trim() });
+      });
+    });
+  }
+};
+var PASSTHROUGH_ENV_VARS = ["DATABASE_URL", "AUTH_SECRET", "PUBLIC_URL", "NODE_ENV"];
+function sanitizeLightsailName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-{2,}/g, "-").replace(/^-|-$/g, "").slice(0, 255) || "kora-app";
+}
+function parseLightsailImageRef(output) {
+  const match = output.match(/Refer to this image as\s+"?(:[^"\s]+)"?/i);
+  if (match?.[1]) {
+    return match[1];
+  }
+  const refMatch = output.match(/(:\S+\.\S+\.\d+)/);
+  return refMatch?.[1] ?? null;
+}
+function parseLightsailUrl(rawJson) {
+  try {
+    const parsed = JSON.parse(rawJson);
+    const url = parsed.containerServices?.[0]?.url;
+    if (typeof url === "string" && url.length > 0) {
+      return url.startsWith("https://") ? url : `https://${url}`;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function parsePreviousDeployment(rawJson, serviceName) {
+  try {
+    const parsed = JSON.parse(rawJson);
+    const deployments = parsed.deployments ?? [];
+    const previous = deployments.length > 1 ? deployments[1] : null;
+    if (!previous) return null;
+    return {
+      containers: previous.containers,
+      publicEndpoint: previous.publicEndpoint
+    };
+  } catch {
+    return null;
+  }
+}
+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";
+}
+
+// src/commands/deploy/adapters/fly-adapter.ts
+var import_node_child_process4 = require("child_process");
+var import_node_path8 = require("path");
+
+// src/commands/deploy/artifacts/fly-toml-generator.ts
+var import_promises6 = require("fs/promises");
+var import_node_path7 = 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 = "/health"',
+    ""
+  ].join("\n");
+}
+async function writeFlyTomlArtifact(deployDirectory, options) {
+  await (0, import_promises6.mkdir)(deployDirectory, { recursive: true });
+  const filePath = (0, import_node_path7.join)(deployDirectory, "fly.toml");
+  await (0, import_promises6.writeFile)(filePath, generateFlyToml(options), "utf-8");
+  return filePath;
+}
+
+// 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_path8.join)(config.projectRoot, ".kora", "deploy");
+    await writeFlyTomlArtifact(deployDirectory, {
+      appName: config.appName,
+      region: config.region ?? "iad"
+    });
+    await bundleServer({
+      projectRoot: config.projectRoot,
+      deployDirectory
+    });
+    const client = config.deployTarget === "sync-server" ? null : await buildClient({
+      projectRoot: config.projectRoot,
+      outDir: (0, import_node_path8.join)(deployDirectory, "dist"),
+      mode: "production"
+    });
+    return {
+      clientDirectory: client?.outDir ?? null,
+      serverBundlePath: (0, import_node_path8.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: inferLogLevel3(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((resolve3) => {
+      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) => {
+        resolve3({
+          exitCode: 1,
+          stdout,
+          stderr: `${stderr}
+${error.message}`
+        });
+      });
+      child.on("exit", (code) => {
+        resolve3({
+          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 inferLogLevel3(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_path10 = require("path");
+
+// src/commands/deploy/artifacts/railway-json-generator.ts
+var import_promises7 = require("fs/promises");
+var import_node_path9 = 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_promises7.mkdir)(deployDirectory, { recursive: true });
+  const filePath = (0, import_node_path9.join)(deployDirectory, "railway.json");
+  await (0, import_promises7.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_path10.join)(config.projectRoot, ".kora", "deploy");
+    await writeRailwayJsonArtifact(deployDirectory, {
+      appName: config.appName,
+      environment: config.environment
+    });
+    await bundleServer({
+      projectRoot: config.projectRoot,
+      deployDirectory
+    });
+    const client = config.deployTarget === "sync-server" ? null : await buildClient({
+      projectRoot: config.projectRoot,
+      outDir: (0, import_node_path10.join)(deployDirectory, "dist"),
+      mode: "production"
+    });
+    return {
+      clientDirectory: client?.outDir ?? null,
+      serverBundlePath: (0, import_node_path10.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: inferLogLevel4(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((resolve3) => {
+      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) => {
+        resolve3({
+          exitCode: 1,
+          stdout,
+          stderr: `${stderr}
+${error.message}`
+        });
+      });
+      child.on("exit", (code) => {
+        resolve3({
+          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 inferLogLevel4(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()
+    };
+  }
+  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 "aws-ecs":
+      return new AwsEcsAdapter();
+    case "aws-lightsail":
+      return new AwsLightsailAdapter();
+    case "render":
+    case "docker":
+    case "kora-cloud":
+      return new StubDeployAdapter(platform);
+    default: {
+      const exhaustiveCheck = platform;
+      return exhaustiveCheck;
+    }
+  }
+}
+
+// src/commands/deploy/artifacts/dockerfile-generator.ts
+var import_promises8 = require("fs/promises");
+var import_node_path11 = 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 === void 0 ? "dist" : options.clientDirectory;
+  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("");
+  }
+  if (clientDirectory !== null) {
+    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)}
+`;
+}
+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_promises8.mkdir)(deployDirectory, { recursive: true });
+  const dockerfilePath = (0, import_node_path11.join)(deployDirectory, "Dockerfile");
+  await (0, import_promises8.writeFile)(dockerfilePath, generateDockerfile(options), "utf-8");
+  if (options.nativeDependencies && Object.keys(options.nativeDependencies).length > 0) {
+    const pkgJsonPath = (0, import_node_path11.join)(deployDirectory, "package.json");
+    await (0, import_promises8.writeFile)(pkgJsonPath, generateDeployPackageJson(options.nativeDependencies), "utf-8");
+  }
+  return dockerfilePath;
+}
+async function writeDockerIgnoreArtifact(deployDirectory) {
+  await (0, import_promises8.mkdir)(deployDirectory, { recursive: true });
+  const dockerIgnorePath = (0, import_node_path11.join)(deployDirectory, ".dockerignore");
+  await (0, import_promises8.writeFile)(dockerIgnorePath, generateDockerIgnore(), "utf-8");
+  return dockerIgnorePath;
+}
+
+// src/commands/deploy/state/deploy-state.ts
+var import_promises9 = require("fs/promises");
+var import_node_path12 = require("path");
+var KORA_DEPLOY_DIRECTORY = (0, import_node_path12.join)(".kora", "deploy");
+var DEPLOY_STATE_FILENAME = "deploy.json";
+function resolveDeployDirectory(projectRoot) {
+  return (0, import_node_path12.join)(projectRoot, KORA_DEPLOY_DIRECTORY);
+}
+function resolveDeployStatePath(projectRoot) {
+  return (0, import_node_path12.join)(resolveDeployDirectory(projectRoot), DEPLOY_STATE_FILENAME);
+}
+async function readDeployState(projectRoot) {
+  const statePath = resolveDeployStatePath(projectRoot);
+  try {
+    const source = await (0, import_promises9.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;
+  }
+}
+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 persistDeployState(projectRoot, state);
+  return state;
+}
+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_promises9.rm)(resolveDeployDirectory(projectRoot), { recursive: true, force: true });
+}
+async function persistDeployState(projectRoot, state) {
+  const deployDir = resolveDeployDirectory(projectRoot);
+  const statePath = resolveDeployStatePath(projectRoot);
+  await (0, import_promises9.mkdir)(deployDir, { recursive: true });
+  await (0, import_promises9.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/deploy/deploy-command.ts
+var deployCommand = (0, import_citty2.defineCommand)({
+  meta: {
+    name: "deploy",
+    description: "Deploy a Kora project to your selected platform"
+  },
+  args: {
+    platform: {
+      type: "string",
+      description: `Deployment platform (${DEPLOY_PLATFORMS.join(", ")})`
+    },
+    app: {
+      type: "string",
+      description: "Application name used by the target platform"
+    },
+    region: {
+      type: "string",
+      description: "Preferred deployment region (for example: iad, lhr, syd)"
+    },
+    prod: {
+      type: "boolean",
+      description: "Deploy to production environment",
+      default: false
+    },
+    confirm: {
+      type: "boolean",
+      description: "Non-interactive mode (fail fast on missing required data)",
+      default: false
+    },
+    reset: {
+      type: "boolean",
+      description: "Delete .kora/deploy state and generated artifacts",
+      default: false
+    }
+  },
+  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();
+    const prompts = createPromptClient();
+    const projectRoot = await requireProjectRoot();
+    if (args.reset === true) {
+      await resetDeployState(projectRoot);
+      logger.success("Reset .kora/deploy state.");
+      return;
+    }
+    const existingState = await readDeployState(projectRoot);
+    const confirmMode = args.confirm === true;
+    const platform = await resolvePlatform({
+      promptClient: prompts,
+      platformArg: args.platform,
+      storedPlatform: existingState?.platform,
+      confirm: confirmMode
+    });
+    if (!isImplementedDeployPlatform(platform)) {
+      throw new DeployPlatformUnavailableError(platform, IMPLEMENTED_DEPLOY_PLATFORMS);
+    }
+    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 deployTarget = detectDeployTarget(projectRoot);
+    const config = {
+      projectRoot,
+      appName,
+      region,
+      environment,
+      confirm: confirmMode,
+      deployTarget
+    };
+    const adapter = createDeployAdapter(platform);
+    configureAdapterContext(adapter, {
+      projectRoot,
+      appName,
+      region
+    });
+    logger.banner();
+    logger.info(
+      `Deploying to ${platform} (${appName}${region ? `, ${region}` : ""}, ${environment})`
+    );
+    if (deployTarget === "sync-server") {
+      logger.step("Detected Tauri project. Deploying the sync server only.");
+    }
+    if (confirmMode) {
+      logger.step("Running in --confirm mode (non-interactive, fail-fast).");
+    }
+    await writeDockerfileArtifact(deployDirectory, {
+      clientDirectory: deployTarget === "sync-server" ? null : void 0,
+      nativeDependencies: {
+        "better-sqlite3": "^11.0.0",
+        "drizzle-orm": "^0.45.2",
+        postgres: "^3.4.0"
+      }
+    });
+    await writeDockerIgnoreArtifact(deployDirectory);
+    const detected = await adapter.detect();
+    if (!detected) {
+      await adapter.install();
+    }
+    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
+      });
+    }
+    logger.success(`Deployment completed: ${deployResult.liveUrl}`);
+    if (deployResult.syncUrl) {
+      logger.step(`Sync endpoint: ${deployResult.syncUrl}`);
+    }
+  }
+});
+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: "AWS ECS Fargate (production multi-instance)",
+      value: "aws-ecs"
+    },
+    {
+      label: "AWS Lightsail Containers (simple, cost-effective)",
+      value: "aws-lightsail"
+    },
+    {
+      label: "Render (coming soon)",
+      value: "render"
+    },
+    {
+      label: "Docker (self-hosted, coming soon)",
+      value: "docker"
+    },
+    {
+      label: "Kora Cloud (coming soon)",
+      value: "kora-cloud"
+    }
+  ]);
+}
+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_path13.basename)(projectRoot));
+}
+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 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 detectDeployTarget(projectRoot) {
+  return (0, import_node_fs2.existsSync)((0, import_node_path13.join)(projectRoot, "src-tauri")) ? "sync-server" : "full-stack";
+}
+function hasContextSetter(adapter) {
+  return typeof adapter.setContext === "function";
+}
+
+// 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/options.ts
+function determineTemplateFromSelections(input) {
+  if (input.platform === "desktop-tauri") return "tauri-react";
+  const shouldSync = input.sync && input.db !== "none";
+  if (input.framework === "vue") {
+    if (input.tailwind && shouldSync) return "vue-tailwind-sync";
+    if (input.tailwind && !shouldSync) return "vue-tailwind";
+    return shouldSync ? "vue-sync" : "vue-basic";
+  }
+  if (input.framework === "svelte") {
+    if (input.tailwind && shouldSync) return "svelte-tailwind-sync";
+    if (input.tailwind && !shouldSync) return "svelte-tailwind";
+    return shouldSync ? "svelte-sync" : "svelte-basic";
+  }
+  if (input.framework === "solid") {
+    throw new Error("Solid templates are not available yet. Use react, vue, or svelte.");
+  }
+  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 isPlatformValue(value) {
+  return value === "web" || value === "desktop-tauri";
+}
+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/prompts/preferences.ts
+var import_conf = __toESM(require("conf"), 1);
+var DEFAULT_PREFERENCES = {
+  platform: "web",
+  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/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.platform !== void 0) {
+    if (!isPlatformValue(flags.platform)) {
+      throw new Error(
+        `Invalid --platform value "${flags.platform}". Expected one of: web, desktop-tauri.`
+      );
+    }
+    effective.platform = flags.platform;
+  } else if (!flags.useDefaults && !usedStoredPreferences) {
+    effective.platform = await prompts.select("Platform:", [
+      { label: "Web (browser)", value: "web" },
+      { label: "Desktop (Tauri \u2014 native SQLite)", value: "desktop-tauri" }
+    ]);
+  }
+  const isTauri = effective.platform === "desktop-tauri";
+  if (isTauri) {
+    effective.framework = "react";
+    effective.tailwind = false;
+    effective.auth = "none";
+    if (flags.sync !== void 0) {
+      effective.sync = flags.sync;
+    } else if (!flags.useDefaults && !usedStoredPreferences) {
+      effective.sync = await prompts.confirm("Enable multi-device sync?", true);
+    }
+    if (flags.db !== void 0) {
+      if (!isDatabaseValue(flags.db)) {
+        throw new Error(
+          `Invalid --db value "${flags.db}". Expected one of: none, sqlite, postgres.`
+        );
+      }
+      effective.db = flags.db;
+    } else if (!effective.sync) {
+      effective.db = "none";
+    } else if (!flags.useDefaults && !usedStoredPreferences) {
+      effective.db = await prompts.select("Sync server database:", [
+        { label: "SQLite (zero-config; local, LAN, small teams)", value: "sqlite" },
+        { label: "PostgreSQL (production-scale)", value: "postgres" }
+      ]);
+    }
+    if (effective.db === "none") {
+      effective.sync = false;
+    }
+    if (effective.db !== "postgres") {
+      effective.dbProvider = "none";
+    } else if (flags.dbProvider !== void 0) {
+      if (!isDatabaseProviderValue(flags.dbProvider)) {
+        throw new Error(
+          `Invalid --db-provider value "${flags.dbProvider}". Expected one of: none, local, supabase, neon, railway, vercel-postgres, custom.`
+        );
+      }
+      effective.dbProvider = flags.dbProvider;
+    } else if (!flags.useDefaults && !usedStoredPreferences) {
+      effective.dbProvider = await prompts.select("Database provider:", [
+        { label: "Local Postgres", value: "local" },
+        { label: "Supabase", value: "supabase" },
+        { label: "Neon", value: "neon" },
+        { label: "Railway", value: "railway" },
+        { label: "Vercel Postgres", value: "vercel-postgres" },
+        { label: "Custom connection string", value: "custom" }
+      ]);
+    }
+  } else {
+    if (flags.framework !== void 0) {
+      if (!isFrameworkValue(flags.framework)) {
+        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 3", value: "vue" },
+        { label: "Svelte 5", value: "svelte" },
+        { 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({
+    platform: effective.platform,
+    framework: effective.framework,
+    tailwind: effective.tailwind,
+    sync: effective.sync,
+    db: effective.db
+  });
+  return {
+    platform: effective.platform,
+    framework: effective.framework,
+    auth: effective.auth,
+    db: effective.db,
+    dbProvider: effective.dbProvider,
+    tailwind: effective.tailwind,
+    sync: effective.sync,
+    template,
+    usedStoredPreferences
+  };
+}
+function shouldSavePreferences(flags) {
+  return !flags.useDefaults;
+}
+function saveResolvedPreferences(store, resolution) {
+  store.saveCreatePreferences({
+    platform: resolution.platform,
+    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.platform !== void 0 || 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) {
+  if (preferences.platform === "desktop-tauri") {
+    return `Use previous settings (tauri-desktop + ${preferences.packageManager})`;
+  }
+  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/sync-provider-preset.ts
+var import_promises10 = require("fs/promises");
+var import_node_path14 = 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 envPath = (0, import_node_path14.join)(options.targetDir, ".env.example");
+  const readmePath = (0, import_node_path14.join)(options.targetDir, "README.md");
+  const existingReadme = await (0, import_promises10.readFile)(readmePath, "utf-8");
+  const existingEnv = await (0, import_promises10.readFile)(envPath, "utf-8");
+  const trimmedReadme = existingReadme.trimEnd();
+  const trimmedEnv = existingEnv.trimEnd();
+  const envSuffix = [
+    "",
+    `# PostgreSQL provider preset: ${providerName}`,
+    `# Example: ${providerConnectionString}`
+  ].join("\n");
+  const readmeSuffix = [
+    "",
+    "## PostgreSQL Provider Preset",
+    "",
+    `Selected DB provider: ${options.dbProvider}`,
+    "",
+    "This scaffold keeps one sync server entrypoint. When `DATABASE_URL` is set, `server.ts` uses PostgreSQL. When it is empty, the same server uses SQLite at `KORA_SERVER_DB`.",
+    "",
+    "The generated server uses `createPostgresServerStore` automatically when `DATABASE_URL` is present.",
+    ""
+  ].join("\n");
+  const readmeTemplate = `${trimmedReadme}${readmeSuffix}`;
+  await (0, import_promises10.writeFile)(envPath, `${trimmedEnv}${envSuffix}
+`, "utf-8");
+  await (0, import_promises10.writeFile)(readmePath, readmeTemplate, "utf-8");
+}
+function isSyncTemplate(template) {
+  return template === "react-sync" || template === "react-tailwind-sync" || template === "vue-sync" || template === "vue-tailwind-sync" || template === "svelte-sync" || template === "svelte-tailwind-sync" || template === "tauri-react";
+}
+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";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGENTS_FRAMEWORKS,
+  ClackPromptClient,
+  CliError,
+  DEPLOY_PLATFORMS,
+  DeployPlatformUnavailableError,
+  DevServerError,
+  FlyAdapter,
+  IMPLEMENTED_DEPLOY_PLATFORMS,
+  InvalidProjectError,
+  NodeFlyCommandRunner,
+  NodeRailwayCommandRunner,
+  PACKAGE_MANAGERS,
+  PreferenceStore,
+  ProjectExistsError,
+  PromptCancelledError,
+  RailwayAdapter,
+  ReadlinePromptClient,
+  SchemaNotFoundError,
+  StubDeployAdapter,
+  TEMPLATES,
+  TEMPLATE_INFO,
+  agentsCommand,
+  applySyncProviderPreset,
+  buildClient,
+  bundleServer,
+  createDeployAdapter,
+  createPromptClient,
+  deployCommand,
+  detectFrameworkFromManifest,
+  determineTemplateFromSelections,
+  generateAgentsMd,
+  generateDeployPackageJson,
+  generateDockerIgnore,
+  generateDockerfile,
+  generateFlyToml,
+  generateRailwayJson,
+  generateTypes,
+  getCreatePreferencesOrDefault,
+  getDefaultCreatePreferences,
+  isAgentsFramework,
+  isAuthValue,
+  isDatabaseProviderValue,
+  isDatabaseValue,
+  isDeployPlatform,
+  isFrameworkValue,
+  isImplementedDeployPlatform,
+  readDeployState,
+  resetDeployState,
+  resolveCreatePreferencesFlow,
+  resolveDeployDirectory,
+  resolveDeployStatePath,
+  saveResolvedPreferences,
+  shouldSavePreferences,
+  updateDeployState,
+  validateProjectName,
+  writeDeployState,
+  writeDockerIgnoreArtifact,
+  writeDockerfileArtifact,
+  writeFlyTomlArtifact,
+  writeRailwayJsonArtifact
+});
+//# sourceMappingURL=index.cjs.map