@korajs/cli 1.0.0-beta.12 → 1.0.0-beta.13

package/dist/bin.cjs

@@ -251,6 +251,15 @@ function parseJsonColumn(raw) {
     return null;
   }
 }
+function stripOpMetadata(data) {
+  if (data === null) return null;
+  const fields = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (key.startsWith("__kora_") && key.endsWith("__")) continue;
+    fields[key] = value;
+  }
+  return Object.keys(fields).length > 0 ? fields : null;
+}
 function parseJsonArrayColumn(raw) {
   if (typeof raw !== "string" || raw.length === 0) {
     return [];
@@ -464,7 +473,7 @@ var init_db_reader = __esm({
           nodeId: String(row.node_id),
           type: String(row.type),
           recordId: String(row.record_id),
-          data: parseJsonColumn(row.data),
+          data: stripOpMetadata(parseJsonColumn(row.data)),
           previousData: parseJsonColumn(row.previous_data),
           timestamp: parseVersionStamp(row.timestamp),
           sequenceNumber: Number(row.sequence_number),
@@ -1981,13 +1990,13 @@ var spectator_manager_exports = {};
 __export(spectator_manager_exports, {
   SpectatorManager: () => SpectatorManager
 });
-var import_node_fs7, import_node_os, import_node_path28, FORWARDED_EVENTS, MAX_EVENT_BUFFER, SpectatorManager;
+var import_node_fs7, import_node_os, import_node_path29, FORWARDED_EVENTS, MAX_EVENT_BUFFER, SpectatorManager;
 var init_spectator_manager = __esm({
   "src/commands/studio/spectator-manager.ts"() {
     "use strict";
     import_node_fs7 = require("fs");
     import_node_os = require("os");
-    import_node_path28 = require("path");
+    import_node_path29 = require("path");
     FORWARDED_EVENTS = [
       "merge:started",
       "merge:conflict",
@@ -2001,8 +2010,8 @@ var init_spectator_manager = __esm({
     SpectatorManager = class {
       constructor(options) {
         this.options = options;
-        this.tmpDir = (0, import_node_fs7.mkdtempSync)((0, import_node_path28.join)((0, import_node_os.tmpdir)(), "kora-studio-spectator-"));
-        this.dbPath = (0, import_node_path28.join)(this.tmpDir, "spectator-replica.db");
+        this.tmpDir = (0, import_node_fs7.mkdtempSync)((0, import_node_path29.join)((0, import_node_os.tmpdir)(), "kora-studio-spectator-"));
+        this.dbPath = (0, import_node_path29.join)(this.tmpDir, "spectator-replica.db");
       }
       options;
       runtime = null;
@@ -2185,13 +2194,13 @@ function summarizeEvent(type, payload) {
       return type.replace("lab:", "");
   }
 }
-var import_node_fs8, import_node_os2, import_node_path29, import_core3, DEFAULT_CHAOS, FORWARDED_EVENTS2, MAX_EVENT_BUFFER2, LabManager;
+var import_node_fs8, import_node_os2, import_node_path30, import_core3, DEFAULT_CHAOS, FORWARDED_EVENTS2, MAX_EVENT_BUFFER2, LabManager;
 var init_lab_manager = __esm({
   "src/commands/studio/lab-manager.ts"() {
     "use strict";
     import_node_fs8 = require("fs");
     import_node_os2 = require("os");
-    import_node_path29 = require("path");
+    import_node_path30 = require("path");
     import_core3 = require("@korajs/core");
     DEFAULT_CHAOS = {
       dropRate: 0,
@@ -2249,7 +2258,7 @@ var init_lab_manager = __esm({
       }
       async start(initialDevices = 2) {
         const harness = await this.loadHarness();
-        this.tmpDir = (0, import_node_fs8.mkdtempSync)((0, import_node_path29.join)((0, import_node_os2.tmpdir)(), "kora-studio-lab-"));
+        this.tmpDir = (0, import_node_fs8.mkdtempSync)((0, import_node_path30.join)((0, import_node_os2.tmpdir)(), "kora-studio-lab-"));
         this.server = new harness.TestServer(this.schema);
         for (let i = 0; i < initialDevices; i++) {
           await this.addDevice();
@@ -2301,7 +2310,7 @@ var init_lab_manager = __esm({
           nodeId: entry.device.getNodeId(),
           connected: entry.device.isConnected(),
           chaos: { ...entry.chaos },
-          dbPath: (0, import_node_path29.join)(this.tmpDir ?? "", `test-device-${name}.db`),
+          dbPath: (0, import_node_path30.join)(this.tmpDir ?? "", `test-device-${name}.db`),
           pendingOperations: entry.device.getSyncEngine()?.getStatus().pendingOperations ?? 0
         };
       }
@@ -2502,7 +2511,7 @@ await addTodo.mutateAsync({ title: 'x' })     // resolves with the result; throw
 const status = useSyncStatus()                // status.status, status.pendingOperations
 \`\`\`
 
-Rules: always render \`mutation.error\` somewhere. Keep \`<StrictMode>\` in place; the hooks are StrictMode-safe. \`useQuery\` returns data synchronously from the local store, so do not add loading spinners for local reads.`,
+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
@@ -2515,7 +2524,7 @@ addTodo.mutate({ title: 'x' })                // fire-and-forget; errors land in
 const status = useSyncStatus()                // status.status, status.pendingOperations
 \`\`\`
 
-Rules: surface the mutation's error state in the UI. \`useQuery\` reads synchronously from the local store, so avoid loading spinners for local data. The Kora context comes from \`KoraProvider\`, wired in your app entry (for example \`src/main.ts\`).`,
+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.
@@ -2530,7 +2539,7 @@ addTodo.mutate({ title: 'x' })                // fire-and-forget; errors land in
 const status = useSyncStatus()                // readable store; read $status.status in markup
 \`\`\`
 
-Rules: queries are reactive stores that read synchronously from the local database, so avoid loading spinners for local reads. Mutations expose an \`error\` state that must be surfaced in the UI.`
+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
@@ -2547,9 +2556,9 @@ This project uses **Kora.js**, an offline-first application framework. All appli
 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 fold 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.
+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 loading spinners for local reads.** \`useQuery\` returns data synchronously from the local store, so there is no loading state to wait on for local data.
+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
 
@@ -2587,15 +2596,15 @@ export default defineSchema({
 })
 \`\`\`
 
-If you change collection shapes, increment \`version\` and run \`npx kora migrate\`.
+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, add-wins for arrays, 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.
+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 by adding one line to \`createApp\`: \`createApp({ schema, sync: { url } })\`. When the app is offline, writes queue locally and sync when connectivity returns. If the project uses \`@korajs/auth\`, pass its client as \`createApp({ schema, sync: { url, authClient } })\`. Local writes work without sign-in; sync requires the server to accept the connection.
+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]}
 
@@ -2603,7 +2612,7 @@ ${FRAMEWORK_BINDINGS[framework]}
 
 - \`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\` applies a schema change to the local store.
+- \`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.
 `;
 }
@@ -2844,6 +2853,20 @@ var import_citty3 = require("citty");
 
 // src/errors.ts
 var import_core = require("@korajs/core");
+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(
@@ -3065,7 +3088,7 @@ var compactCommand = (0, import_citty3.defineCommand)({
 // src/commands/create/create-command.ts
 var import_node_child_process4 = require("child_process");
 var import_node_fs2 = require("fs");
-var import_node_path10 = require("path");
+var import_node_path11 = require("path");
 var import_node_url4 = require("url");
 var import_citty4 = require("citty");
 
@@ -3475,6 +3498,32 @@ function isSupportedWebFramework(framework) {
   return framework === "react" || framework === "vue" || framework === "svelte";
 }
 
+// src/commands/create/pnpm-workspace.ts
+var import_promises6 = require("fs/promises");
+var import_node_path8 = require("path");
+async function writePnpmWorkspaceSettings(targetDir) {
+  const manifest = JSON.parse(await (0, import_promises6.readFile)((0, import_node_path8.join)(targetDir, "package.json"), "utf-8"));
+  const listed = manifest.pnpm?.onlyBuiltDependencies;
+  const allowed = Array.isArray(listed) ? [...new Set(listed.filter((name) => typeof name === "string"))].sort() : [];
+  await (0, import_promises6.writeFile)((0, import_node_path8.join)(targetDir, "pnpm-workspace.yaml"), renderPnpmWorkspace(allowed), "utf-8");
+  return allowed;
+}
+function renderPnpmWorkspace(allowed) {
+  const quote = (name) => `'${name.replace(/'/g, "''")}'`;
+  const lines = [
+    "# pnpm settings for this app. Dependencies listed here may run their install",
+    "# (build) scripts: pnpm 10 reads onlyBuiltDependencies, pnpm 11+ reads allowBuilds.",
+    "packages:",
+    "  - '.'"
+  ];
+  if (allowed.length > 0) {
+    lines.push("onlyBuiltDependencies:", ...allowed.map((name) => `  - ${quote(name)}`));
+    lines.push("allowBuilds:", ...allowed.map((name) => `  ${quote(name)}: true`));
+  }
+  return `${lines.join("\n")}
+`;
+}
+
 // src/commands/create/preferences-flow.ts
 async function resolveCreatePreferencesFlow(params) {
   const { flags, prompts, store } = params;
@@ -3705,8 +3754,8 @@ function validateProjectName(name) {
 }
 
 // src/commands/create/sync-provider-preset.ts
-var import_promises6 = require("fs/promises");
-var import_node_path8 = require("path");
+var import_promises7 = require("fs/promises");
+var import_node_path9 = require("path");
 async function applySyncProviderPreset(options) {
   if (!isSyncTemplate(options.template)) {
     return;
@@ -3716,10 +3765,10 @@ async function applySyncProviderPreset(options) {
   }
   const providerName = getProviderDisplayName(options.dbProvider);
   const providerConnectionString = getProviderConnectionStringExample(options.dbProvider);
-  const envPath = (0, import_node_path8.join)(options.targetDir, ".env.example");
-  const readmePath = (0, import_node_path8.join)(options.targetDir, "README.md");
-  const existingReadme = await (0, import_promises6.readFile)(readmePath, "utf-8");
-  const existingEnv = await (0, import_promises6.readFile)(envPath, "utf-8");
+  const envPath = (0, import_node_path9.join)(options.targetDir, ".env.example");
+  const readmePath = (0, import_node_path9.join)(options.targetDir, "README.md");
+  const existingReadme = await (0, import_promises7.readFile)(readmePath, "utf-8");
+  const existingEnv = await (0, import_promises7.readFile)(envPath, "utf-8");
   const trimmedReadme = existingReadme.trimEnd();
   const trimmedEnv = existingEnv.trimEnd();
   const envSuffix = [
@@ -3739,9 +3788,9 @@ async function applySyncProviderPreset(options) {
     ""
   ].join("\n");
   const readmeTemplate = `${trimmedReadme}${readmeSuffix}`;
-  await (0, import_promises6.writeFile)(envPath, `${trimmedEnv}${envSuffix}
+  await (0, import_promises7.writeFile)(envPath, `${trimmedEnv}${envSuffix}
 `, "utf-8");
-  await (0, import_promises6.writeFile)(readmePath, readmeTemplate, "utf-8");
+  await (0, import_promises7.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";
@@ -3785,9 +3834,14 @@ function getProviderConnectionStringExample(provider) {
 
 // src/templates/composer.ts
 var import_node_fs = require("fs");
-var import_promises7 = require("fs/promises");
-var import_node_path9 = require("path");
+var import_promises8 = require("fs/promises");
+var import_node_path10 = require("path");
 var import_node_url3 = require("url");
+
+// src/templates/tauri-version.ts
+var KORA_TAURI_TEMPLATE_VERSION = "0.4.3-beta.12";
+
+// src/templates/composer.ts
 var import_meta = {};
 function substituteVariables(template, context) {
   return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
@@ -3796,16 +3850,16 @@ function substituteVariables(template, context) {
   });
 }
 function getTemplatePath(templateName) {
-  let dir = (0, import_node_path9.dirname)((0, import_node_url3.fileURLToPath)(import_meta.url));
+  let dir = (0, import_node_path10.dirname)((0, import_node_url3.fileURLToPath)(import_meta.url));
   for (let i = 0; i < 7; i++) {
-    const candidate = (0, import_node_path9.resolve)(dir, "templates", templateName);
+    const candidate = (0, import_node_path10.resolve)(dir, "templates", templateName);
     if ((0, import_node_fs.existsSync)(candidate)) {
       return candidate;
     }
-    dir = (0, import_node_path9.dirname)(dir);
+    dir = (0, import_node_path10.dirname)(dir);
   }
-  const currentDir = (0, import_node_path9.dirname)((0, import_node_url3.fileURLToPath)(import_meta.url));
-  return (0, import_node_path9.resolve)(currentDir, "..", "..", "..", "templates", templateName);
+  const currentDir = (0, import_node_path10.dirname)((0, import_node_url3.fileURLToPath)(import_meta.url));
+  return (0, import_node_path10.resolve)(currentDir, "..", "..", "..", "templates", templateName);
 }
 function createCompatibilityLayerPlan(templateName) {
   const baseLayer = { category: "base", name: "base", sourceTemplate: "react-basic" };
@@ -3927,6 +3981,7 @@ async function composeTemplateLayers(plan, targetDir, context) {
     projectName: context.projectName,
     packageManager: context.packageManager,
     koraVersion: context.koraVersion,
+    tauriVersion: context.tauriVersion ?? KORA_TAURI_TEMPLATE_VERSION,
     dbProvider: context.dbProvider ?? "none"
   };
   for (const layer of plan.layers) {
@@ -3938,22 +3993,22 @@ async function composeTemplateLayers(plan, targetDir, context) {
   }
 }
 async function copyDirectory(src, dest, vars) {
-  await (0, import_promises7.mkdir)(dest, { recursive: true });
-  const entries = await (0, import_promises7.readdir)(src);
+  await (0, import_promises8.mkdir)(dest, { recursive: true });
+  const entries = await (0, import_promises8.readdir)(src);
   for (const entry of entries) {
-    const srcPath = (0, import_node_path9.join)(src, entry);
-    const srcStat = await (0, import_promises7.stat)(srcPath);
+    const srcPath = (0, import_node_path10.join)(src, entry);
+    const srcStat = await (0, import_promises8.stat)(srcPath);
     if (srcStat.isDirectory()) {
-      await copyDirectory(srcPath, (0, import_node_path9.join)(dest, entry), vars);
+      await copyDirectory(srcPath, (0, import_node_path10.join)(dest, entry), vars);
       continue;
     }
     if (entry.endsWith(".hbs")) {
-      const content = await (0, import_promises7.readFile)(srcPath, "utf-8");
+      const content = await (0, import_promises8.readFile)(srcPath, "utf-8");
       const outputName = entry.slice(0, -4);
-      await (0, import_promises7.writeFile)((0, import_node_path9.join)(dest, outputName), substituteVariables(content, vars), "utf-8");
+      await (0, import_promises8.writeFile)((0, import_node_path10.join)(dest, outputName), substituteVariables(content, vars), "utf-8");
       continue;
     }
-    await (0, import_promises7.copyFile)(srcPath, (0, import_node_path9.join)(dest, entry));
+    await (0, import_promises8.copyFile)(srcPath, (0, import_node_path10.join)(dest, entry));
   }
 }
 
@@ -4106,7 +4161,7 @@ var createCommand = (0, import_citty4.defineCommand)({
       const editorDetection = detectEditorFromEnvironment();
       const gitContext = await detectGitContext(process.cwd());
       const monorepoContext = await detectMonorepoContext(process.cwd());
-      let targetDir = (0, import_node_path10.resolve)(process.cwd(), projectName);
+      let targetDir = (0, import_node_path11.resolve)(process.cwd(), projectName);
       if (!useDefaults && monorepoContext.isMonorepo && monorepoContext.root !== null) {
         const useWorkspaceTarget = await prompts.confirm(
           `Detected ${formatMonorepoKind(monorepoContext.kind)} at ${monorepoContext.root}. Create app under packages/${projectName}?`,
@@ -4133,6 +4188,9 @@ var createCommand = (0, import_citty4.defineCommand)({
         db: selection.db,
         dbProvider: selection.dbProvider
       });
+      if (pm === "pnpm") {
+        await writePnpmWorkspaceSettings(targetDir);
+      }
       if (!useDefaults && editorDetection.editor !== "unknown") {
         const shouldApplyEditorPreset = await prompts.confirm(
           `Detected ${formatEditor(editorDetection.editor)}. Add workspace recommendations for ${formatEditor(editorDetection.editor)}?`,
@@ -4276,16 +4334,16 @@ function relativeToTarget(targetDir, filePath) {
 }
 function resolveKoraVersion() {
   try {
-    let dir = (0, import_node_path10.dirname)((0, import_node_url4.fileURLToPath)(import_meta2.url));
+    let dir = (0, import_node_path11.dirname)((0, import_node_url4.fileURLToPath)(import_meta2.url));
     for (let i = 0; i < 5; i++) {
-      const pkgPath = (0, import_node_path10.resolve)(dir, "package.json");
+      const pkgPath = (0, import_node_path11.resolve)(dir, "package.json");
       if ((0, import_node_fs2.existsSync)(pkgPath)) {
         const pkg = JSON.parse((0, import_node_fs2.readFileSync)(pkgPath, "utf-8"));
         if (pkg.name === "@korajs/cli") {
           return deriveKoraTemplateVersion(pkg.version);
         }
       }
-      dir = (0, import_node_path10.dirname)(dir);
+      dir = (0, import_node_path11.dirname)(dir);
     }
     return "latest";
   } catch {
@@ -4301,7 +4359,7 @@ function deriveKoraTemplateVersion(version) {
 
 // src/commands/deploy/deploy-command.ts
 var import_node_fs4 = require("fs");
-var import_node_path21 = require("path");
+var import_node_path22 = require("path");
 var import_citty5 = require("citty");
 init_fs_helpers();
 
@@ -4315,19 +4373,23 @@ var DEPLOY_PLATFORMS = [
   "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_process6 = require("child_process");
-var import_node_path13 = require("path");
+var import_node_path14 = require("path");
 
 // src/commands/deploy/builder/client-builder.ts
 var import_node_child_process5 = require("child_process");
 var import_node_fs3 = require("fs");
-var import_promises8 = require("fs/promises");
-var import_node_path11 = require("path");
+var import_promises9 = require("fs/promises");
+var import_node_path12 = require("path");
 init_fs_helpers();
 async function buildClient(options) {
   const viteEntryPoint = await resolveProjectBinaryEntryPoint(options.projectRoot, "vite", "vite");
@@ -4349,15 +4411,15 @@ async function buildClient(options) {
   return { outDir: options.outDir };
 }
 async function patchSqliteWasmAssets(projectRoot, outDir) {
-  const assetsDir = (0, import_node_path11.join)(outDir, "assets");
+  const assetsDir = (0, import_node_path12.join)(outDir, "assets");
   if (!(0, import_node_fs3.existsSync)(assetsDir)) return;
-  const files = await (0, import_promises8.readdir)(assetsDir);
+  const files = await (0, import_promises9.readdir)(assetsDir);
   const hashedWasm = files.find((f) => /^sqlite3-.+\.wasm$/.test(f));
   if (hashedWasm && !files.includes("sqlite3.wasm")) {
-    await (0, import_promises8.copyFile)((0, import_node_path11.join)(assetsDir, hashedWasm), (0, import_node_path11.join)(assetsDir, "sqlite3.wasm"));
+    await (0, import_promises9.copyFile)((0, import_node_path12.join)(assetsDir, hashedWasm), (0, import_node_path12.join)(assetsDir, "sqlite3.wasm"));
   }
   if (!files.includes("sqlite3-opfs-async-proxy.js")) {
-    const proxyFile = (0, import_node_path11.resolve)(
+    const proxyFile = (0, import_node_path12.resolve)(
       projectRoot,
       "node_modules",
       "@sqlite.org",
@@ -4367,7 +4429,7 @@ async function patchSqliteWasmAssets(projectRoot, outDir) {
       "sqlite3-opfs-async-proxy.js"
     );
     if ((0, import_node_fs3.existsSync)(proxyFile)) {
-      await (0, import_promises8.copyFile)(proxyFile, (0, import_node_path11.join)(assetsDir, "sqlite3-opfs-async-proxy.js"));
+      await (0, import_promises9.copyFile)(proxyFile, (0, import_node_path12.join)(assetsDir, "sqlite3-opfs-async-proxy.js"));
     }
   }
 }
@@ -4392,9 +4454,9 @@ async function runProcess(command, args, cwd) {
 }
 
 // src/commands/deploy/builder/server-bundler.ts
-var import_promises9 = require("fs/promises");
 var import_promises10 = require("fs/promises");
-var import_node_path12 = require("path");
+var import_promises11 = require("fs/promises");
+var import_node_path13 = require("path");
 var import_esbuild = require("esbuild");
 var DEFAULT_ENTRY_CANDIDATES = [
   "server.ts",
@@ -4410,8 +4472,8 @@ async function bundleServer(options) {
       `Could not find a server entry file in ${options.projectRoot}. Looked for: ${candidates.join(", ")}`
     );
   }
-  await (0, import_promises9.mkdir)(options.deployDirectory, { recursive: true });
-  const outputFilePath = (0, import_node_path12.join)(options.deployDirectory, "server-bundled.js");
+  await (0, import_promises10.mkdir)(options.deployDirectory, { recursive: true });
+  const outputFilePath = (0, import_node_path13.join)(options.deployDirectory, "server-bundled.js");
   await (0, import_esbuild.build)({
     entryPoints: [entryFilePath],
     outfile: outputFilePath,
@@ -4433,9 +4495,9 @@ async function bundleServer(options) {
 }
 async function resolveServerEntry(projectRoot, candidates) {
   for (const candidate of candidates) {
-    const fullPath = (0, import_node_path12.join)(projectRoot, candidate);
+    const fullPath = (0, import_node_path13.join)(projectRoot, candidate);
     try {
-      await (0, import_promises10.access)(fullPath);
+      await (0, import_promises11.access)(fullPath);
       return fullPath;
     } catch {
     }
@@ -4537,19 +4599,19 @@ var AwsEcsAdapter = class {
       appName: config.appName,
       region: config.region
     };
-    const deployDirectory = (0, import_node_path13.join)(config.projectRoot, ".kora", "deploy");
+    const deployDirectory = (0, import_node_path14.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_path13.join)(deployDirectory, "dist"),
+      outDir: (0, import_node_path14.join)(deployDirectory, "dist"),
       mode: "production"
     });
     return {
       clientDirectory: client?.outDir ?? null,
-      serverBundlePath: (0, import_node_path13.join)(deployDirectory, "server-bundled.js"),
+      serverBundlePath: (0, import_node_path14.join)(deployDirectory, "server-bundled.js"),
       deployDirectory
     };
   }
@@ -4815,7 +4877,7 @@ function inferLogLevel(line) {
 
 // src/commands/deploy/adapters/aws-lightsail-adapter.ts
 var import_node_child_process7 = require("child_process");
-var import_node_path14 = require("path");
+var import_node_path15 = require("path");
 var AwsLightsailAdapter = class {
   name = "aws-lightsail";
   logger = createLogger();
@@ -4888,19 +4950,19 @@ var AwsLightsailAdapter = class {
       appName: config.appName,
       region: config.region
     };
-    const deployDirectory = (0, import_node_path14.join)(config.projectRoot, ".kora", "deploy");
+    const deployDirectory = (0, import_node_path15.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_path14.join)(deployDirectory, "dist"),
+      outDir: (0, import_node_path15.join)(deployDirectory, "dist"),
       mode: "production"
     });
     return {
       clientDirectory: client?.outDir ?? null,
-      serverBundlePath: (0, import_node_path14.join)(deployDirectory, "server-bundled.js"),
+      serverBundlePath: (0, import_node_path15.join)(deployDirectory, "server-bundled.js"),
       deployDirectory
     };
   }
@@ -5200,11 +5262,11 @@ function inferLogLevel2(line) {
 
 // src/commands/deploy/adapters/fly-adapter.ts
 var import_node_child_process8 = require("child_process");
-var import_node_path16 = require("path");
+var import_node_path17 = require("path");
 
 // src/commands/deploy/artifacts/fly-toml-generator.ts
-var import_promises11 = require("fs/promises");
-var import_node_path15 = require("path");
+var import_promises12 = require("fs/promises");
+var import_node_path16 = require("path");
 var GENERATED_HEADER = "# Generated by kora deploy \u2014 do not edit manually";
 function generateFlyToml(options) {
   const internalPort = options.internalPort ?? 3e3;
@@ -5234,9 +5296,9 @@ function generateFlyToml(options) {
   ].join("\n");
 }
 async function writeFlyTomlArtifact(deployDirectory, options) {
-  await (0, import_promises11.mkdir)(deployDirectory, { recursive: true });
-  const filePath = (0, import_node_path15.join)(deployDirectory, "fly.toml");
-  await (0, import_promises11.writeFile)(filePath, generateFlyToml(options), "utf-8");
+  await (0, import_promises12.mkdir)(deployDirectory, { recursive: true });
+  const filePath = (0, import_node_path16.join)(deployDirectory, "fly.toml");
+  await (0, import_promises12.writeFile)(filePath, generateFlyToml(options), "utf-8");
   return filePath;
 }
 
@@ -5330,7 +5392,7 @@ var FlyAdapter = class {
       appName: config.appName,
       region: config.region
     };
-    const deployDirectory = (0, import_node_path16.join)(config.projectRoot, ".kora", "deploy");
+    const deployDirectory = (0, import_node_path17.join)(config.projectRoot, ".kora", "deploy");
     await writeFlyTomlArtifact(deployDirectory, {
       appName: config.appName,
       region: config.region ?? "iad"
@@ -5341,12 +5403,12 @@ var FlyAdapter = class {
     });
     const client = config.deployTarget === "sync-server" ? null : await buildClient({
       projectRoot: config.projectRoot,
-      outDir: (0, import_node_path16.join)(deployDirectory, "dist"),
+      outDir: (0, import_node_path17.join)(deployDirectory, "dist"),
       mode: "production"
     });
     return {
       clientDirectory: client?.outDir ?? null,
-      serverBundlePath: (0, import_node_path16.join)(deployDirectory, "server-bundled.js"),
+      serverBundlePath: (0, import_node_path17.join)(deployDirectory, "server-bundled.js"),
       deployDirectory
     };
   }
@@ -5568,11 +5630,11 @@ ${stdout}`.toLowerCase();
 
 // src/commands/deploy/adapters/railway-adapter.ts
 var import_node_child_process9 = require("child_process");
-var import_node_path18 = require("path");
+var import_node_path19 = require("path");
 
 // src/commands/deploy/artifacts/railway-json-generator.ts
-var import_promises12 = require("fs/promises");
-var import_node_path17 = require("path");
+var import_promises13 = require("fs/promises");
+var import_node_path18 = require("path");
 var GENERATED_HEADER2 = "Generated by kora deploy - do not edit manually.";
 function generateRailwayJson(options) {
   const file = {
@@ -5597,9 +5659,9 @@ function generateRailwayJson(options) {
 `;
 }
 async function writeRailwayJsonArtifact(deployDirectory, options) {
-  await (0, import_promises12.mkdir)(deployDirectory, { recursive: true });
-  const filePath = (0, import_node_path17.join)(deployDirectory, "railway.json");
-  await (0, import_promises12.writeFile)(filePath, generateRailwayJson(options), "utf-8");
+  await (0, import_promises13.mkdir)(deployDirectory, { recursive: true });
+  const filePath = (0, import_node_path18.join)(deployDirectory, "railway.json");
+  await (0, import_promises13.writeFile)(filePath, generateRailwayJson(options), "utf-8");
   return filePath;
 }
 
@@ -5688,7 +5750,7 @@ var RailwayAdapter = class {
       appName: config.appName,
       region: config.region
     };
-    const deployDirectory = (0, import_node_path18.join)(config.projectRoot, ".kora", "deploy");
+    const deployDirectory = (0, import_node_path19.join)(config.projectRoot, ".kora", "deploy");
     await writeRailwayJsonArtifact(deployDirectory, {
       appName: config.appName,
       environment: config.environment
@@ -5699,12 +5761,12 @@ var RailwayAdapter = class {
     });
     const client = config.deployTarget === "sync-server" ? null : await buildClient({
       projectRoot: config.projectRoot,
-      outDir: (0, import_node_path18.join)(deployDirectory, "dist"),
+      outDir: (0, import_node_path19.join)(deployDirectory, "dist"),
       mode: "production"
     });
     return {
       clientDirectory: client?.outDir ?? null,
-      serverBundlePath: (0, import_node_path18.join)(deployDirectory, "server-bundled.js"),
+      serverBundlePath: (0, import_node_path19.join)(deployDirectory, "server-bundled.js"),
       deployDirectory
     };
   }
@@ -5989,8 +6051,8 @@ function createDeployAdapter(platform) {
 }
 
 // src/commands/deploy/artifacts/dockerfile-generator.ts
-var import_promises13 = require("fs/promises");
-var import_node_path19 = require("path");
+var import_promises14 = require("fs/promises");
+var import_node_path20 = require("path");
 var GENERATED_HEADER3 = "# Generated by kora deploy \u2014 do not edit manually";
 function generateDockerfile(options = {}) {
   const nodeVersion = options.nodeVersion ?? "20-alpine";
@@ -6056,37 +6118,37 @@ function generateDockerIgnore() {
   ].join("\n");
 }
 async function writeDockerfileArtifact(deployDirectory, options = {}) {
-  await (0, import_promises13.mkdir)(deployDirectory, { recursive: true });
-  const dockerfilePath = (0, import_node_path19.join)(deployDirectory, "Dockerfile");
-  await (0, import_promises13.writeFile)(dockerfilePath, generateDockerfile(options), "utf-8");
+  await (0, import_promises14.mkdir)(deployDirectory, { recursive: true });
+  const dockerfilePath = (0, import_node_path20.join)(deployDirectory, "Dockerfile");
+  await (0, import_promises14.writeFile)(dockerfilePath, generateDockerfile(options), "utf-8");
   if (options.nativeDependencies && Object.keys(options.nativeDependencies).length > 0) {
-    const pkgJsonPath = (0, import_node_path19.join)(deployDirectory, "package.json");
-    await (0, import_promises13.writeFile)(pkgJsonPath, generateDeployPackageJson(options.nativeDependencies), "utf-8");
+    const pkgJsonPath = (0, import_node_path20.join)(deployDirectory, "package.json");
+    await (0, import_promises14.writeFile)(pkgJsonPath, generateDeployPackageJson(options.nativeDependencies), "utf-8");
   }
   return dockerfilePath;
 }
 async function writeDockerIgnoreArtifact(deployDirectory) {
-  await (0, import_promises13.mkdir)(deployDirectory, { recursive: true });
-  const dockerIgnorePath = (0, import_node_path19.join)(deployDirectory, ".dockerignore");
-  await (0, import_promises13.writeFile)(dockerIgnorePath, generateDockerIgnore(), "utf-8");
+  await (0, import_promises14.mkdir)(deployDirectory, { recursive: true });
+  const dockerIgnorePath = (0, import_node_path20.join)(deployDirectory, ".dockerignore");
+  await (0, import_promises14.writeFile)(dockerIgnorePath, generateDockerIgnore(), "utf-8");
   return dockerIgnorePath;
 }
 
 // src/commands/deploy/state/deploy-state.ts
-var import_promises14 = require("fs/promises");
-var import_node_path20 = require("path");
-var KORA_DEPLOY_DIRECTORY = (0, import_node_path20.join)(".kora", "deploy");
+var import_promises15 = require("fs/promises");
+var import_node_path21 = require("path");
+var KORA_DEPLOY_DIRECTORY = (0, import_node_path21.join)(".kora", "deploy");
 var DEPLOY_STATE_FILENAME = "deploy.json";
 function resolveDeployDirectory(projectRoot) {
-  return (0, import_node_path20.join)(projectRoot, KORA_DEPLOY_DIRECTORY);
+  return (0, import_node_path21.join)(projectRoot, KORA_DEPLOY_DIRECTORY);
 }
 function resolveDeployStatePath(projectRoot) {
-  return (0, import_node_path20.join)(resolveDeployDirectory(projectRoot), DEPLOY_STATE_FILENAME);
+  return (0, import_node_path21.join)(resolveDeployDirectory(projectRoot), DEPLOY_STATE_FILENAME);
 }
 async function readDeployState(projectRoot) {
   const statePath = resolveDeployStatePath(projectRoot);
   try {
-    const source = await (0, import_promises14.readFile)(statePath, "utf-8");
+    const source = await (0, import_promises15.readFile)(statePath, "utf-8");
     const parsed = JSON.parse(source);
     return parseDeployState(parsed);
   } catch (error) {
@@ -6133,13 +6195,13 @@ async function updateDeployState(projectRoot, patch, now = /* @__PURE__ */ new D
   return nextState;
 }
 async function resetDeployState(projectRoot) {
-  await (0, import_promises14.rm)(resolveDeployDirectory(projectRoot), { recursive: true, force: true });
+  await (0, import_promises15.rm)(resolveDeployDirectory(projectRoot), { recursive: true, force: true });
 }
 async function persistDeployState(projectRoot, state) {
   const deployDir = resolveDeployDirectory(projectRoot);
   const statePath = resolveDeployStatePath(projectRoot);
-  await (0, import_promises14.mkdir)(deployDir, { recursive: true });
-  await (0, import_promises14.writeFile)(statePath, `${JSON.stringify(state, null, 2)}
+  await (0, import_promises15.mkdir)(deployDir, { recursive: true });
+  await (0, import_promises15.writeFile)(statePath, `${JSON.stringify(state, null, 2)}
 `, "utf-8");
 }
 function parseDeployState(value) {
@@ -6338,6 +6400,9 @@ var deployCommand = (0, import_citty5.defineCommand)({
       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);
@@ -6448,11 +6513,11 @@ async function resolvePlatform(options) {
       value: "aws-lightsail"
     },
     {
-      label: "Render",
+      label: "Render (coming soon)",
       value: "render"
     },
     {
-      label: "Docker (self-hosted)",
+      label: "Docker (self-hosted, coming soon)",
       value: "docker"
     },
     {
@@ -6473,7 +6538,7 @@ function resolveAppName(argValue, storedValue, projectRoot, confirm) {
       "Missing app name in --confirm mode. Provide --app or run an interactive deploy first."
     );
   }
-  return sanitizeAppName((0, import_node_path21.basename)(projectRoot));
+  return sanitizeAppName((0, import_node_path22.basename)(projectRoot));
 }
 function resolveRegion(argValue, storedValue, confirm) {
   if (typeof argValue === "string" && argValue.length > 0) return argValue;
@@ -6508,7 +6573,7 @@ function configureAdapterContext(adapter, context) {
   }
 }
 function detectDeployTarget(projectRoot) {
-  return (0, import_node_fs4.existsSync)((0, import_node_path21.join)(projectRoot, "src-tauri")) ? "sync-server" : "full-stack";
+  return (0, import_node_fs4.existsSync)((0, import_node_path22.join)(projectRoot, "src-tauri")) ? "sync-server" : "full-stack";
 }
 function hasContextSetter(adapter) {
   return typeof adapter.setContext === "function";
@@ -6516,9 +6581,9 @@ function hasContextSetter(adapter) {
 
 // src/commands/dev/dev-command.ts
 var import_node_fs6 = require("fs");
-var import_promises15 = require("fs/promises");
-var import_node_path23 = require("path");
+var import_promises16 = require("fs/promises");
 var import_node_path24 = require("path");
+var import_node_path25 = require("path");
 var import_citty6 = require("citty");
 init_fs_helpers();
 
@@ -6627,7 +6692,7 @@ function delay(ms) {
 // src/commands/dev/schema-watcher.ts
 var import_node_child_process11 = require("child_process");
 var import_node_fs5 = require("fs");
-var import_node_path22 = require("path");
+var import_node_path23 = require("path");
 init_fs_helpers();
 init_schema_loader();
 var SchemaWatcher = class {
@@ -6661,7 +6726,7 @@ var SchemaWatcher = class {
     this.watcher = null;
   }
   async regenerate() {
-    const koraBinJs = (0, import_node_path22.join)(
+    const koraBinJs = (0, import_node_path23.join)(
       this.config.projectRoot,
       "node_modules",
       "@korajs",
@@ -6777,7 +6842,7 @@ var devCommand = (0, import_citty6.defineCommand)({
     const watchDebounceMs = typeof config?.dev?.watch === "object" && typeof config.dev.watch.debounceMs === "number" ? config.dev.watch.debounceMs : 300;
     const viteEntryPoint = await resolveProjectBinaryEntryPoint(projectRoot, "vite", "vite");
     if (!viteEntryPoint) {
-      throw new DevServerError("vite", (0, import_node_path23.join)(projectRoot, "node_modules", ".bin", "vite"));
+      throw new DevServerError("vite", (0, import_node_path24.join)(projectRoot, "node_modules", ".bin", "vite"));
     }
     const syncServerFile = await findSyncServerFile(projectRoot);
     let managedSyncStore = normalizeManagedSyncStore(config, projectRoot);
@@ -6793,7 +6858,7 @@ var devCommand = (0, import_citty6.defineCommand)({
     }
     if (shouldStartSync && syncServerFile === null && managedSyncStore) {
       const hasServerPackage = await fileExists3(
-        (0, import_node_path23.join)(projectRoot, "node_modules", "@korajs", "server", "package.json")
+        (0, import_node_path24.join)(projectRoot, "node_modules", "@korajs", "server", "package.json")
       );
       if (!hasServerPackage) {
         logger.warn(
@@ -6810,7 +6875,7 @@ var devCommand = (0, import_citty6.defineCommand)({
     }
     let configuredSchemaPath = null;
     if (typeof config?.schema === "string") {
-      const candidate = (0, import_node_path24.resolve)(projectRoot, config.schema);
+      const candidate = (0, import_node_path25.resolve)(projectRoot, config.schema);
       if (await fileExists3(candidate)) {
         configuredSchemaPath = candidate;
       } else {
@@ -6938,10 +7003,10 @@ var devCommand = (0, import_citty6.defineCommand)({
   }
 });
 async function findSyncServerFile(projectRoot) {
-  const candidates = [(0, import_node_path23.join)(projectRoot, "server.ts"), (0, import_node_path23.join)(projectRoot, "server.js")];
+  const candidates = [(0, import_node_path24.join)(projectRoot, "server.ts"), (0, import_node_path24.join)(projectRoot, "server.js")];
   for (const candidate of candidates) {
     try {
-      await (0, import_promises15.access)(candidate);
+      await (0, import_promises16.access)(candidate);
       return candidate;
     } catch {
     }
@@ -6950,7 +7015,7 @@ async function findSyncServerFile(projectRoot) {
 }
 async function fileExists3(path) {
   try {
-    await (0, import_promises15.access)(path);
+    await (0, import_promises16.access)(path);
     return true;
   } catch {
     return false;
@@ -6960,7 +7025,7 @@ function loadProjectEnv(projectRoot, mode = "development") {
   const files = [".env", ".env.local", `.env.${mode}`, `.env.${mode}.local`];
   const existingKeys = new Set(Object.keys(process.env));
   for (const file of files) {
-    const path = (0, import_node_path23.join)(projectRoot, file);
+    const path = (0, import_node_path24.join)(projectRoot, file);
     if (!(0, import_node_fs6.existsSync)(path)) continue;
     const parsed = parseEnvFile((0, import_node_fs6.readFileSync)(path, "utf8"));
     for (const [key, value] of Object.entries(parsed)) {
@@ -6999,7 +7064,7 @@ function normalizeManagedSyncStore(config, projectRoot) {
   const store = sync.store;
   if (store === void 0) return { type: "memory" };
   if (store === "memory") return { type: "memory" };
-  if (store === "sqlite") return { type: "sqlite", filename: (0, import_node_path23.join)(projectRoot, "kora-sync.db") };
+  if (store === "sqlite") return { type: "sqlite", filename: (0, import_node_path24.join)(projectRoot, "kora-sync.db") };
   if (store === "postgres") {
     const connectionString = process.env.DATABASE_URL;
     if (!connectionString) return null;
@@ -7008,7 +7073,7 @@ function normalizeManagedSyncStore(config, projectRoot) {
   if (typeof store === "object" && store !== null) {
     if (store.type === "memory") return { type: "memory" };
     if (store.type === "sqlite") {
-      const filename = typeof store.filename === "string" && store.filename.length > 0 ? (0, import_node_path24.resolve)(projectRoot, store.filename) : (0, import_node_path23.join)(projectRoot, "kora-sync.db");
+      const filename = typeof store.filename === "string" && store.filename.length > 0 ? (0, import_node_path25.resolve)(projectRoot, store.filename) : (0, import_node_path24.join)(projectRoot, "kora-sync.db");
       return { type: "sqlite", filename };
     }
     if (store.type === "postgres" && typeof store.connectionString === "string") {
@@ -7076,8 +7141,8 @@ var import_citty7 = require("citty");
 init_fs_helpers();
 
 // src/commands/doctor/doctor-checks.ts
-var import_promises16 = require("fs/promises");
-var import_node_path25 = require("path");
+var import_promises17 = require("fs/promises");
+var import_node_path26 = require("path");
 init_fs_helpers();
 init_schema_loader();
 var STATUS_ENDPOINT = "/__kora/status";
@@ -7157,9 +7222,9 @@ async function runDoctorChecks(options) {
 }
 async function resolveSchemaPath(projectRoot, configSchema) {
   if (typeof configSchema === "string") {
-    const resolved = (0, import_node_path25.resolve)(projectRoot, configSchema);
+    const resolved = (0, import_node_path26.resolve)(projectRoot, configSchema);
     try {
-      await (0, import_promises16.access)(resolved);
+      await (0, import_promises17.access)(resolved);
       return resolved;
     } catch {
     }
@@ -7168,12 +7233,12 @@ async function resolveSchemaPath(projectRoot, configSchema) {
 }
 async function checkWorkerFile(projectRoot) {
   const candidates = [
-    (0, import_node_path25.join)(projectRoot, "src", "kora-worker.ts"),
-    (0, import_node_path25.join)(projectRoot, "src", "kora-worker.js")
+    (0, import_node_path26.join)(projectRoot, "src", "kora-worker.ts"),
+    (0, import_node_path26.join)(projectRoot, "src", "kora-worker.js")
   ];
   for (const path of candidates) {
     try {
-      await (0, import_promises16.access)(path);
+      await (0, import_promises17.access)(path);
       return {
         id: "worker",
         title: "SQLite WASM worker",
@@ -7193,7 +7258,7 @@ async function checkWorkerFile(projectRoot) {
 }
 async function checkDependencies(projectRoot) {
   try {
-    const raw = await (0, import_promises16.readFile)((0, import_node_path25.join)(projectRoot, "package.json"), "utf-8");
+    const raw = await (0, import_promises17.readFile)((0, import_node_path26.join)(projectRoot, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     const hasKora = Boolean(deps.korajs || deps.kora);
@@ -7242,9 +7307,9 @@ async function resolveSyncHttpUrl(projectRoot, config) {
 }
 async function readEnvSyncUrl(projectRoot) {
   for (const file of [".env", ".env.local"]) {
-    const path = (0, import_node_path25.join)(projectRoot, file);
+    const path = (0, import_node_path26.join)(projectRoot, file);
     try {
-      const content = await (0, import_promises16.readFile)(path, "utf-8");
+      const content = await (0, import_promises17.readFile)(path, "utf-8");
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed || trimmed.startsWith("#")) continue;
@@ -7390,8 +7455,8 @@ var doctorCommand = (0, import_citty7.defineCommand)({
 });
 
 // src/commands/generate/generate-command.ts
-var import_promises17 = require("fs/promises");
-var import_node_path26 = require("path");
+var import_promises18 = require("fs/promises");
+var import_node_path27 = require("path");
 var import_citty8 = require("citty");
 init_fs_helpers();
 init_schema_loader();
@@ -7577,7 +7642,7 @@ var generateCommand = (0, import_citty8.defineCommand)({
         }
         let schemaPath;
         if (args.schema && typeof args.schema === "string") {
-          schemaPath = (0, import_node_path26.resolve)(args.schema);
+          schemaPath = (0, import_node_path27.resolve)(args.schema);
         } else {
           const found = await findSchemaFile(projectRoot);
           if (!found) {
@@ -7600,9 +7665,9 @@ var generateCommand = (0, import_citty8.defineCommand)({
         }
         const output = generateTypes(schema);
         const outputFile = typeof args.output === "string" ? args.output : "kora/generated/types.ts";
-        const outputPath = (0, import_node_path26.resolve)(projectRoot, outputFile);
-        await (0, import_promises17.mkdir)((0, import_node_path26.dirname)(outputPath), { recursive: true });
-        await (0, import_promises17.writeFile)(outputPath, output, "utf-8");
+        const outputPath = (0, import_node_path27.resolve)(projectRoot, outputFile);
+        await (0, import_promises18.mkdir)((0, import_node_path27.dirname)(outputPath), { recursive: true });
+        await (0, import_promises18.writeFile)(outputPath, output, "utf-8");
         logger.success(`Generated types at ${outputPath}`);
       }
     }),
@@ -7635,7 +7700,7 @@ var generateCommand = (0, import_citty8.defineCommand)({
         }
         let schemaPath;
         if (args.schema && typeof args.schema === "string") {
-          schemaPath = (0, import_node_path26.resolve)(projectRoot, args.schema);
+          schemaPath = (0, import_node_path27.resolve)(projectRoot, args.schema);
         } else {
           const found = await findSchemaFile(projectRoot);
           if (!found) {
@@ -7649,13 +7714,13 @@ var generateCommand = (0, import_citty8.defineCommand)({
           schemaPath = found;
         }
         const schema = await loadSchemaDefinition(schemaPath, projectRoot);
-        const outputDir = typeof args.output === "string" ? (0, import_node_path26.resolve)(projectRoot, args.output) : (0, import_node_path26.resolve)(projectRoot, "kora/generated/hooks");
+        const outputDir = typeof args.output === "string" ? (0, import_node_path27.resolve)(projectRoot, args.output) : (0, import_node_path27.resolve)(projectRoot, "kora/generated/hooks");
         const files = generateCollectionHooks(schema);
         for (const [name, content] of files) {
           const adjusted = typeof args.types === "string" && args.types !== "../types" ? content.replace("from '../types'", `from '${args.types}'`) : content;
-          const filePath = (0, import_node_path26.resolve)(outputDir, name);
-          await (0, import_promises17.mkdir)((0, import_node_path26.dirname)(filePath), { recursive: true });
-          await (0, import_promises17.writeFile)(filePath, adjusted, "utf-8");
+          const filePath = (0, import_node_path27.resolve)(outputDir, name);
+          await (0, import_promises18.mkdir)((0, import_node_path27.dirname)(filePath), { recursive: true });
+          await (0, import_promises18.writeFile)(filePath, adjusted, "utf-8");
         }
         logger.success(`Generated ${String(files.size)} hook file(s) at ${outputDir}`);
         logger.step("Run `kora generate types` first if ../types is missing.");
@@ -7784,8 +7849,8 @@ var logsCommand = (0, import_citty9.defineCommand)({
 });
 
 // src/commands/migrate/migrate-command.ts
-var import_promises18 = require("fs/promises");
-var import_node_path27 = require("path");
+var import_promises19 = require("fs/promises");
+var import_node_path28 = require("path");
 var import_citty10 = require("citty");
 init_fs_helpers();
 
@@ -7879,8 +7944,8 @@ function isBreakingChange(change) {
   if (change.type === "field-changed") {
     if (change.before.kind !== change.after.kind) return true;
     if (change.before.itemKind !== change.after.itemKind) return true;
-    if (serializeEnum(change.before.enumValues) !== serializeEnum(change.after.enumValues))
-      return true;
+    const kept = new Set(change.after.enumValues ?? []);
+    if ((change.before.enumValues ?? []).some((value) => !kept.has(value))) return true;
     if (change.before.required !== change.after.required && change.after.required) return true;
     return false;
   }
@@ -7909,22 +7974,473 @@ function compareChanges(left, right) {
   return 0;
 }
 
+// src/commands/migrate/table-evolution-directive.ts
+var import_internal = require("@korajs/core/internal");
+var EVOLVE_TABLE_DIRECTIVE = "--kora:evolve-table";
+function evolveFieldSpec(descriptor) {
+  return {
+    kind: descriptor.kind,
+    ...descriptor.itemKind ? { itemKind: descriptor.itemKind } : {},
+    ...descriptor.enumValues ? { enumValues: [...descriptor.enumValues] } : {},
+    ...descriptor.defaultValue !== void 0 ? { default: descriptor.defaultValue } : {},
+    ...descriptor.auto ? { auto: true } : {}
+  };
+}
+function formatEvolveTableDirective(target) {
+  return `${EVOLVE_TABLE_DIRECTIVE} ${JSON.stringify(target)}`;
+}
+function parseEvolveTableDirective(statement) {
+  const trimmed = statement.trimStart();
+  if (!trimmed.startsWith(EVOLVE_TABLE_DIRECTIVE)) return null;
+  const payload = trimmed.slice(EVOLVE_TABLE_DIRECTIVE.length).trim();
+  let parsed;
+  try {
+    parsed = JSON.parse(payload);
+  } catch {
+    parsed = null;
+  }
+  const target = parsed;
+  const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  const isStrings = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+  const isSpec = (value) => isRecord(value) && typeof value.kind === "string";
+  if (!isRecord(target) || typeof target.table !== "string" || !isRecord(target.add) || !Object.values(target.add).every(isSpec) || !isStrings(target.drop) || !isRecord(target.change) || !Object.values(target.change).every(
+    (change) => isRecord(change) && isSpec(change.from) && isSpec(change.to)
+  ) || !isStrings(target.addIndexes) || !isStrings(target.removeIndexes)) {
+    throw new Error(
+      `Malformed migration directive "${statement}": expected ${EVOLVE_TABLE_DIRECTIVE} {"table", "add", "drop", "change", "addIndexes", "removeIndexes"}. Regenerate the migration with \`kora migrate\`.`
+    );
+  }
+  return {
+    table: target.table,
+    add: target.add,
+    drop: [...target.drop],
+    change: target.change,
+    addIndexes: [...target.addIndexes],
+    removeIndexes: [...target.removeIndexes]
+  };
+}
+async function expandEvolveTableForSqlite(target, query, now) {
+  const catalog = await (0, import_internal.readSqliteTableCatalog)(query, target.table);
+  if (!catalog) return [];
+  const table = quoteIdentifier(target.table);
+  const existing = new Map(
+    catalog.columns.map((column) => [column.name, column.type.toUpperCase()])
+  );
+  const plan = planColumns(target, existing, sqliteType);
+  const statements = [];
+  const presentIndexes = await indexColumnsByName(query, target.table);
+  const removedIndexNames = new Set(
+    target.removeIndexes.flatMap((field) => koraIndexNames(target.table, field)).filter((name) => presentIndexes.has(name))
+  );
+  for (const name of removedIndexNames) {
+    statements.push(`DROP INDEX IF EXISTS ${quoteIdentifier(name)}`);
+  }
+  if (plan.drop.length > 0 || plan.change.length > 0) {
+    statements.push(
+      ...await sqliteRebuildStatements(catalog, plan, query, removedIndexNames, now)
+    );
+  } else {
+    for (const [field, spec] of plan.add) {
+      statements.push(
+        `ALTER TABLE ${table} ADD COLUMN ${quoteIdentifier(field)} ${sqliteType(spec)}${defaultClause(spec)}`
+      );
+      if (spec.auto && spec.kind === "timestamp" && spec.default === void 0) {
+        statements.push(`UPDATE ${table} SET ${quoteIdentifier(field)} = ${now}`);
+      }
+    }
+  }
+  const indexed = await singleColumnIndexes(query, target.table, removedIndexNames);
+  for (const field of target.addIndexes) {
+    if (indexed.has(field)) continue;
+    statements.push(
+      `CREATE INDEX IF NOT EXISTS ${koraIndexNames(target.table, field)[0]} ON ${table} (${quoteIdentifier(field)})`
+    );
+  }
+  return statements;
+}
+async function expandEvolveTableForPostgres(target, query, now) {
+  const columns = await query(
+    `SELECT column_name::text AS name, upper(data_type::text) AS type FROM information_schema.columns WHERE table_schema = current_schema() AND table_name = ${sqlText(target.table)}`
+  );
+  if (columns.length === 0) return [];
+  const table = quoteIdentifier(target.table);
+  const existing = new Map(columns.map((row) => [String(row.name), String(row.type)]));
+  const plan = planColumns(target, existing, postgresType);
+  const statements = [];
+  const indexNames = new Set(
+    (await query(
+      `SELECT indexname::text AS name FROM pg_indexes WHERE schemaname = current_schema() AND tablename = ${sqlText(target.table)}`
+    )).map((row) => String(row.name))
+  );
+  for (const field of target.removeIndexes) {
+    const [serverName, clientName] = koraIndexNames(target.table, field);
+    if (indexNames.has(serverName.toLowerCase())) {
+      statements.push(`DROP INDEX IF EXISTS ${serverName}`);
+    }
+    if (indexNames.has(clientName)) {
+      statements.push(`DROP INDEX IF EXISTS ${quoteIdentifier(clientName)}`);
+    }
+  }
+  for (const field of plan.drop) {
+    statements.push(`ALTER TABLE ${table} DROP COLUMN IF EXISTS ${quoteIdentifier(field)}`);
+  }
+  for (const [field, change] of plan.change) {
+    const column = quoteIdentifier(field);
+    const type = postgresType(change.to);
+    statements.push(`ALTER TABLE ${table} ALTER COLUMN ${column} DROP DEFAULT`);
+    statements.push(
+      `ALTER TABLE ${table} ALTER COLUMN ${column} TYPE ${type} USING CAST((${postgresProjection(column, change.from, change.to, now)}) AS ${type})`
+    );
+    if (change.to.default !== void 0) {
+      statements.push(
+        `ALTER TABLE ${table} ALTER COLUMN ${column} SET DEFAULT ${(0, import_internal.sqlDefaultLiteral)(change.to.default)}`
+      );
+    }
+  }
+  for (const [field, spec] of plan.add) {
+    statements.push(
+      `ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${quoteIdentifier(field)} ${postgresType(spec)}${defaultClause(spec)}`
+    );
+    if (spec.auto && spec.kind === "timestamp" && spec.default === void 0) {
+      statements.push(`UPDATE ${table} SET ${quoteIdentifier(field)} = ${now}`);
+    }
+  }
+  for (const field of target.addIndexes) {
+    const name = koraIndexNames(target.table, field)[0];
+    if (indexNames.has(name.toLowerCase())) continue;
+    statements.push(`CREATE INDEX IF NOT EXISTS ${name} ON ${table} (${quoteIdentifier(field)})`);
+  }
+  return statements;
+}
+function planColumns(target, existing, typeOf) {
+  const plan = { add: [], drop: [], change: [] };
+  for (const [field, spec] of Object.entries(target.add)) {
+    if (!existing.has(field)) plan.add.push([field, spec]);
+  }
+  for (const [field, change] of Object.entries(target.change)) {
+    const current = existing.get(field);
+    if (current === void 0) {
+      plan.add.push([field, change.to]);
+      continue;
+    }
+    const from = typeOf(change.from);
+    const to = typeOf(change.to);
+    if (from !== to && current === to) continue;
+    plan.change.push([field, change]);
+  }
+  for (const field of target.drop) {
+    if (existing.has(field) && !(field in target.add) && !(field in target.change)) {
+      if ((0, import_internal.isKoraInternalColumn)(field)) {
+        throw new Error(
+          `Migration directive refuses to drop Kora's own column "${field}" of "${target.table}".`
+        );
+      }
+      plan.drop.push(field);
+    }
+  }
+  return plan;
+}
+async function sqliteRebuildStatements(catalog, plan, query, removedIndexNames, now) {
+  const table = catalog.table;
+  const temp = `_kora_evolve_${table}`;
+  const dropped = new Set(plan.drop);
+  const changed = new Map(plan.change);
+  const ordered = [...catalog.columns].sort((a, b) => a.cid - b.cid).filter((column) => !dropped.has(column.name));
+  const pkColumns = ordered.filter((c) => c.pk > 0).sort((a, b) => a.pk - b.pk);
+  const fkGroups = /* @__PURE__ */ new Map();
+  for (const fk of catalog.foreignKeys) {
+    const group = fkGroups.get(fk.id) ?? [];
+    group.push(fk);
+    fkGroups.set(fk.id, group);
+  }
+  const columnReferences = /* @__PURE__ */ new Map();
+  const tableConstraints = [];
+  for (const group of fkGroups.values()) {
+    group.sort((a, b) => a.seq - b.seq);
+    const first = group[0];
+    if (!first || group.some((fk) => dropped.has(fk.from))) continue;
+    const actions = foreignKeyActions(first);
+    const targetRef = group.every((fk) => fk.to !== null && fk.to !== "") ? `${quoteIdentifier(first.table)}(${group.map((fk) => quoteIdentifier(fk.to ?? "")).join(", ")})` : quoteIdentifier(first.table);
+    if (group.length === 1) {
+      columnReferences.set(first.from, `REFERENCES ${targetRef}${actions}`);
+    } else {
+      tableConstraints.push(
+        `FOREIGN KEY (${group.map((fk) => quoteIdentifier(fk.from)).join(", ")}) REFERENCES ${targetRef}${actions}`
+      );
+    }
+  }
+  if (pkColumns.length > 1) {
+    tableConstraints.unshift(
+      `PRIMARY KEY (${pkColumns.map((c) => quoteIdentifier(c.name)).join(", ")})`
+    );
+  }
+  for (const unique of catalog.uniqueConstraints) {
+    if (unique.some((column) => dropped.has(column))) continue;
+    tableConstraints.push(`UNIQUE (${unique.map(quoteIdentifier).join(", ")})`);
+  }
+  for (const check of (0, import_internal.parseSqliteCheckConstraints)(catalog.sql)) {
+    if ((0, import_internal.sqliteCheckReferencesColumn)(check, dropped)) continue;
+    tableConstraints.push((0, import_internal.sqliteCheckConstraintDefinition)(check));
+  }
+  const definitions = [];
+  const targetColumns = [];
+  const selections = [];
+  for (const column of ordered) {
+    const change = changed.get(column.name);
+    const parts = [quoteIdentifier(column.name)];
+    if (change) {
+      parts.push(sqliteType(change.to));
+    } else if (column.type) {
+      parts.push(column.type);
+    }
+    if (pkColumns.length === 1 && column.pk === 1) parts.push("PRIMARY KEY");
+    if (column.notnull === 1) parts.push("NOT NULL");
+    if (change) {
+      if (change.to.default !== void 0) {
+        parts.push(`DEFAULT ${(0, import_internal.sqlDefaultLiteral)(change.to.default)}`);
+      }
+    } else if (column.dflt_value !== null) {
+      parts.push(`DEFAULT (${column.dflt_value})`);
+    }
+    const reference = columnReferences.get(column.name);
+    if (reference) parts.push(reference);
+    definitions.push(parts.join(" "));
+    targetColumns.push(quoteIdentifier(column.name));
+    selections.push(
+      change ? sqliteProjection(quoteIdentifier(column.name), change.from, change.to, now) : quoteIdentifier(column.name)
+    );
+  }
+  for (const [field, spec] of plan.add) {
+    definitions.push(`${quoteIdentifier(field)} ${sqliteType(spec)}${defaultClause(spec)}`);
+    targetColumns.push(quoteIdentifier(field));
+    selections.push(fallbackLiteral(spec, now));
+  }
+  const indexColumns = await indexColumnsByName(query, table);
+  const dependents = [];
+  for (const row of await query(
+    `SELECT type, name, sql FROM sqlite_master WHERE type IN ('index', 'trigger') AND tbl_name = ${sqlText(table)} AND sql IS NOT NULL ORDER BY type, name`
+  )) {
+    const name = String(row.name);
+    if (row.type === "index") {
+      if (removedIndexNames.has(name)) continue;
+      if ((indexColumns.get(name) ?? []).some((column) => dropped.has(column))) continue;
+    }
+    dependents.push(String(row.sql));
+  }
+  return [
+    `DROP TABLE IF EXISTS ${quoteIdentifier(temp)}`,
+    `CREATE TABLE ${quoteIdentifier(temp)} (
+  ${[...definitions, ...tableConstraints].join(",\n  ")}
+)`,
+    `INSERT INTO ${quoteIdentifier(temp)} (${targetColumns.join(", ")}) SELECT ${selections.join(", ")} FROM ${quoteIdentifier(table)}`,
+    `DROP TABLE ${quoteIdentifier(table)}`,
+    `ALTER TABLE ${quoteIdentifier(temp)} RENAME TO ${quoteIdentifier(table)}`,
+    ...dependents
+  ];
+}
+async function indexColumnsByName(query, table) {
+  const out = /* @__PURE__ */ new Map();
+  for (const index of await query(`SELECT name FROM pragma_index_list(${sqlText(table)})`)) {
+    const name = String(index.name);
+    const info = await query(`SELECT name FROM pragma_index_info(${sqlText(name)}) ORDER BY seqno`);
+    out.set(
+      name,
+      info.filter((row) => typeof row.name === "string").map((row) => String(row.name))
+    );
+  }
+  return out;
+}
+async function singleColumnIndexes(query, table, ignore) {
+  const out = /* @__PURE__ */ new Set();
+  for (const [name, columns] of await indexColumnsByName(query, table)) {
+    if (ignore.has(name)) continue;
+    const only = columns[0];
+    if (columns.length === 1 && only !== void 0) out.add(only);
+  }
+  return out;
+}
+function koraIndexNames(table, field) {
+  quoteIdentifier(table);
+  quoteIdentifier(field);
+  return [`idx_${table}_${field}`, (0, import_internal.collectionIndexName)(table, field)];
+}
+function defaultClause(spec) {
+  return spec.default !== void 0 ? ` DEFAULT ${(0, import_internal.sqlDefaultLiteral)(spec.default)}` : "";
+}
+function sqliteType(spec) {
+  switch (spec.kind) {
+    case "number":
+      return "REAL";
+    case "boolean":
+    case "timestamp":
+      return "INTEGER";
+    case "richtext":
+      return "BLOB";
+    default:
+      return "TEXT";
+  }
+}
+function postgresType(spec) {
+  switch (spec.kind) {
+    case "number":
+      return "DOUBLE PRECISION";
+    case "boolean":
+      return "INTEGER";
+    case "timestamp":
+      return "BIGINT";
+    case "array":
+    case "object":
+    case "json":
+      return "JSONB";
+    case "richtext":
+      return "BYTEA";
+    default:
+      return "TEXT";
+  }
+}
+function fallbackLiteral(target, now) {
+  if (target.auto && target.kind === "timestamp") return String(now);
+  if (target.default !== void 0) return (0, import_internal.sqlDefaultLiteral)(target.default);
+  return "NULL";
+}
+var NUMERIC_SOURCES = /* @__PURE__ */ new Set(["number", "timestamp", "boolean"]);
+var TEXT_SOURCES = /* @__PURE__ */ new Set(["string", "enum"]);
+var TRUE_WORDS = "('1','true','t','yes','y','on')";
+var FALSE_WORDS = "('0','false','f','no','n','off')";
+function sqliteProjection(column, source, target, now) {
+  if (source.kind === target.kind && source.itemKind === target.itemKind) return column;
+  const fallback = fallbackLiteral(target, now);
+  if (target.kind === "string") return `CAST(${column} AS TEXT)`;
+  if (target.kind === "number" || target.kind === "timestamp") {
+    if (NUMERIC_SOURCES.has(source.kind) || TEXT_SOURCES.has(source.kind)) {
+      const castType = target.kind === "number" ? "REAL" : "INTEGER";
+      return `CASE WHEN ${column} IS NULL THEN NULL ELSE CAST(${column} AS ${castType}) END`;
+    }
+  }
+  if (target.kind === "boolean") {
+    if (NUMERIC_SOURCES.has(source.kind)) {
+      return `CASE WHEN ${column} IS NULL THEN NULL WHEN CAST(${column} AS REAL) = 0 THEN 0 ELSE 1 END`;
+    }
+    if (TEXT_SOURCES.has(source.kind)) {
+      const word = `LOWER(TRIM(CAST(${column} AS TEXT)))`;
+      return `CASE WHEN ${column} IS NULL THEN NULL WHEN ${word} IN ${TRUE_WORDS} THEN 1 WHEN ${word} IN ${FALSE_WORDS} THEN 0 ELSE ${fallback} END`;
+    }
+  }
+  if (target.kind === "enum" && target.enumValues && target.enumValues.length > 0) {
+    if (TEXT_SOURCES.has(source.kind)) {
+      const allowed = target.enumValues.map((value) => (0, import_internal.sqlDefaultLiteral)(value)).join(", ");
+      return `CASE WHEN ${column} IN (${allowed}) THEN ${column} ELSE ${fallback} END`;
+    }
+  }
+  return fallback;
+}
+function postgresProjection(column, source, target, now) {
+  if (source.kind === target.kind && source.itemKind === target.itemKind) return column;
+  const fallback = fallbackLiteral(target, now);
+  const text = `(${column})::text`;
+  if (target.kind === "string") return text;
+  if (target.kind === "number" || target.kind === "timestamp") {
+    const toTarget = (value) => target.kind === "number" ? value : `round(${value})::bigint`;
+    if (NUMERIC_SOURCES.has(source.kind)) {
+      return `CASE WHEN ${column} IS NULL THEN NULL ELSE ${toTarget(`(${column})::double precision`)} END`;
+    }
+    if (TEXT_SOURCES.has(source.kind)) {
+      const trimmed = `btrim(${text})`;
+      return `CASE WHEN ${column} IS NULL THEN NULL WHEN ${trimmed} ~ '^[-+]?([0-9]+([.][0-9]*)?|[.][0-9]+)([eE][-+]?[0-9]+)?$' THEN ${toTarget(`(${trimmed})::double precision`)} ELSE ${fallback} END`;
+    }
+  }
+  if (target.kind === "boolean") {
+    if (NUMERIC_SOURCES.has(source.kind)) {
+      return `CASE WHEN ${column} IS NULL THEN NULL WHEN (${column})::double precision = 0 THEN 0 ELSE 1 END`;
+    }
+    if (TEXT_SOURCES.has(source.kind)) {
+      const word = `lower(btrim(${text}))`;
+      return `CASE WHEN ${column} IS NULL THEN NULL WHEN ${word} IN ${TRUE_WORDS} THEN 1 WHEN ${word} IN ${FALSE_WORDS} THEN 0 ELSE ${fallback} END`;
+    }
+  }
+  if (target.kind === "enum" && target.enumValues && target.enumValues.length > 0) {
+    if (TEXT_SOURCES.has(source.kind)) {
+      const allowed = target.enumValues.map((value) => (0, import_internal.sqlDefaultLiteral)(value)).join(", ");
+      return `CASE WHEN ${text} IN (${allowed}) THEN ${text} ELSE ${fallback} END`;
+    }
+  }
+  return fallback;
+}
+function foreignKeyActions(fk) {
+  let out = "";
+  const onDelete = fk.on_delete?.toUpperCase();
+  const onUpdate = fk.on_update?.toUpperCase();
+  if (onDelete && onDelete !== "NO ACTION") out += ` ON DELETE ${onDelete}`;
+  if (onUpdate && onUpdate !== "NO ACTION") out += ` ON UPDATE ${onUpdate}`;
+  return out;
+}
+function sqlText(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function quoteIdentifier(identifier) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(identifier)) {
+    throw new Error(`Invalid SQL identifier: ${identifier}`);
+  }
+  return `"${identifier}"`;
+}
+
+// src/commands/migrate/value-domain-directive.ts
+var import_internal2 = require("@korajs/core/internal");
+var RELAX_VALUE_DOMAIN_DIRECTIVE = "--kora:relax-value-domain";
+function formatRelaxValueDomainDirective(target) {
+  return `${RELAX_VALUE_DOMAIN_DIRECTIVE} ${JSON.stringify(target)}`;
+}
+function parseRelaxValueDomainDirective(statement) {
+  const trimmed = statement.trimStart();
+  if (!trimmed.startsWith(RELAX_VALUE_DOMAIN_DIRECTIVE)) return null;
+  const payload = trimmed.slice(RELAX_VALUE_DOMAIN_DIRECTIVE.length).trim();
+  let parsed;
+  try {
+    parsed = JSON.parse(payload);
+  } catch {
+    parsed = null;
+  }
+  if (typeof parsed !== "object" || parsed === null || typeof parsed.table !== "string" || !Array.isArray(parsed.fields) || !parsed.fields.every((field) => typeof field === "string") || parsed.enums !== void 0 && (!Array.isArray(parsed.enums) || !parsed.enums.every((field) => typeof field === "string"))) {
+    throw new Error(
+      `Malformed migration directive "${statement}": expected ${RELAX_VALUE_DOMAIN_DIRECTIVE} {"table": "...", "fields": ["..."]}. Regenerate the migration with \`kora migrate\`.`
+    );
+  }
+  const target = parsed;
+  return {
+    table: target.table,
+    fields: [...target.fields],
+    ...target.enums !== void 0 ? { enums: [...target.enums] } : {}
+  };
+}
+async function expandRelaxValueDomainForSqlite(target, query) {
+  return (0, import_internal2.planSqliteConstraintRelaxation)(query, [target.table], {
+    [target.table]: target.enums ?? target.fields
+  });
+}
+async function expandRelaxValueDomainForPostgres(target, query) {
+  return (0, import_internal2.planPostgresConstraintRelaxation)(
+    query,
+    { [target.table]: target.fields },
+    target.enums !== void 0 ? { [target.table]: target.enums } : {}
+  );
+}
+
 // src/commands/migrate/migration-generator.ts
 function generateMigration(previous, current, diff) {
   const up = [];
-  const down = [];
+  const downGroups = [];
   for (const change of diff.changes) {
     if (change.type === "collection-added") {
       const collectionDef = current.collections[change.collection];
       if (!collectionDef) continue;
       up.push(...(0, import_core2.generateSQL)(change.collection, collectionDef));
-      down.push(...dropCollectionStatements(change.collection));
+      downGroups.push(dropCollectionStatements(change.collection));
     }
     if (change.type === "collection-removed") {
       const collectionDef = previous.collections[change.collection];
       up.push(...dropCollectionStatements(change.collection));
       if (collectionDef) {
-        down.push(...(0, import_core2.generateSQL)(change.collection, collectionDef));
+        downGroups.push((0, import_core2.generateSQL)(change.collection, collectionDef));
       }
     }
   }
@@ -7937,48 +8453,59 @@ function generateMigration(previous, current, diff) {
     const previousDef = previous.collections[collection];
     const currentDef = current.collections[collection];
     if (!previousDef || !currentDef) continue;
+    const valueDomainOnly = diff.changes.every(
+      (change) => change.collection !== collection || change.type === "field-changed" && isValueDomainChange(change.before, change.after)
+    );
+    if (valueDomainOnly) {
+      const directive = relaxValueDomainDirective(collection, previousDef, currentDef);
+      up.push(directive);
+      downGroups.push([directive]);
+      continue;
+    }
     validateRebuildSafety(collection, previousDef, currentDef);
-    up.push(...generateRebuildStatements(collection, previousDef, currentDef));
-    down.push(...generateRebuildStatements(collection, currentDef, previousDef));
+    const relax = relaxValueDomainDirective(collection, previousDef, currentDef);
+    up.push(relax, formatEvolveTableDirective(evolveTarget(collection, previousDef, currentDef)));
+    downGroups.push([
+      relax,
+      formatEvolveTableDirective(evolveTarget(collection, currentDef, previousDef))
+    ]);
   }
-  down.reverse();
   return {
     up,
-    down,
+    down: downGroups.reverse().flat(),
     summary: diff.changes.map(formatChange),
     containsBreakingChanges: diff.hasBreakingChanges
   };
 }
-function generateRebuildStatements(collection, from, to) {
-  const table = quoteIdentifier(collection);
-  const tempTable = quoteIdentifier(`_kora_mig_${collection}_new`);
-  const targetColumns = [
-    "id TEXT PRIMARY KEY NOT NULL",
-    ...Object.entries(to.fields).map(([field, descriptor]) => columnDefinition(field, descriptor)),
-    "_created_at INTEGER NOT NULL",
-    "_updated_at INTEGER NOT NULL",
-    "_deleted INTEGER NOT NULL DEFAULT 0"
-  ];
-  const statements = [];
-  statements.push(`CREATE TABLE ${tempTable} (
-  ${targetColumns.join(",\n  ")}
-)`);
-  const toFields = Object.keys(to.fields);
-  const columns = ["id", ...toFields, "_created_at", "_updated_at", "_deleted"];
-  const selectExpressions = columns.map(
-    (column) => projectionForColumn(column, from.fields, to.fields[column] ?? null)
-  );
-  statements.push(
-    `INSERT INTO ${tempTable} (${columns.map(quoteIdentifier).join(", ")}) SELECT ${selectExpressions.join(", ")} FROM ${table}`
-  );
-  statements.push(`DROP TABLE ${table}`);
-  statements.push(`ALTER TABLE ${tempTable} RENAME TO ${table}`);
-  for (const indexField of to.indexes) {
-    statements.push(
-      `CREATE INDEX IF NOT EXISTS idx_${collection}_${indexField} ON ${table} (${quoteIdentifier(indexField)})`
-    );
+function isValueDomainChange(before, after) {
+  return before.kind === after.kind && before.itemKind === after.itemKind && before.auto === after.auto;
+}
+function evolveTarget(collection, from, to) {
+  const target = {
+    table: collection,
+    add: {},
+    drop: [],
+    change: {},
+    addIndexes: to.indexes.filter((field) => !from.indexes.includes(field)),
+    removeIndexes: from.indexes.filter((field) => !to.indexes.includes(field))
+  };
+  for (const [field, descriptor] of Object.entries(to.fields)) {
+    const before = from.fields[field];
+    if (!before) {
+      target.add[field] = evolveFieldSpec(descriptor);
+    } else if (before.kind !== descriptor.kind || before.itemKind !== descriptor.itemKind) {
+      target.change[field] = { from: evolveFieldSpec(before), to: evolveFieldSpec(descriptor) };
+    }
   }
-  return statements;
+  target.drop = Object.keys(from.fields).filter((field) => !(field in to.fields));
+  return target;
+}
+function relaxValueDomainDirective(collection, from, to) {
+  const fields = [.../* @__PURE__ */ new Set([...Object.keys(from.fields), ...Object.keys(to.fields)])].sort();
+  const enums = fields.filter(
+    (field) => from.fields[field]?.kind === "enum" || to.fields[field]?.kind === "enum"
+  );
+  return formatRelaxValueDomainDirective({ table: collection, fields, enums });
 }
 function validateRebuildSafety(collection, from, to) {
   for (const [fieldName, descriptor] of Object.entries(to.fields)) {
@@ -8000,69 +8527,6 @@ function validateRebuildSafety(collection, from, to) {
     }
   }
 }
-function projectionForColumn(column, fromFields, targetDescriptor) {
-  if (column === "id" || column === "_created_at" || column === "_updated_at" || column === "_deleted") {
-    return quoteIdentifier(column);
-  }
-  const sourceDescriptor = fromFields[column];
-  if (sourceDescriptor && targetDescriptor) {
-    return projectionForFieldTransform(column, sourceDescriptor, targetDescriptor);
-  }
-  if (sourceDescriptor) {
-    return quoteIdentifier(column);
-  }
-  if (!targetDescriptor) {
-    return "NULL";
-  }
-  if (targetDescriptor.auto && targetDescriptor.kind === "timestamp") {
-    return "CAST(strftime('%s','now') AS INTEGER) * 1000";
-  }
-  if (targetDescriptor.defaultValue !== void 0) {
-    return sqlLiteral(targetDescriptor.defaultValue);
-  }
-  return "NULL";
-}
-function projectionForFieldTransform(column, source, target) {
-  const sourceColumn = quoteIdentifier(column);
-  if (source.kind === target.kind && source.itemKind === target.itemKind) {
-    if (target.kind === "enum" && target.enumValues && target.enumValues.length > 0) {
-      const allowed = target.enumValues.map((value) => sqlLiteral(value)).join(", ");
-      const fallback = target.defaultValue !== void 0 ? sqlLiteral(target.defaultValue) : sourceColumn;
-      return `CASE WHEN ${sourceColumn} IN (${allowed}) THEN ${sourceColumn} ELSE ${fallback} END`;
-    }
-    return sourceColumn;
-  }
-  if (target.kind === "string") {
-    return `CAST(${sourceColumn} AS TEXT)`;
-  }
-  if (target.kind === "number" || target.kind === "timestamp") {
-    if (source.kind === "string" || source.kind === "enum" || source.kind === "number" || source.kind === "timestamp" || source.kind === "boolean") {
-      const castType = target.kind === "number" ? "REAL" : "INTEGER";
-      return `CASE WHEN ${sourceColumn} IS NULL THEN NULL ELSE CAST(${sourceColumn} AS ${castType}) END`;
-    }
-  }
-  if (target.kind === "boolean") {
-    if (source.kind === "number" || source.kind === "timestamp" || source.kind === "boolean") {
-      return `CASE WHEN ${sourceColumn} IS NULL THEN NULL WHEN CAST(${sourceColumn} AS REAL) = 0 THEN 0 ELSE 1 END`;
-    }
-    if (source.kind === "string" || source.kind === "enum") {
-      return `CASE WHEN ${sourceColumn} IS NULL THEN NULL WHEN LOWER(TRIM(CAST(${sourceColumn} AS TEXT))) IN ('1','true','t','yes','y','on') THEN 1 WHEN LOWER(TRIM(CAST(${sourceColumn} AS TEXT))) IN ('0','false','f','no','n','off') THEN 0 ELSE ${projectionFallback(target)} END`;
-    }
-  }
-  if (target.kind === "enum" && target.enumValues && target.enumValues.length > 0) {
-    if (source.kind === "string" || source.kind === "enum") {
-      const allowed = target.enumValues.map((value) => sqlLiteral(value)).join(", ");
-      return `CASE WHEN ${sourceColumn} IN (${allowed}) THEN ${sourceColumn} ELSE ${projectionFallback(target)} END`;
-    }
-  }
-  if (target.kind === "array" && source.kind === "array" && source.itemKind === target.itemKind) {
-    return sourceColumn;
-  }
-  if (target.auto && target.kind === "timestamp") {
-    return "CAST(strftime('%s','now') AS INTEGER) * 1000";
-  }
-  return projectionFallback(target);
-}
 function canTransformField(source, target) {
   if (source.kind === target.kind && source.itemKind === target.itemKind) {
     return true;
@@ -8087,69 +8551,12 @@ function canTransformField(source, target) {
   }
   return false;
 }
-function projectionFallback(target) {
-  if (target.auto && target.kind === "timestamp") {
-    return "CAST(strftime('%s','now') AS INTEGER) * 1000";
-  }
-  if (target.defaultValue !== void 0) {
-    return sqlLiteral(target.defaultValue);
-  }
-  return "NULL";
-}
 function dropCollectionStatements(collection) {
-  const table = quoteIdentifier(collection);
-  const opsTable = quoteIdentifier(`_kora_ops_${collection}`);
+  const table = quoteIdentifier2(collection);
+  const opsTable = quoteIdentifier2(`_kora_ops_${collection}`);
   return [`DROP TABLE IF EXISTS ${table}`, `DROP TABLE IF EXISTS ${opsTable}`];
 }
-function columnDefinition(fieldName, descriptor) {
-  const sqlType = mapFieldType(descriptor);
-  const parts = [quoteIdentifier(fieldName), sqlType];
-  if (descriptor.required && descriptor.defaultValue === void 0 && !descriptor.auto) {
-    parts.push("NOT NULL");
-  }
-  if (descriptor.defaultValue !== void 0) {
-    parts.push(`DEFAULT ${sqlLiteral(descriptor.defaultValue)}`);
-  }
-  if (descriptor.kind === "enum" && descriptor.enumValues) {
-    const values = descriptor.enumValues.map((value) => sqlLiteral(value)).join(", ");
-    parts.push(`CHECK (${quoteIdentifier(fieldName)} IN (${values}))`);
-  }
-  return parts.join(" ");
-}
-function mapFieldType(descriptor) {
-  switch (descriptor.kind) {
-    case "string":
-      return "TEXT";
-    case "number":
-      return "REAL";
-    case "boolean":
-      return "INTEGER";
-    case "enum":
-      return "TEXT";
-    case "timestamp":
-      return "INTEGER";
-    case "array":
-      return "TEXT";
-    case "object":
-      return "TEXT";
-    case "json":
-      return "TEXT";
-    case "blob":
-      return "TEXT";
-    case "secret":
-      return "TEXT";
-    case "richtext":
-      return "BLOB";
-  }
-}
-function sqlLiteral(value) {
-  if (value === null) return "NULL";
-  if (typeof value === "number") return String(value);
-  if (typeof value === "boolean") return value ? "1" : "0";
-  if (typeof value === "string") return `'${value.replaceAll("'", "''")}'`;
-  return `'${JSON.stringify(value).replaceAll("'", "''")}'`;
-}
-function quoteIdentifier(identifier) {
+function quoteIdentifier2(identifier) {
   if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(identifier)) {
     throw new Error(`Invalid SQL identifier: ${identifier}`);
   }
@@ -8228,6 +8635,8 @@ async function runSqliteMigration(path, statements, migrationId, fromVersion, to
   const driver = driverOverride ?? await loadSqliteDriver(projectRoot);
   const db = driver.open(path);
   let statementsApplied = 0;
+  const foreignKeysOn = Number(db.query?.("PRAGMA foreign_keys")[0]?.foreign_keys ?? 0) === 1;
+  if (foreignKeysOn) db.exec("PRAGMA foreign_keys = OFF");
   try {
     db.exec("BEGIN");
     db.exec(
@@ -8243,12 +8652,38 @@ async function runSqliteMigration(path, statements, migrationId, fromVersion, to
         skipped: true
       };
     }
+    const now = Date.now();
+    const catalogQuery = (table) => {
+      const query = db.query?.bind(db);
+      if (!query) {
+        throw new Error(
+          `Migration ${migrationId}: the SQLite driver cannot read the catalog needed to migrate "${table}".`
+        );
+      }
+      return async (text) => query(text);
+    };
     for (const statement of statements) {
-      db.exec(statement);
+      const relax = parseRelaxValueDomainDirective(statement);
+      const evolve = relax ? null : parseEvolveTableDirective(statement);
+      if (relax) {
+        const expanded = await expandRelaxValueDomainForSqlite(relax, catalogQuery(relax.table));
+        for (const rebuild of expanded) db.exec(rebuild);
+      } else if (evolve) {
+        const expanded = await expandEvolveTableForSqlite(evolve, catalogQuery(evolve.table), now);
+        for (const change of expanded) db.exec(change);
+      } else {
+        db.exec(statement);
+      }
       statementsApplied++;
     }
+    const violations = db.query?.("PRAGMA foreign_key_check") ?? [];
+    if (violations.length > 0) {
+      throw new Error(
+        `Migration ${migrationId} left ${violations.length} foreign key violation(s) (first: ${JSON.stringify(violations[0])}); nothing was applied.`
+      );
+    }
     db.exec(
-      `INSERT OR REPLACE INTO _kora_migrations (id, from_version, to_version, applied_at) VALUES (${sqlLiteral2(migrationId)}, ${fromVersion}, ${toVersion}, ${Date.now()})`
+      `INSERT OR REPLACE INTO _kora_migrations (id, from_version, to_version, applied_at) VALUES (${sqlLiteral(migrationId)}, ${fromVersion}, ${toVersion}, ${Date.now()})`
     );
     db.exec("COMMIT");
     return {
@@ -8264,6 +8699,12 @@ async function runSqliteMigration(path, statements, migrationId, fromVersion, to
     }
     throw error;
   } finally {
+    if (foreignKeysOn) {
+      try {
+        db.exec("PRAGMA foreign_keys = ON");
+      } catch {
+      }
+    }
     if (typeof db.close === "function") {
       db.close();
     }
@@ -8285,6 +8726,9 @@ async function loadSqliteDriver(projectRoot) {
             const row = db.prepare("SELECT COUNT(*) AS count FROM _kora_migrations WHERE id = ?").get(id);
             return (row?.count ?? 0) > 0;
           },
+          query(sql) {
+            return db.prepare(sql).all();
+          },
           close() {
             db.close();
           }
@@ -8298,7 +8742,11 @@ async function loadSqliteDriver(projectRoot) {
   }
 }
 async function runPostgresMigration(connectionString, statements, migrationId, fromVersion, toVersion, clientFactoryOverride) {
-  const sql = typeof clientFactoryOverride === "function" ? clientFactoryOverride(connectionString) : (await loadPostgresModule()).default(connectionString);
+  const sql = typeof clientFactoryOverride === "function" ? clientFactoryOverride(connectionString) : (
+    // One connection: BEGIN, the statements and COMMIT must share it (postgres.js
+    // refuses a raw BEGIN on a pool, UNSAFE_TRANSACTION).
+    (await loadPostgresModule()).default(connectionString, { max: 1 })
+  );
   let statementsApplied = 0;
   try {
     await sql.unsafe("BEGIN");
@@ -8306,7 +8754,7 @@ async function runPostgresMigration(connectionString, statements, migrationId, f
       "CREATE TABLE IF NOT EXISTS _kora_migrations (id TEXT PRIMARY KEY, from_version INTEGER NOT NULL, to_version INTEGER NOT NULL, applied_at BIGINT NOT NULL)"
     );
     const existing = await sql.unsafe(
-      `SELECT COUNT(*)::int AS count FROM _kora_migrations WHERE id = ${sqlLiteral2(migrationId)}`
+      `SELECT COUNT(*)::int AS count FROM _kora_migrations WHERE id = ${sqlLiteral(migrationId)}`
     );
     if ((existing[0]?.count ?? 0) > 0) {
       await sql.unsafe("COMMIT");
@@ -8317,12 +8765,25 @@ async function runPostgresMigration(connectionString, statements, migrationId, f
         skipped: true
       };
     }
+    const now = Date.now();
+    const query = async (text) => await sql.unsafe(text);
     for (const statement of statements) {
-      await sql.unsafe(statement);
+      const relax = parseRelaxValueDomainDirective(statement);
+      const evolve = relax ? null : parseEvolveTableDirective(statement);
+      if (relax) {
+        const expanded = await expandRelaxValueDomainForPostgres(relax, query);
+        for (const alter of expanded) await sql.unsafe(alter);
+      } else if (evolve) {
+        const expanded = await expandEvolveTableForPostgres(evolve, query, now);
+        for (const alter of expanded) await sql.unsafe(alter);
+      } else {
+        assertNotLegacyRebuild(statement, migrationId);
+        await sql.unsafe(statement);
+      }
       statementsApplied++;
     }
     await sql.unsafe(
-      `INSERT INTO _kora_migrations (id, from_version, to_version, applied_at) VALUES (${sqlLiteral2(migrationId)}, ${fromVersion}, ${toVersion}, ${Date.now()}) ON CONFLICT (id) DO UPDATE SET from_version = EXCLUDED.from_version, to_version = EXCLUDED.to_version, applied_at = EXCLUDED.applied_at`
+      `INSERT INTO _kora_migrations (id, from_version, to_version, applied_at) VALUES (${sqlLiteral(migrationId)}, ${fromVersion}, ${toVersion}, ${Date.now()}) ON CONFLICT (id) DO UPDATE SET from_version = EXCLUDED.from_version, to_version = EXCLUDED.to_version, applied_at = EXCLUDED.applied_at`
     );
     await sql.unsafe("COMMIT");
     return {
@@ -8343,7 +8804,14 @@ async function runPostgresMigration(connectionString, statements, migrationId, f
     }
   }
 }
-function sqlLiteral2(value) {
+function assertNotLegacyRebuild(statement, migrationId) {
+  if (/^\s*CREATE\s+TABLE\s+"?_kora_mig_[A-Za-z0-9_]+_new"?/i.test(statement)) {
+    throw new Error(
+      `Migration ${migrationId} was generated by an earlier \`kora migrate\` as a SQLite-only table rebuild, which cannot run on Postgres. Regenerate it: restore kora/schema.snapshot.json to the schema version it migrates from, delete the migration's files, and run \`kora migrate\` again.`
+    );
+  }
+}
+function sqlLiteral(value) {
   return `'${value.replaceAll("'", "''")}'`;
 }
 async function loadPostgresModule() {
@@ -8431,12 +8899,12 @@ var migrateCommand = (0, import_citty10.defineCommand)({
       throw new InvalidProjectError(process.cwd());
     }
     const config = await loadKoraConfig(projectRoot);
-    const resolvedSchemaPath = typeof args.schema === "string" ? (0, import_node_path27.resolve)(projectRoot, args.schema) : typeof config?.schema === "string" ? (0, import_node_path27.resolve)(projectRoot, config.schema) : await findSchemaFile(projectRoot);
+    const resolvedSchemaPath = typeof args.schema === "string" ? (0, import_node_path28.resolve)(projectRoot, args.schema) : typeof config?.schema === "string" ? (0, import_node_path28.resolve)(projectRoot, config.schema) : await findSchemaFile(projectRoot);
     if (!resolvedSchemaPath) {
       throw new SchemaNotFoundError(["src/schema.ts", "schema.ts", "src/schema.js", "schema.js"]);
     }
     const currentSchema = await loadSchemaDefinition(resolvedSchemaPath, projectRoot);
-    const snapshotFile = (0, import_node_path27.join)(projectRoot, SNAPSHOT_PATH);
+    const snapshotFile = (0, import_node_path28.join)(projectRoot, SNAPSHOT_PATH);
     const previousSchema = await readSchemaSnapshot(snapshotFile);
     if (!previousSchema) {
       if (args["dry-run"] === true) {
@@ -8449,7 +8917,7 @@ var migrateCommand = (0, import_citty10.defineCommand)({
       return;
     }
     const diff = diffSchemas(previousSchema, currentSchema);
-    const outputDir = typeof args["output-dir"] === "string" ? (0, import_node_path27.resolve)(projectRoot, args["output-dir"]) : (0, import_node_path27.resolve)(projectRoot, MIGRATIONS_DIR);
+    const outputDir = typeof args["output-dir"] === "string" ? (0, import_node_path28.resolve)(projectRoot, args["output-dir"]) : (0, import_node_path28.resolve)(projectRoot, MIGRATIONS_DIR);
     if (!diff.hasChanges) {
       logger.success("No schema changes detected.");
       if (args.apply === true) {
@@ -8501,7 +8969,7 @@ var migrateCommand = (0, import_citty10.defineCommand)({
       logger.warn("Dry run enabled: no files written, no migrations applied.");
       return;
     }
-    await (0, import_promises18.mkdir)(outputDir, { recursive: true });
+    await (0, import_promises19.mkdir)(outputDir, { recursive: true });
     const migrationPath = await writeMigrationFile(
       outputDir,
       diff.fromVersion,
@@ -8537,7 +9005,7 @@ var migrateCommand = (0, import_citty10.defineCommand)({
 });
 async function readSchemaSnapshot(path) {
   try {
-    const content = await (0, import_promises18.readFile)(path, "utf-8");
+    const content = await (0, import_promises19.readFile)(path, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -8558,15 +9026,15 @@ function isInteractiveTerminal2() {
   return process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
 async function writeSchemaSnapshot(path, schema) {
-  await (0, import_promises18.mkdir)((0, import_node_path27.dirname)(path), { recursive: true });
-  await (0, import_promises18.writeFile)(path, `${JSON.stringify(schema, null, 2)}
+  await (0, import_promises19.mkdir)((0, import_node_path28.dirname)(path), { recursive: true });
+  await (0, import_promises19.writeFile)(path, `${JSON.stringify(schema, null, 2)}
 `, "utf-8");
 }
 async function writeMigrationFile(outputDir, fromVersion, toVersion, generated) {
-  const existing = await (0, import_promises18.readdir)(outputDir).catch(() => []);
+  const existing = await (0, import_promises19.readdir)(outputDir).catch(() => []);
   const sequence = existing.filter((file) => /^\d{3}-/.test(file)).length + 1;
   const filename = `${String(sequence).padStart(3, "0")}-v${fromVersion}-to-v${toVersion}.ts`;
-  const path = (0, import_node_path27.join)(outputDir, filename);
+  const path = (0, import_node_path28.join)(outputDir, filename);
   const migrationId = filename.replace(/\.ts$/, "");
   const fileContent = [
     `export const up = ${JSON.stringify(generated.up, null, 2)} as const`,
@@ -8578,10 +9046,10 @@ async function writeMigrationFile(outputDir, fromVersion, toVersion, generated)
     `export const containsBreakingChanges = ${generated.containsBreakingChanges}`,
     ""
   ].join("\n");
-  await (0, import_promises18.writeFile)(path, fileContent, "utf-8");
-  const transformsPath = (0, import_node_path27.join)(outputDir, `${migrationId}.transforms.ts`);
-  await (0, import_promises18.writeFile)(transformsPath, generateOperationTransformModule(fromVersion, toVersion), "utf-8");
-  await writeMigrationManifest((0, import_node_path27.join)(outputDir, `${migrationId}.json`), {
+  await (0, import_promises19.writeFile)(path, fileContent, "utf-8");
+  const transformsPath = (0, import_node_path28.join)(outputDir, `${migrationId}.transforms.ts`);
+  await (0, import_promises19.writeFile)(transformsPath, generateOperationTransformModule(fromVersion, toVersion), "utf-8");
+  await writeMigrationManifest((0, import_node_path28.join)(outputDir, `${migrationId}.json`), {
     id: migrationId,
     fromVersion,
     toVersion,
@@ -8593,22 +9061,22 @@ async function writeMigrationFile(outputDir, fromVersion, toVersion, generated)
   return path;
 }
 async function writeMigrationManifest(path, manifest) {
-  await (0, import_promises18.writeFile)(path, `${JSON.stringify(manifest, null, 2)}
+  await (0, import_promises19.writeFile)(path, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
 }
 async function listMigrationManifests(outputDir) {
-  const files = await (0, import_promises18.readdir)(outputDir).catch(() => []);
+  const files = await (0, import_promises19.readdir)(outputDir).catch(() => []);
   const migrationFiles = files.filter((file) => /^\d{3}-.*\.ts$/.test(file)).sort((left, right) => left.localeCompare(right));
   const manifests = [];
   for (const file of migrationFiles) {
     const id = file.replace(/\.ts$/, "");
-    const manifestPath = (0, import_node_path27.join)(outputDir, `${id}.json`);
+    const manifestPath = (0, import_node_path28.join)(outputDir, `${id}.json`);
     const jsonManifest = await readMigrationManifest(manifestPath);
     if (jsonManifest) {
       manifests.push({ ...jsonManifest, id });
       continue;
     }
-    const migrationPath = (0, import_node_path27.join)(outputDir, file);
+    const migrationPath = (0, import_node_path28.join)(outputDir, file);
     const sourceManifest = await readMigrationManifestFromSource(migrationPath, id);
     manifests.push(sourceManifest);
   }
@@ -8616,7 +9084,7 @@ async function listMigrationManifests(outputDir) {
 }
 async function readMigrationManifest(path) {
   try {
-    const content = await (0, import_promises18.readFile)(path, "utf-8");
+    const content = await (0, import_promises19.readFile)(path, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     const code = error.code;
@@ -8627,7 +9095,7 @@ async function readMigrationManifest(path) {
   }
 }
 async function readMigrationManifestFromSource(path, id) {
-  const content = await (0, import_promises18.readFile)(path, "utf-8");
+  const content = await (0, import_promises19.readFile)(path, "utf-8");
   const versions = parseVersionsFromMigrationId(id);
   return {
     id,
@@ -8689,18 +9157,18 @@ function parseLiteralExport(source, exportName) {
 }
 function resolveSqliteApplyPath(dbArg, projectRoot, config) {
   if (typeof dbArg === "string") {
-    return (0, import_node_path27.resolve)(projectRoot, dbArg);
+    return (0, import_node_path28.resolve)(projectRoot, dbArg);
   }
   const sync = config?.dev?.sync;
   if (typeof sync === "object" && sync !== null) {
     if (sync.store === "sqlite") {
-      return (0, import_node_path27.join)(projectRoot, "kora-sync.db");
+      return (0, import_node_path28.join)(projectRoot, "kora-sync.db");
     }
     if (typeof sync.store === "object" && sync.store !== null && sync.store.type === "sqlite") {
       if (typeof sync.store.filename === "string" && sync.store.filename.length > 0) {
-        return (0, import_node_path27.resolve)(projectRoot, sync.store.filename);
+        return (0, import_node_path28.resolve)(projectRoot, sync.store.filename);
       }
-      return (0, import_node_path27.join)(projectRoot, "kora-sync.db");
+      return (0, import_node_path28.join)(projectRoot, "kora-sync.db");
     }
   }
   return void 0;
@@ -8851,7 +9319,7 @@ function printStatus(status, url, logger) {
 
 // src/commands/studio/studio-command.ts
 var import_node_fs9 = require("fs");
-var import_node_path30 = require("path");
+var import_node_path31 = require("path");
 var import_citty12 = require("citty");
 var studioCommand = (0, import_citty12.defineCommand)({
   meta: {
@@ -8902,7 +9370,7 @@ var studioCommand = (0, import_citty12.defineCommand)({
         );
       }
       const { loadSchemaDefinition: loadSchemaDefinition2 } = await Promise.resolve().then(() => (init_schema_loader(), schema_loader_exports));
-      const schema = await loadSchemaDefinition2((0, import_node_path30.resolve)(process.cwd(), args.schema), process.cwd());
+      const schema = await loadSchemaDefinition2((0, import_node_path31.resolve)(process.cwd(), args.schema), process.cwd());
       const { SpectatorManager: SpectatorManager2 } = await Promise.resolve().then(() => (init_spectator_manager(), spectator_manager_exports));
       const spectator = new SpectatorManager2({
         url: args.connect,
@@ -8929,7 +9397,7 @@ var studioCommand = (0, import_citty12.defineCommand)({
       let schema = defaultLabSchema2();
       if (typeof args.schema === "string") {
         const { loadSchemaDefinition: loadSchemaDefinition2 } = await Promise.resolve().then(() => (init_schema_loader(), schema_loader_exports));
-        schema = await loadSchemaDefinition2((0, import_node_path30.resolve)(process.cwd(), args.schema), process.cwd());
+        schema = await loadSchemaDefinition2((0, import_node_path31.resolve)(process.cwd(), args.schema), process.cwd());
       }
       const initialDevices = args.devices !== void 0 ? Math.max(1, Number.parseInt(args.devices, 10) || 2) : 2;
       const lab = new LabManager2(schema);
@@ -8954,7 +9422,7 @@ var studioCommand = (0, import_citty12.defineCommand)({
         "Pass --db <path> to inspect a database, --lab for the sync laboratory, or --connect <wss url> for live spectator mode."
       );
     }
-    const dbPath = (0, import_node_path30.resolve)(process.cwd(), args.db);
+    const dbPath = (0, import_node_path31.resolve)(process.cwd(), args.db);
     if (!(0, import_node_fs9.existsSync)(dbPath)) {
       throw new Error(`Database file not found: ${dbPath}`);
     }