@korajs/cli 0.1.15 → 0.2.0

package/dist/chunk-E4JG7THU.js

@@ -0,0 +1,1550 @@
+#!/usr/bin/env node
+import {
+  InvalidProjectError,
+  createLogger,
+  createPromptClient,
+  findProjectRoot,
+  resolveProjectBinaryEntryPoint
+} from "./chunk-KTSRAPSE.js";
+
+// src/commands/deploy/adapters/adapter.ts
+var DEPLOY_PLATFORMS = ["fly", "railway", "render", "docker", "kora-cloud"];
+function isDeployPlatform(value) {
+  return DEPLOY_PLATFORMS.includes(value);
+}
+
+// src/commands/deploy/artifacts/fly-toml-generator.ts
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+var GENERATED_HEADER = "# Generated by kora deploy \u2014 do not edit manually";
+function generateFlyToml(options) {
+  const internalPort = options.internalPort ?? 3e3;
+  return [
+    GENERATED_HEADER,
+    "",
+    `app = "${options.appName}"`,
+    `primary_region = "${options.region}"`,
+    "",
+    "[build]",
+    `  dockerfile = "Dockerfile"`,
+    "",
+    "[http_service]",
+    `  internal_port = ${String(internalPort)}`,
+    "  force_https = true",
+    '  auto_stop_machines = "stop"',
+    "  auto_start_machines = true",
+    "  min_machines_running = 0",
+    "",
+    "  [[http_service.checks]]",
+    '    grace_period = "10s"',
+    '    interval = "30s"',
+    '    method = "GET"',
+    '    timeout = "5s"',
+    '    path = "/"',
+    ""
+  ].join("\n");
+}
+async function writeFlyTomlArtifact(deployDirectory, options) {
+  await mkdir(deployDirectory, { recursive: true });
+  const filePath = join(deployDirectory, "fly.toml");
+  await writeFile(filePath, generateFlyToml(options), "utf-8");
+  return filePath;
+}
+
+// src/commands/deploy/builder/client-builder.ts
+import { spawn } from "child_process";
+import { copyFile, readdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join as join2, resolve } from "path";
+async function buildClient(options) {
+  const viteEntryPoint = await resolveProjectBinaryEntryPoint(options.projectRoot, "vite", "vite");
+  if (!viteEntryPoint) {
+    throw new Error(
+      `Could not find local Vite binary in ${options.projectRoot}. Install dependencies before deploying.`
+    );
+  }
+  const args = [
+    viteEntryPoint,
+    "build",
+    "--outDir",
+    options.outDir,
+    "--mode",
+    options.mode ?? "production"
+  ];
+  await runProcess(process.execPath, args, options.projectRoot);
+  await patchSqliteWasmAssets(options.projectRoot, options.outDir);
+  return { outDir: options.outDir };
+}
+async function patchSqliteWasmAssets(projectRoot, outDir) {
+  const assetsDir = join2(outDir, "assets");
+  if (!existsSync(assetsDir)) return;
+  const files = await readdir(assetsDir);
+  const hashedWasm = files.find((f) => /^sqlite3-.+\.wasm$/.test(f));
+  if (hashedWasm && !files.includes("sqlite3.wasm")) {
+    await copyFile(join2(assetsDir, hashedWasm), join2(assetsDir, "sqlite3.wasm"));
+  }
+  if (!files.includes("sqlite3-opfs-async-proxy.js")) {
+    const proxyFile = resolve(
+      projectRoot,
+      "node_modules",
+      "@sqlite.org",
+      "sqlite-wasm",
+      "sqlite-wasm",
+      "jswasm",
+      "sqlite3-opfs-async-proxy.js"
+    );
+    if (existsSync(proxyFile)) {
+      await copyFile(proxyFile, join2(assetsDir, "sqlite3-opfs-async-proxy.js"));
+    }
+  }
+}
+async function runProcess(command, args, cwd) {
+  await new Promise((resolve2, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: "inherit",
+      env: process.env
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve2();
+        return;
+      }
+      reject(new Error(`Client build failed with exit code ${String(code ?? "unknown")}.`));
+    });
+  });
+}
+
+// src/commands/deploy/builder/server-bundler.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { access } from "fs/promises";
+import { join as join3 } from "path";
+import { build } from "esbuild";
+var DEFAULT_ENTRY_CANDIDATES = [
+  "server.ts",
+  "server.js",
+  "src/server.ts",
+  "src/server.js"
+];
+async function bundleServer(options) {
+  const candidates = options.entryFileCandidates ?? DEFAULT_ENTRY_CANDIDATES;
+  const entryFilePath = await resolveServerEntry(options.projectRoot, candidates);
+  if (!entryFilePath) {
+    throw new Error(
+      `Could not find a server entry file in ${options.projectRoot}. Looked for: ${candidates.join(", ")}`
+    );
+  }
+  await mkdir2(options.deployDirectory, { recursive: true });
+  const outputFilePath = join3(options.deployDirectory, "server-bundled.js");
+  await build({
+    entryPoints: [entryFilePath],
+    outfile: outputFilePath,
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    target: ["node20"],
+    sourcemap: false,
+    logLevel: "silent",
+    external: ["better-sqlite3"],
+    banner: {
+      js: "import { createRequire as __createRequire } from 'module'; const require = __createRequire(import.meta.url);"
+    }
+  });
+  return {
+    entryFilePath,
+    outputFilePath
+  };
+}
+async function resolveServerEntry(projectRoot, candidates) {
+  for (const candidate of candidates) {
+    const fullPath = join3(projectRoot, candidate);
+    try {
+      await access(fullPath);
+      return fullPath;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/commands/deploy/adapters/fly-adapter.ts
+import { spawn as spawn2 } from "child_process";
+import { join as join4 } from "path";
+var FlyAdapter = class {
+  name = "fly";
+  logger = createLogger();
+  runner;
+  commandCandidates;
+  flyCommand = null;
+  currentContext;
+  lastDeploymentId = null;
+  constructor(options = {}) {
+    this.runner = options.runner ?? new NodeFlyCommandRunner();
+    this.commandCandidates = options.commandCandidates ?? DEFAULT_FLY_COMMAND_CANDIDATES;
+    this.currentContext = options.context ?? null;
+  }
+  /**
+   * Seeds runtime context for non-provisioning commands.
+   */
+  setContext(context) {
+    this.currentContext = context;
+  }
+  /**
+   * Checks whether a Fly CLI executable can be resolved.
+   */
+  async detect() {
+    const command = await this.tryResolveFlyCommand(process.cwd());
+    return command !== null;
+  }
+  /**
+   * Ensures Fly CLI is available before deployment.
+   */
+  async install() {
+    const available = await this.detect();
+    if (!available) {
+      throw new Error(
+        "Fly CLI is required but not installed. Install from https://fly.io/docs/hands-on/install-flyctl/."
+      );
+    }
+  }
+  /**
+   * Performs Fly authentication check/login.
+   */
+  async authenticate() {
+    const projectRoot = this.currentContext?.projectRoot ?? process.cwd();
+    const status = await this.runFlyCommand(["auth", "whoami", "--json"], projectRoot, false);
+    if (status.exitCode === 0) return;
+    const login = await this.runFlyCommand(["auth", "login"], projectRoot, true);
+    if (login.exitCode !== 0) {
+      throw new Error(`Fly authentication failed: ${normalizeError(login.stderr, login.stdout)}`);
+    }
+  }
+  /**
+   * Provisions app and optionally region-bound resources in Fly.
+   */
+  async provision(config) {
+    this.currentContext = {
+      projectRoot: config.projectRoot,
+      appName: config.appName,
+      region: config.region ?? "iad"
+    };
+    const appCreateArgs = ["apps", "create", config.appName];
+    const createApp = await this.runFlyCommand(appCreateArgs, config.projectRoot, false);
+    if (createApp.exitCode !== 0 && !isAlreadyExistsResponse(createApp.stderr, createApp.stdout)) {
+      throw new Error(
+        `Fly app provisioning failed for "${config.appName}": ${normalizeError(createApp.stderr, createApp.stdout)}`
+      );
+    }
+    const secrets = [];
+    const portSecret = await this.runFlyCommand(
+      ["secrets", "set", "PORT=3000", "--app", config.appName],
+      config.projectRoot,
+      false
+    );
+    if (portSecret.exitCode === 0) {
+      secrets.push("PORT");
+    }
+    return {
+      applicationId: config.appName,
+      databaseId: null,
+      secretsSet: secrets
+    };
+  }
+  /**
+   * Builds local artifacts consumed by Fly deploy.
+   */
+  async build(config) {
+    this.currentContext = {
+      projectRoot: config.projectRoot,
+      appName: config.appName,
+      region: config.region
+    };
+    const deployDirectory = join4(config.projectRoot, ".kora", "deploy");
+    await writeFlyTomlArtifact(deployDirectory, {
+      appName: config.appName,
+      region: config.region ?? "iad"
+    });
+    await bundleServer({
+      projectRoot: config.projectRoot,
+      deployDirectory
+    });
+    const client = await buildClient({
+      projectRoot: config.projectRoot,
+      outDir: join4(deployDirectory, "dist"),
+      mode: "production"
+    });
+    return {
+      clientDirectory: client.outDir,
+      serverBundlePath: join4(deployDirectory, "server-bundled.js"),
+      deployDirectory
+    };
+  }
+  /**
+   * Deploys generated artifacts to Fly and returns live endpoints.
+   */
+  async deploy(artifacts) {
+    const context = this.requireContext();
+    const deploy = await this.runFlyCommand(
+      ["deploy", "--config", "fly.toml", "--app", context.appName],
+      artifacts.deployDirectory,
+      true
+    );
+    if (deploy.exitCode !== 0) {
+      throw new Error(`Fly deployment failed: ${normalizeError(deploy.stderr, deploy.stdout)}`);
+    }
+    const info = await this.runFlyCommand(
+      ["status", "--app", context.appName, "--json"],
+      context.projectRoot,
+      false
+    );
+    const hostname = parseFlyHostname(info.stdout) ?? `${context.appName}.fly.dev`;
+    const deploymentId = parseFlyDeploymentId(info.stdout) ?? (/* @__PURE__ */ new Date()).toISOString();
+    this.lastDeploymentId = deploymentId;
+    return {
+      deploymentId,
+      liveUrl: `https://${hostname}`,
+      syncUrl: `wss://${hostname}/kora-sync`
+    };
+  }
+  /**
+   * Rolls back to a deployment version.
+   */
+  async rollback(deploymentId) {
+    const context = this.requireContext();
+    const rollback = await this.runFlyCommand(
+      ["releases", "revert", deploymentId, "--app", context.appName],
+      context.projectRoot,
+      true
+    );
+    if (rollback.exitCode !== 0) {
+      throw new Error(`Fly rollback failed: ${normalizeError(rollback.stderr, rollback.stdout)}`);
+    }
+  }
+  /**
+   * Returns deployment logs as an async iterable.
+   */
+  async *logs(options) {
+    const context = this.requireContext();
+    const args = ["logs", "--app", context.appName, "--no-tail"];
+    if (typeof options.since === "string" && options.since.length > 0) {
+      args.push("--region", options.since);
+    }
+    const result = await this.runFlyCommand(args, context.projectRoot, false);
+    if (result.exitCode !== 0) {
+      throw new Error(`Fly logs failed: ${normalizeError(result.stderr, result.stdout)}`);
+    }
+    const lines = result.stdout.split(/\r?\n/).filter((line) => line.length > 0);
+    for (const line of lines) {
+      yield {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level: inferLogLevel(line),
+        message: line
+      };
+    }
+  }
+  /**
+   * Reads current deployment status from Fly.
+   */
+  async status() {
+    const context = this.requireContext();
+    const status = await this.runFlyCommand(
+      ["status", "--app", context.appName, "--json"],
+      context.projectRoot,
+      false
+    );
+    if (status.exitCode !== 0) {
+      return {
+        state: "failed",
+        message: normalizeError(status.stderr, status.stdout)
+      };
+    }
+    const hostname = parseFlyHostname(status.stdout);
+    return {
+      state: "healthy",
+      message: "Fly deployment is healthy.",
+      liveUrl: hostname ? `https://${hostname}` : void 0
+    };
+  }
+  async runFlyCommand(flyArgs, cwd, inheritOutput) {
+    const flyBinary = await this.resolveFlyCommand(cwd);
+    if (inheritOutput) {
+      this.logger.step(`fly ${flyArgs.join(" ")}`);
+    }
+    return await this.runner.run(flyBinary, flyArgs, cwd);
+  }
+  requireContext() {
+    if (!this.currentContext) {
+      throw new Error("Fly adapter context is not initialized. Run provision() first.");
+    }
+    return this.currentContext;
+  }
+  async resolveFlyCommand(cwd) {
+    if (this.flyCommand) {
+      return this.flyCommand;
+    }
+    const resolved = await this.tryResolveFlyCommand(cwd);
+    if (!resolved) {
+      throw new Error("Could not resolve a usable Fly CLI command (tried flyctl, fly).");
+    }
+    this.flyCommand = resolved;
+    return resolved;
+  }
+  async tryResolveFlyCommand(cwd) {
+    for (const command of this.commandCandidates) {
+      const versionCheck = await this.runner.run(command, ["version"], cwd);
+      if (versionCheck.exitCode === 0) {
+        return command;
+      }
+    }
+    return null;
+  }
+};
+var NodeFlyCommandRunner = class {
+  async run(command, args, cwd) {
+    return await new Promise((resolve2) => {
+      const child = spawn2(command, args, {
+        cwd,
+        env: process.env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString("utf-8");
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString("utf-8");
+      });
+      child.on("error", (error) => {
+        resolve2({
+          exitCode: 1,
+          stdout,
+          stderr: `${stderr}
+${error.message}`
+        });
+      });
+      child.on("exit", (code) => {
+        resolve2({
+          exitCode: code ?? 1,
+          stdout: stdout.trim(),
+          stderr: stderr.trim()
+        });
+      });
+    });
+  }
+};
+var DEFAULT_FLY_COMMAND_CANDIDATES = ["flyctl", "fly"];
+function parseFlyHostname(rawJson) {
+  const parsed = parseJsonRecord(rawJson);
+  if (!parsed) return null;
+  const hostname = parsed.Hostname;
+  if (typeof hostname === "string" && hostname.length > 0) {
+    return hostname;
+  }
+  const hostnames = parsed.Hostnames;
+  if (Array.isArray(hostnames)) {
+    const first = hostnames.find((item) => typeof item === "string");
+    if (typeof first === "string" && first.length > 0) {
+      return first;
+    }
+  }
+  return null;
+}
+function parseFlyDeploymentId(rawJson) {
+  const parsed = parseJsonRecord(rawJson);
+  if (!parsed) return null;
+  const deploymentId = parsed.DeploymentID;
+  if (typeof deploymentId === "string" && deploymentId.length > 0) {
+    return deploymentId;
+  }
+  const latestDeployment = parsed.LatestDeployment;
+  if (typeof latestDeployment === "object" && latestDeployment !== null) {
+    const id = latestDeployment.ID;
+    if (typeof id === "string" && id.length > 0) {
+      return id;
+    }
+  }
+  return null;
+}
+function parseJsonRecord(value) {
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function inferLogLevel(line) {
+  const normalized = line.toLowerCase();
+  if (normalized.includes("error")) return "error";
+  if (normalized.includes("warn")) return "warn";
+  if (normalized.includes("debug")) return "debug";
+  return "info";
+}
+function normalizeError(stderr, stdout) {
+  if (stderr.length > 0) return stderr;
+  if (stdout.length > 0) return stdout;
+  return "unknown fly CLI error";
+}
+function isAlreadyExistsResponse(stderr, stdout) {
+  const text = `${stderr}
+${stdout}`.toLowerCase();
+  return text.includes("already exists") || text.includes("already been taken");
+}
+
+// src/commands/deploy/artifacts/railway-json-generator.ts
+import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
+import { join as join5 } from "path";
+var GENERATED_HEADER2 = "Generated by kora deploy - do not edit manually.";
+function generateRailwayJson(options) {
+  const file = {
+    $schema: "https://railway.app/railway.schema.json",
+    build: {
+      builder: "DOCKERFILE",
+      dockerfilePath: "Dockerfile"
+    },
+    deploy: {
+      startCommand: options.startCommand ?? "node ./server-bundled.js",
+      healthcheckPath: options.healthcheckPath ?? "/health",
+      restartPolicyType: "on_failure",
+      restartPolicyMaxRetries: 3
+    },
+    metadata: {
+      generatedBy: GENERATED_HEADER2,
+      appName: options.appName,
+      region: options.region
+    }
+  };
+  return `${JSON.stringify(file, null, 2)}
+`;
+}
+async function writeRailwayJsonArtifact(deployDirectory, options) {
+  await mkdir3(deployDirectory, { recursive: true });
+  const filePath = join5(deployDirectory, "railway.json");
+  await writeFile2(filePath, generateRailwayJson(options), "utf-8");
+  return filePath;
+}
+
+// src/commands/deploy/adapters/railway-adapter.ts
+import { spawn as spawn3 } from "child_process";
+import { join as join6 } from "path";
+var RailwayAdapter = class {
+  name = "railway";
+  logger = createLogger();
+  runner;
+  commandCandidates;
+  railwayCommand = null;
+  currentContext;
+  lastDeploymentId = null;
+  constructor(options = {}) {
+    this.runner = options.runner ?? new NodeRailwayCommandRunner();
+    this.commandCandidates = options.commandCandidates ?? DEFAULT_RAILWAY_COMMAND_CANDIDATES;
+    this.currentContext = options.context ?? null;
+  }
+  setContext(context) {
+    this.currentContext = context;
+  }
+  async detect() {
+    const command = await this.tryResolveRailwayCommand(process.cwd());
+    return command !== null;
+  }
+  async install() {
+    const available = await this.detect();
+    if (!available) {
+      throw new Error(
+        "Railway CLI is required but not installed. Install with `npm i -g @railway/cli` or see https://docs.railway.com/guides/cli."
+      );
+    }
+  }
+  async authenticate() {
+    const projectRoot = this.currentContext?.projectRoot ?? process.cwd();
+    const whoami = await this.runRailwayCommand(["whoami"], projectRoot, false);
+    if (whoami.exitCode === 0) return;
+    const login = await this.runRailwayCommand(["login"], projectRoot, true);
+    if (login.exitCode !== 0) {
+      throw new Error(
+        `Railway authentication failed: ${normalizeError2(login.stderr, login.stdout)}`
+      );
+    }
+  }
+  async provision(config) {
+    this.currentContext = {
+      projectRoot: config.projectRoot,
+      appName: config.appName,
+      region: config.region
+    };
+    const init = await this.runRailwayCommand(
+      ["init", "--name", config.appName, "--confirm"],
+      config.projectRoot,
+      false
+    );
+    if (init.exitCode !== 0 && !isAlreadyExistsResponse2(init.stderr, init.stdout)) {
+      throw new Error(
+        `Railway project provisioning failed for "${config.appName}": ${normalizeError2(init.stderr, init.stdout)}`
+      );
+    }
+    const link = await this.runRailwayCommand(
+      ["link", "--project", config.appName, "--environment", config.environment, "--yes"],
+      config.projectRoot,
+      false
+    );
+    if (link.exitCode !== 0 && !isAlreadyExistsResponse2(link.stderr, link.stdout)) {
+      throw new Error(`Railway link failed: ${normalizeError2(link.stderr, link.stdout)}`);
+    }
+    const vars = [];
+    const setPort = await this.runRailwayCommand(
+      ["variables", "set", "PORT=3000", "--yes"],
+      config.projectRoot,
+      false
+    );
+    if (setPort.exitCode === 0) {
+      vars.push("PORT");
+    }
+    return {
+      applicationId: config.appName,
+      databaseId: null,
+      secretsSet: vars
+    };
+  }
+  async build(config) {
+    this.currentContext = {
+      projectRoot: config.projectRoot,
+      appName: config.appName,
+      region: config.region
+    };
+    const deployDirectory = join6(config.projectRoot, ".kora", "deploy");
+    await writeRailwayJsonArtifact(deployDirectory, {
+      appName: config.appName,
+      environment: config.environment
+    });
+    await bundleServer({
+      projectRoot: config.projectRoot,
+      deployDirectory
+    });
+    const client = await buildClient({
+      projectRoot: config.projectRoot,
+      outDir: join6(deployDirectory, "dist"),
+      mode: "production"
+    });
+    return {
+      clientDirectory: client.outDir,
+      serverBundlePath: join6(deployDirectory, "server-bundled.js"),
+      deployDirectory
+    };
+  }
+  async deploy(artifacts) {
+    const context = this.requireContext();
+    const up = await this.runRailwayCommand(["up", "--yes"], artifacts.deployDirectory, true);
+    if (up.exitCode !== 0) {
+      throw new Error(`Railway deployment failed: ${normalizeError2(up.stderr, up.stdout)}`);
+    }
+    const status = await this.runRailwayCommand(["status", "--json"], context.projectRoot, false);
+    const deploymentId = parseRailwayDeploymentId(status.stdout) ?? (/* @__PURE__ */ new Date()).toISOString();
+    const liveUrl = parseRailwayUrl(status.stdout) ?? `https://${context.appName}.up.railway.app`;
+    this.lastDeploymentId = deploymentId;
+    return {
+      deploymentId,
+      liveUrl,
+      syncUrl: toSyncUrl(liveUrl)
+    };
+  }
+  async rollback(deploymentId) {
+    const context = this.requireContext();
+    const rollback = await this.runRailwayCommand(
+      ["redeploy", "--deployment", deploymentId, "--yes"],
+      context.projectRoot,
+      true
+    );
+    if (rollback.exitCode !== 0) {
+      throw new Error(
+        `Railway rollback failed: ${normalizeError2(rollback.stderr, rollback.stdout)}`
+      );
+    }
+  }
+  async *logs(options) {
+    const context = this.requireContext();
+    const args = ["logs"];
+    if (typeof options.tail === "number" && options.tail > 0) {
+      args.push("--lines", String(options.tail));
+    }
+    const result = await this.runRailwayCommand(args, context.projectRoot, false);
+    if (result.exitCode !== 0) {
+      throw new Error(`Railway logs failed: ${normalizeError2(result.stderr, result.stdout)}`);
+    }
+    const lines = result.stdout.split(/\r?\n/).filter((line) => line.length > 0);
+    for (const line of lines) {
+      yield {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level: inferLogLevel2(line),
+        message: line
+      };
+    }
+  }
+  async status() {
+    const context = this.requireContext();
+    const status = await this.runRailwayCommand(["status", "--json"], context.projectRoot, false);
+    if (status.exitCode !== 0) {
+      return {
+        state: "failed",
+        message: normalizeError2(status.stderr, status.stdout)
+      };
+    }
+    const liveUrl = parseRailwayUrl(status.stdout);
+    return {
+      state: "healthy",
+      message: "Railway deployment is healthy.",
+      liveUrl: liveUrl ?? void 0
+    };
+  }
+  async runRailwayCommand(railwayArgs, cwd, inheritOutput) {
+    const command = await this.resolveRailwayCommand(cwd);
+    if (inheritOutput) {
+      this.logger.step(`railway ${railwayArgs.join(" ")}`);
+    }
+    return await this.runner.run(command, railwayArgs, cwd);
+  }
+  requireContext() {
+    if (!this.currentContext) {
+      throw new Error("Railway adapter context is not initialized. Run provision() first.");
+    }
+    return this.currentContext;
+  }
+  async resolveRailwayCommand(cwd) {
+    if (this.railwayCommand) {
+      return this.railwayCommand;
+    }
+    const resolved = await this.tryResolveRailwayCommand(cwd);
+    if (!resolved) {
+      throw new Error("Could not resolve a usable Railway CLI command (tried railway).");
+    }
+    this.railwayCommand = resolved;
+    return resolved;
+  }
+  async tryResolveRailwayCommand(cwd) {
+    for (const command of this.commandCandidates) {
+      const version = await this.runner.run(command, ["--version"], cwd);
+      if (version.exitCode === 0) {
+        return command;
+      }
+    }
+    return null;
+  }
+};
+var NodeRailwayCommandRunner = class {
+  async run(command, args, cwd) {
+    return await new Promise((resolve2) => {
+      const child = spawn3(command, args, {
+        cwd,
+        env: process.env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString("utf-8");
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString("utf-8");
+      });
+      child.on("error", (error) => {
+        resolve2({
+          exitCode: 1,
+          stdout,
+          stderr: `${stderr}
+${error.message}`
+        });
+      });
+      child.on("exit", (code) => {
+        resolve2({
+          exitCode: code ?? 1,
+          stdout: stdout.trim(),
+          stderr: stderr.trim()
+        });
+      });
+    });
+  }
+};
+var DEFAULT_RAILWAY_COMMAND_CANDIDATES = ["railway"];
+function parseRailwayUrl(rawJson) {
+  const record = parseJsonRecord2(rawJson);
+  if (!record) return null;
+  const url = record.url;
+  if (typeof url === "string" && url.length > 0) {
+    return ensureHttpsUrl(url);
+  }
+  const service = record.service;
+  if (typeof service === "object" && service !== null) {
+    const domain = service.domain;
+    if (typeof domain === "string" && domain.length > 0) {
+      return ensureHttpsUrl(domain);
+    }
+  }
+  return null;
+}
+function parseRailwayDeploymentId(rawJson) {
+  const record = parseJsonRecord2(rawJson);
+  if (!record) return null;
+  const deploymentId = record.deploymentId;
+  if (typeof deploymentId === "string" && deploymentId.length > 0) {
+    return deploymentId;
+  }
+  const deployment = record.deployment;
+  if (typeof deployment === "object" && deployment !== null) {
+    const id = deployment.id;
+    if (typeof id === "string" && id.length > 0) {
+      return id;
+    }
+  }
+  return null;
+}
+function parseJsonRecord2(value) {
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function toSyncUrl(liveUrl) {
+  try {
+    const url = new URL(liveUrl);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    url.pathname = "/kora-sync";
+    return url.toString().replace(/\/$/, "");
+  } catch {
+    return null;
+  }
+}
+function ensureHttpsUrl(value) {
+  if (value.startsWith("http://") || value.startsWith("https://")) {
+    return value;
+  }
+  return `https://${value}`;
+}
+function inferLogLevel2(line) {
+  const normalized = line.toLowerCase();
+  if (normalized.includes("error")) return "error";
+  if (normalized.includes("warn")) return "warn";
+  if (normalized.includes("debug")) return "debug";
+  return "info";
+}
+function normalizeError2(stderr, stdout) {
+  if (stderr.length > 0) return stderr;
+  if (stdout.length > 0) return stdout;
+  return "unknown railway CLI error";
+}
+function isAlreadyExistsResponse2(stderr, stdout) {
+  const text = `${stderr}
+${stdout}`.toLowerCase();
+  return text.includes("already exists");
+}
+
+// src/commands/deploy/adapters/stub-adapter.ts
+var StubDeployAdapter = class {
+  name;
+  contextLabel;
+  constructor(platform) {
+    this.name = platform;
+    this.contextLabel = `Deploy adapter "${platform}" is not implemented yet.`;
+  }
+  setContext(_context) {
+  }
+  async detect() {
+    return false;
+  }
+  async install() {
+    throw this.notImplementedError();
+  }
+  async authenticate() {
+    throw this.notImplementedError();
+  }
+  async provision(_config) {
+    throw this.notImplementedError();
+  }
+  async build(_config) {
+    throw this.notImplementedError();
+  }
+  async deploy(_artifacts) {
+    throw this.notImplementedError();
+  }
+  async rollback(_deploymentId) {
+    throw this.notImplementedError();
+  }
+  logs(_options) {
+    throw this.notImplementedError();
+  }
+  async status() {
+    return {
+      state: "unknown",
+      message: this.notImplementedMessage()
+    };
+  }
+  notImplementedError() {
+    return new Error(this.notImplementedMessage());
+  }
+  notImplementedMessage() {
+    return `${this.contextLabel} Start with --platform fly for now.`;
+  }
+};
+
+// src/commands/deploy/adapters/factory.ts
+function createDeployAdapter(platform) {
+  switch (platform) {
+    case "fly":
+      return new FlyAdapter();
+    case "railway":
+      return new RailwayAdapter();
+    case "render":
+    case "docker":
+    case "kora-cloud":
+      return new StubDeployAdapter(platform);
+    default: {
+      const exhaustiveCheck = platform;
+      return exhaustiveCheck;
+    }
+  }
+}
+
+// src/commands/deploy/artifacts/dockerfile-generator.ts
+import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
+import { join as join7 } from "path";
+var GENERATED_HEADER3 = "# Generated by kora deploy \u2014 do not edit manually";
+function generateDockerfile(options = {}) {
+  const nodeVersion = options.nodeVersion ?? "20-alpine";
+  const port = options.port ?? 3e3;
+  const clientDirectory = options.clientDirectory ?? "dist";
+  const serverBundleFile = options.serverBundleFile ?? "server-bundled.js";
+  const hasNativeDeps = options.nativeDependencies && Object.keys(options.nativeDependencies).length > 0;
+  const lines = [
+    GENERATED_HEADER3,
+    "",
+    `FROM node:${nodeVersion} AS runtime`,
+    "WORKDIR /app",
+    "ENV NODE_ENV=production",
+    `ENV PORT=${String(port)}`,
+    ""
+  ];
+  if (hasNativeDeps) {
+    lines.push("# Install build tools for native modules");
+    lines.push("RUN apk add --no-cache python3 make g++");
+    lines.push("");
+    lines.push("COPY package.json ./package.json");
+    lines.push("RUN npm install --omit=dev");
+    lines.push("");
+  }
+  lines.push(`COPY ${clientDirectory} ./dist`);
+  lines.push(`COPY ${serverBundleFile} ./server-bundled.js`);
+  lines.push("");
+  lines.push(`EXPOSE ${String(port)}`);
+  lines.push('CMD ["node", "./server-bundled.js"]');
+  lines.push("");
+  return lines.join("\n");
+}
+function generateDeployPackageJson(nativeDependencies) {
+  const pkg = {
+    name: "kora-deploy",
+    version: "1.0.0",
+    private: true,
+    type: "module",
+    dependencies: nativeDependencies
+  };
+  return JSON.stringify(pkg, null, 2) + "\n";
+}
+function generateDockerIgnore() {
+  return [
+    GENERATED_HEADER3,
+    "",
+    "node_modules",
+    "npm-debug.log*",
+    "pnpm-debug.log*",
+    "yarn-error.log*",
+    ".env",
+    ".env.*",
+    ".git",
+    ".gitignore",
+    "coverage",
+    ".turbo",
+    "*.test.ts",
+    "*.spec.ts",
+    ""
+  ].join("\n");
+}
+async function writeDockerfileArtifact(deployDirectory, options = {}) {
+  await mkdir4(deployDirectory, { recursive: true });
+  const dockerfilePath = join7(deployDirectory, "Dockerfile");
+  await writeFile3(dockerfilePath, generateDockerfile(options), "utf-8");
+  if (options.nativeDependencies && Object.keys(options.nativeDependencies).length > 0) {
+    const pkgJsonPath = join7(deployDirectory, "package.json");
+    await writeFile3(pkgJsonPath, generateDeployPackageJson(options.nativeDependencies), "utf-8");
+  }
+  return dockerfilePath;
+}
+async function writeDockerIgnoreArtifact(deployDirectory) {
+  await mkdir4(deployDirectory, { recursive: true });
+  const dockerIgnorePath = join7(deployDirectory, ".dockerignore");
+  await writeFile3(dockerIgnorePath, generateDockerIgnore(), "utf-8");
+  return dockerIgnorePath;
+}
+
+// src/commands/deploy/state/deploy-state.ts
+import { mkdir as mkdir5, readFile, rm, writeFile as writeFile4 } from "fs/promises";
+import { join as join8 } from "path";
+var KORA_DEPLOY_DIRECTORY = join8(".kora", "deploy");
+var DEPLOY_STATE_FILENAME = "deploy.json";
+function resolveDeployDirectory(projectRoot) {
+  return join8(projectRoot, KORA_DEPLOY_DIRECTORY);
+}
+function resolveDeployStatePath(projectRoot) {
+  return join8(resolveDeployDirectory(projectRoot), DEPLOY_STATE_FILENAME);
+}
+async function readDeployState(projectRoot) {
+  const statePath = resolveDeployStatePath(projectRoot);
+  try {
+    const source = await readFile(statePath, "utf-8");
+    const parsed = JSON.parse(source);
+    return parseDeployState(parsed);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function writeDeployState(projectRoot, input, now = /* @__PURE__ */ new Date()) {
+  const timestamp = now.toISOString();
+  const state = {
+    platform: input.platform,
+    appName: input.appName,
+    region: input.region,
+    projectRoot: input.projectRoot,
+    liveUrl: input.liveUrl ?? null,
+    syncUrl: input.syncUrl ?? null,
+    databaseId: input.databaseId ?? null,
+    lastDeploymentId: input.lastDeploymentId ?? null,
+    createdAt: timestamp,
+    updatedAt: timestamp
+  };
+  await persistDeployState(projectRoot, state);
+  return state;
+}
+async function updateDeployState(projectRoot, patch, now = /* @__PURE__ */ new Date()) {
+  const existing = await readDeployState(projectRoot);
+  if (!existing) {
+    throw new Error("Cannot update deploy state because deploy.json does not exist yet.");
+  }
+  const nextState = {
+    platform: patch.platform ?? existing.platform,
+    appName: patch.appName ?? existing.appName,
+    region: patch.region === void 0 ? existing.region : patch.region,
+    projectRoot: patch.projectRoot ?? existing.projectRoot,
+    liveUrl: patch.liveUrl === void 0 ? existing.liveUrl : patch.liveUrl,
+    syncUrl: patch.syncUrl === void 0 ? existing.syncUrl : patch.syncUrl,
+    databaseId: patch.databaseId === void 0 ? existing.databaseId : patch.databaseId,
+    lastDeploymentId: patch.lastDeploymentId === void 0 ? existing.lastDeploymentId : patch.lastDeploymentId,
+    createdAt: existing.createdAt,
+    updatedAt: now.toISOString()
+  };
+  await persistDeployState(projectRoot, nextState);
+  return nextState;
+}
+async function resetDeployState(projectRoot) {
+  await rm(resolveDeployDirectory(projectRoot), { recursive: true, force: true });
+}
+async function persistDeployState(projectRoot, state) {
+  const deployDir = resolveDeployDirectory(projectRoot);
+  const statePath = resolveDeployStatePath(projectRoot);
+  await mkdir5(deployDir, { recursive: true });
+  await writeFile4(statePath, `${JSON.stringify(state, null, 2)}
+`, "utf-8");
+}
+function parseDeployState(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("Invalid deploy state: expected an object.");
+  }
+  const record = value;
+  const platform = readPlatform(record.platform);
+  const appName = readString(record.appName, "appName");
+  const region = readOptionalString(record.region, "region");
+  const projectRoot = readString(record.projectRoot, "projectRoot");
+  const liveUrl = readOptionalString(record.liveUrl, "liveUrl");
+  const syncUrl = readOptionalString(record.syncUrl, "syncUrl");
+  const databaseId = readOptionalString(record.databaseId, "databaseId");
+  const lastDeploymentId = readOptionalString(record.lastDeploymentId, "lastDeploymentId");
+  const createdAt = readString(record.createdAt, "createdAt");
+  const updatedAt = readString(record.updatedAt, "updatedAt");
+  return {
+    platform,
+    appName,
+    region,
+    projectRoot,
+    liveUrl,
+    syncUrl,
+    databaseId,
+    lastDeploymentId,
+    createdAt,
+    updatedAt
+  };
+}
+function readPlatform(value) {
+  if (typeof value !== "string" || !isDeployPlatform(value)) {
+    throw new Error('Invalid deploy state: "platform" must be a supported platform.');
+  }
+  return value;
+}
+function readString(value, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Invalid deploy state: "${field}" must be a non-empty string.`);
+  }
+  return value;
+}
+function readOptionalString(value, field) {
+  if (value === null) return null;
+  if (typeof value === "string") return value;
+  throw new Error(`Invalid deploy state: "${field}" must be a string or null.`);
+}
+
+// src/commands/deploy/deploy-command.ts
+import { basename } from "path";
+import { defineCommand } from "citty";
+var deployCommand = defineCommand({
+  meta: {
+    name: "deploy",
+    description: "Deploy a Kora project to your selected platform"
+  },
+  args: {
+    platform: {
+      type: "string",
+      description: `Deployment platform (${DEPLOY_PLATFORMS.join(", ")})`
+    },
+    app: {
+      type: "string",
+      description: "Application name used by the target platform"
+    },
+    region: {
+      type: "string",
+      description: "Preferred deployment region (for example: iad, lhr, syd)"
+    },
+    prod: {
+      type: "boolean",
+      description: "Deploy to production environment",
+      default: false
+    },
+    confirm: {
+      type: "boolean",
+      description: "Non-interactive mode (fail fast on missing required data)",
+      default: false
+    },
+    reset: {
+      type: "boolean",
+      description: "Delete .kora/deploy state and generated artifacts",
+      default: false
+    }
+  },
+  subCommands: {
+    status: defineCommand({
+      meta: {
+        name: "status",
+        description: "Show current deployment status"
+      },
+      async run() {
+        const logger = createLogger();
+        const projectRoot = await requireProjectRoot();
+        const state = await readDeployState(projectRoot);
+        if (!state) {
+          logger.warn("No deployment state found. Run `kora deploy` first.");
+          return;
+        }
+        logger.banner();
+        logger.info(`Platform: ${state.platform}`);
+        logger.step(`App: ${state.appName}`);
+        logger.step(`Region: ${state.region ?? "n/a"}`);
+        logger.step(`Last deployment: ${state.lastDeploymentId ?? "n/a"}`);
+        const adapter = createDeployAdapter(state.platform);
+        configureAdapterContext(adapter, {
+          projectRoot,
+          appName: state.appName,
+          region: state.region
+        });
+        const adapterStatus = await adapter.status();
+        logger.step(`Status: ${adapterStatus.state}`);
+        logger.step(`Message: ${adapterStatus.message}`);
+        logger.step(`Live URL: ${adapterStatus.liveUrl ?? state.liveUrl ?? "n/a"}`);
+        logger.step(`Sync URL: ${state.syncUrl ?? "n/a"}`);
+      }
+    }),
+    rollback: defineCommand({
+      meta: {
+        name: "rollback",
+        description: "Rollback the current deployment"
+      },
+      args: {
+        id: {
+          type: "positional",
+          description: "Optional deployment identifier",
+          required: false
+        }
+      },
+      async run({ args }) {
+        const logger = createLogger();
+        const projectRoot = await requireProjectRoot();
+        const state = await readDeployState(projectRoot);
+        if (!state) {
+          logger.warn("No deployment state found. Run `kora deploy` first.");
+          return;
+        }
+        const adapter = createDeployAdapter(state.platform);
+        configureAdapterContext(adapter, {
+          projectRoot,
+          appName: state.appName,
+          region: state.region
+        });
+        const deploymentId = typeof args.id === "string" && args.id.length > 0 ? args.id : state.lastDeploymentId ?? "latest";
+        await adapter.rollback(deploymentId);
+        logger.success(`Rolled back ${state.platform} deployment to ${deploymentId}.`);
+      }
+    }),
+    logs: defineCommand({
+      meta: {
+        name: "logs",
+        description: "Read deployment logs"
+      },
+      async run() {
+        const logger = createLogger();
+        const projectRoot = await requireProjectRoot();
+        const state = await readDeployState(projectRoot);
+        if (!state) {
+          logger.warn("No deployment state found. Run `kora deploy` first.");
+          return;
+        }
+        const adapter = createDeployAdapter(state.platform);
+        configureAdapterContext(adapter, {
+          projectRoot,
+          appName: state.appName,
+          region: state.region
+        });
+        const logLines = adapter.logs({ tail: 200 });
+        let hasLines = false;
+        for await (const line of logLines) {
+          hasLines = true;
+          logger.step(`[${line.level}] ${line.message}`);
+        }
+        if (!hasLines) {
+          logger.warn(`No logs returned from ${state.platform}.`);
+        }
+      }
+    })
+  },
+  async run({ args, rawArgs }) {
+    const subCommandNames = ["status", "rollback", "logs"];
+    if (rawArgs.some((arg) => subCommandNames.includes(arg))) {
+      return;
+    }
+    const logger = createLogger();
+    const prompts = createPromptClient();
+    const projectRoot = await requireProjectRoot();
+    if (args.reset === true) {
+      await resetDeployState(projectRoot);
+      logger.success("Reset .kora/deploy state.");
+      return;
+    }
+    const existingState = await readDeployState(projectRoot);
+    const confirmMode = args.confirm === true;
+    const platform = await resolvePlatform({
+      promptClient: prompts,
+      platformArg: args.platform,
+      storedPlatform: existingState?.platform,
+      confirm: confirmMode
+    });
+    const appName = resolveAppName(args.app, existingState?.appName, projectRoot, confirmMode);
+    const region = resolveRegion(args.region, existingState?.region, confirmMode);
+    const deployDirectory = resolveDeployDirectory(projectRoot);
+    const environment = args.prod === true ? "production" : "preview";
+    const config = {
+      projectRoot,
+      appName,
+      region,
+      environment,
+      confirm: confirmMode
+    };
+    const adapter = createDeployAdapter(platform);
+    configureAdapterContext(adapter, {
+      projectRoot,
+      appName,
+      region
+    });
+    logger.banner();
+    logger.info(
+      `Deploying to ${platform} (${appName}${region ? `, ${region}` : ""}, ${environment})`
+    );
+    if (confirmMode) {
+      logger.step("Running in --confirm mode (non-interactive, fail-fast).");
+    }
+    await writeDockerfileArtifact(deployDirectory, {
+      nativeDependencies: {
+        "better-sqlite3": "^11.0.0",
+        "drizzle-orm": "^0.45.2"
+      }
+    });
+    await writeDockerIgnoreArtifact(deployDirectory);
+    const detected = await adapter.detect();
+    if (!detected) {
+      await adapter.install();
+    }
+    await adapter.authenticate();
+    const provisionResult = await adapter.provision(config);
+    const artifacts = await adapter.build(config);
+    const deployResult = await adapter.deploy(artifacts);
+    if (existingState) {
+      await updateDeployState(projectRoot, {
+        platform,
+        appName,
+        region,
+        projectRoot,
+        liveUrl: deployResult.liveUrl,
+        syncUrl: deployResult.syncUrl,
+        databaseId: provisionResult.databaseId,
+        lastDeploymentId: deployResult.deploymentId
+      });
+    } else {
+      await writeDeployState(projectRoot, {
+        platform,
+        appName,
+        region,
+        projectRoot,
+        liveUrl: deployResult.liveUrl,
+        syncUrl: deployResult.syncUrl,
+        databaseId: provisionResult.databaseId,
+        lastDeploymentId: deployResult.deploymentId
+      });
+    }
+    logger.success(`Deployment completed: ${deployResult.liveUrl}`);
+    if (deployResult.syncUrl) {
+      logger.step(`Sync endpoint: ${deployResult.syncUrl}`);
+    }
+  }
+});
+async function resolvePlatform(options) {
+  if (typeof options.platformArg === "string") {
+    if (!isDeployPlatform(options.platformArg)) {
+      throw new Error(
+        `Invalid --platform value "${options.platformArg}". Valid options: ${DEPLOY_PLATFORMS.join(", ")}`
+      );
+    }
+    return options.platformArg;
+  }
+  if (options.storedPlatform) {
+    return options.storedPlatform;
+  }
+  if (options.confirm || !isInteractiveTerminal()) {
+    throw new Error(
+      "Missing deploy platform in --confirm mode. Provide --platform or run an interactive deploy first."
+    );
+  }
+  return await options.promptClient.select("Where do you want to deploy?", [
+    {
+      label: "Fly.io (recommended for sync apps)",
+      value: "fly"
+    },
+    {
+      label: "Railway",
+      value: "railway"
+    },
+    {
+      label: "Render",
+      value: "render"
+    },
+    {
+      label: "Docker (self-hosted)",
+      value: "docker"
+    },
+    {
+      label: "Kora Cloud (coming soon)",
+      value: "kora-cloud"
+    }
+  ]);
+}
+function resolveAppName(argValue, storedValue, projectRoot, confirm) {
+  if (typeof argValue === "string" && argValue.length > 0) {
+    return sanitizeAppName(argValue);
+  }
+  if (storedValue && storedValue.length > 0) {
+    return storedValue;
+  }
+  if (confirm) {
+    throw new Error(
+      "Missing app name in --confirm mode. Provide --app or run an interactive deploy first."
+    );
+  }
+  return sanitizeAppName(basename(projectRoot));
+}
+function resolveRegion(argValue, storedValue, confirm) {
+  if (typeof argValue === "string" && argValue.length > 0) return argValue;
+  if (storedValue !== void 0) return storedValue;
+  if (confirm) {
+    throw new Error(
+      "Missing region in --confirm mode. Provide --region or run an interactive deploy first."
+    );
+  }
+  return "iad";
+}
+function sanitizeAppName(value) {
+  const normalized = value.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-{2,}/g, "-").replace(/^-|-$/g, "");
+  if (normalized.length === 0) {
+    return "kora-app";
+  }
+  return normalized;
+}
+async function requireProjectRoot() {
+  const projectRoot = await findProjectRoot();
+  if (!projectRoot) {
+    throw new InvalidProjectError(process.cwd());
+  }
+  return projectRoot;
+}
+function isInteractiveTerminal() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function configureAdapterContext(adapter, context) {
+  if (hasContextSetter(adapter)) {
+    adapter.setContext(context);
+  }
+}
+function hasContextSetter(adapter) {
+  return typeof adapter.setContext === "function";
+}
+
+// src/commands/generate/type-generator.ts
+function generateTypes(schema) {
+  const lines = [
+    "// Auto-generated by @korajs/cli \u2014 do not edit manually",
+    `// Generated from schema version ${String(schema.version)}`,
+    ""
+  ];
+  const collectionNames = Object.keys(schema.collections);
+  if (collectionNames.length === 0) {
+    return lines.join("\n");
+  }
+  for (const [name, collection] of Object.entries(schema.collections)) {
+    const pascal = toPascalCase(name);
+    const fields = collection.fields;
+    lines.push(`export interface ${pascal}Record {`);
+    lines.push("	readonly id: string");
+    for (const [fieldName, descriptor] of Object.entries(fields)) {
+      const tsType = fieldKindToTypeScript(descriptor);
+      const optional = !descriptor.required && !descriptor.auto ? "?" : "";
+      lines.push(`	readonly ${fieldName}${optional}: ${tsType}`);
+    }
+    lines.push("}");
+    lines.push("");
+    lines.push(`export interface ${pascal}InsertInput {`);
+    for (const [fieldName, descriptor] of Object.entries(fields)) {
+      if (descriptor.auto) continue;
+      const tsType = fieldKindToTypeScript(descriptor);
+      const optional = !descriptor.required || descriptor.defaultValue !== void 0 ? "?" : "";
+      lines.push(`	${fieldName}${optional}: ${tsType}`);
+    }
+    lines.push("}");
+    lines.push("");
+    lines.push(`export interface ${pascal}UpdateInput {`);
+    for (const [fieldName, descriptor] of Object.entries(fields)) {
+      if (descriptor.auto) continue;
+      const tsType = fieldKindToTypeScript(descriptor);
+      lines.push(`	${fieldName}?: ${tsType}`);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function fieldKindToTypeScript(descriptor) {
+  switch (descriptor.kind) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "timestamp":
+      return "number";
+    case "richtext":
+      return "string";
+    case "enum": {
+      if (descriptor.enumValues && descriptor.enumValues.length > 0) {
+        return descriptor.enumValues.map((v) => `'${v}'`).join(" | ");
+      }
+      return "string";
+    }
+    case "array": {
+      const itemType = itemKindToTypeScript(descriptor.itemKind);
+      return `Array<${itemType}>`;
+    }
+    default:
+      return "unknown";
+  }
+}
+function itemKindToTypeScript(kind) {
+  switch (kind) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "timestamp":
+      return "number";
+    case "richtext":
+      return "string";
+    case "enum":
+      return "string";
+    case "array":
+      return "unknown[]";
+    default:
+      return "unknown";
+  }
+}
+function toPascalCase(name) {
+  return name.split(/[_-]/).map((part) => {
+    if (part.length === 0) return "";
+    const first = part[0];
+    return first ? first.toUpperCase() + part.slice(1) : "";
+  }).join("");
+}
+
+export {
+  DEPLOY_PLATFORMS,
+  isDeployPlatform,
+  generateFlyToml,
+  writeFlyTomlArtifact,
+  buildClient,
+  bundleServer,
+  FlyAdapter,
+  NodeFlyCommandRunner,
+  generateRailwayJson,
+  writeRailwayJsonArtifact,
+  RailwayAdapter,
+  NodeRailwayCommandRunner,
+  StubDeployAdapter,
+  createDeployAdapter,
+  generateDockerfile,
+  generateDeployPackageJson,
+  generateDockerIgnore,
+  writeDockerfileArtifact,
+  writeDockerIgnoreArtifact,
+  resolveDeployDirectory,
+  resolveDeployStatePath,
+  readDeployState,
+  writeDeployState,
+  updateDeployState,
+  resetDeployState,
+  deployCommand,
+  generateTypes
+};
+//# sourceMappingURL=chunk-E4JG7THU.js.map