@meetploy/cli 1.5.0 → 1.7.0

package/dist/index.js

@@ -1,72 +1,3009 @@
 #!/usr/bin/env node
-import { buildCommand, parseBuildArgs } from "./commands/build.js";
-import { typesCommand, parseTypesArgs } from "./commands/types.js";
-const args = process.argv.slice(2);
-const command = args[0];
-if (!command) {
-    console.error("Usage: ploy <command>");
-    console.error("\nAvailable commands:");
-    console.error("  build  Build your Ploy project");
-    console.error("  dev    Start development server");
-    console.error("  types  Generate TypeScript types from ploy.yaml");
-    process.exit(1);
+import { createRequire } from 'module';
+import { mkdir, writeFile, readFile, access } from 'fs/promises';
+import { join, dirname } from 'path';
+import { existsSync, readFileSync, readFile as readFile$1, mkdirSync, writeFileSync } from 'fs';
+import { promisify } from 'util';
+import { parse } from 'yaml';
+import { build } from 'esbuild';
+import { watch } from 'chokidar';
+import { fileURLToPath } from 'url';
+import { randomUUID, createHash } from 'crypto';
+import { serve } from '@hono/node-server';
+import { Hono } from 'hono';
+import { tmpdir } from 'os';
+import Database from 'better-sqlite3';
+import { spawn } from 'child_process';
+
+createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+async function isPnpmWorkspace(projectDir) {
+  try {
+    await access(join(projectDir, "pnpm-workspace.yaml"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getAddDevDependencyCommand(packageManager, packages, isPnpmWorkspace2 = false) {
+  const packageList = packages.join(" ");
+  switch (packageManager) {
+    case "npm":
+      return `npm install --save-dev ${packageList}`;
+    case "yarn":
+      return `yarn add -D ${packageList}`;
+    case "pnpm":
+      return isPnpmWorkspace2 ? `pnpm add -w -D ${packageList}` : `pnpm add -D ${packageList}`;
+  }
+}
+function getRunCommand(packageManager, command2) {
+  switch (packageManager) {
+    case "npm":
+      return `npx ${command2}`;
+    case "yarn":
+      return `yarn ${command2}`;
+    case "pnpm":
+      return `pnpm ${command2}`;
+  }
+}
+var init_package_manager = __esm({
+  "../tools/dist/package-manager.js"() {
+  }
+});
+function validateBindings(bindings, bindingType, configFile) {
+  if (bindings === void 0) {
+    return;
+  }
+  if (typeof bindings !== "object" || bindings === null) {
+    throw new Error(`'${bindingType}' in ${configFile} must be an object`);
+  }
+  for (const [bindingName, resourceName] of Object.entries(bindings)) {
+    if (!BINDING_NAME_REGEX.test(bindingName)) {
+      throw new Error(`Invalid ${bindingType} binding name '${bindingName}' in ${configFile}. Binding names must be uppercase with underscores (e.g., DB, USERS_DB)`);
+    }
+    if (typeof resourceName !== "string") {
+      throw new Error(`${bindingType} binding '${bindingName}' in ${configFile} must have a string value`);
+    }
+    if (!RESOURCE_NAME_REGEX.test(resourceName)) {
+      throw new Error(`Invalid ${bindingType} resource name '${resourceName}' for binding '${bindingName}' in ${configFile}. Resource names must be lowercase with underscores (e.g., default, users_db)`);
+    }
+  }
+}
+function validateRelativePath(path, fieldName, configFile) {
+  if (path === void 0) {
+    return void 0;
+  }
+  if (typeof path !== "string") {
+    throw new Error(`'${fieldName}' in ${configFile} must be a string`);
+  }
+  const normalized = path.replace(/\/+$/, "");
+  if (normalized.startsWith("/")) {
+    throw new Error(`'${fieldName}' in ${configFile} must be a relative path, not absolute`);
+  }
+  if (normalized.includes("..")) {
+    throw new Error(`'${fieldName}' in ${configFile} cannot contain path traversal (..)`);
+  }
+  return normalized;
+}
+function validatePloyConfig(config, configFile = "ploy.yaml", options = {}) {
+  const { requireKind = false, requireBuildForStatic = true, allowedKinds = ["nextjs", "static", "dynamic", "worker"] } = options;
+  const validatedConfig = { ...config };
+  if (requireKind && !config.kind) {
+    throw new Error(`Missing required field 'kind' in ${configFile}`);
+  }
+  if (config.kind !== void 0) {
+    if (!allowedKinds.includes(config.kind)) {
+      throw new Error(`Invalid kind '${config.kind}' in ${configFile}. Must be one of: ${allowedKinds.join(", ")}`);
+    }
+  }
+  if (requireBuildForStatic && config.kind === "static" && !config.build) {
+    throw new Error(`Build command is required when kind is 'static' in ${configFile}`);
+  }
+  if (config.build !== void 0 && typeof config.build !== "string") {
+    throw new Error(`'build' in ${configFile} must be a string`);
+  }
+  validatedConfig.out = validateRelativePath(config.out, "out", configFile);
+  validatedConfig.base = validateRelativePath(config.base, "base", configFile);
+  validatedConfig.main = validateRelativePath(config.main, "main", configFile);
+  validateBindings(config.db, "db", configFile);
+  validateBindings(config.queue, "queue", configFile);
+  validateBindings(config.workflow, "workflow", configFile);
+  if (config.ai !== void 0 && typeof config.ai !== "boolean") {
+    throw new Error(`'ai' in ${configFile} must be a boolean`);
+  }
+  if (config.monorepo !== void 0 && typeof config.monorepo !== "boolean") {
+    throw new Error(`'monorepo' in ${configFile} must be a boolean`);
+  }
+  return validatedConfig;
+}
+async function readPloyConfig(projectDir, configPath) {
+  const configFile = configPath || "ploy.yaml";
+  const fullPath = join(projectDir, configFile);
+  try {
+    const content = await readFileAsync(fullPath, "utf-8");
+    return parse(content);
+  } catch (error2) {
+    if (error2 && typeof error2 === "object" && "code" in error2) {
+      if (error2.code === "ENOENT") {
+        return null;
+      }
+    }
+    throw error2;
+  }
+}
+function readPloyConfigSync(projectDir, configPath) {
+  const configFile = configPath || "ploy.yaml";
+  const fullPath = join(projectDir, configFile);
+  if (!existsSync(fullPath)) {
+    throw new Error(`Config file not found: ${fullPath}`);
+  }
+  const content = readFileSync(fullPath, "utf-8");
+  return parse(content);
+}
+async function readAndValidatePloyConfig(projectDir, configPath, validationOptions) {
+  const configFile = configPath || "ploy.yaml";
+  const config = await readPloyConfig(projectDir, configPath);
+  if (!config) {
+    return null;
+  }
+  return validatePloyConfig(config, configFile, validationOptions);
+}
+function readAndValidatePloyConfigSync(projectDir, configPath, validationOptions) {
+  const configFile = configPath || "ploy.yaml";
+  const config = readPloyConfigSync(projectDir, configPath);
+  return validatePloyConfig(config, configFile, validationOptions);
+}
+function hasBindings(config) {
+  return !!(config.db || config.queue || config.workflow || config.ai);
+}
+function getWorkerEntryPoint(projectDir, config) {
+  if (config.main) {
+    return join(projectDir, config.main);
+  }
+  const defaultPaths = [
+    join(projectDir, "index.ts"),
+    join(projectDir, "index.js"),
+    join(projectDir, "src", "index.ts"),
+    join(projectDir, "src", "index.js")
+  ];
+  for (const path of defaultPaths) {
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  throw new Error("Could not find worker entry point. Specify 'main' in ploy.yaml");
+}
+var readFileAsync, BINDING_NAME_REGEX, RESOURCE_NAME_REGEX;
+var init_ploy_config = __esm({
+  "../tools/dist/ploy-config.js"() {
+    readFileAsync = promisify(readFile$1);
+    BINDING_NAME_REGEX = /^[A-Z][A-Z0-9_]*$/;
+    RESOURCE_NAME_REGEX = /^[a-z][a-z0-9_]*$/;
+  }
+});
+
+// ../tools/dist/cli.js
+var cli_exports = {};
+__export(cli_exports, {
+  getAddDevDependencyCommand: () => getAddDevDependencyCommand,
+  getRunCommand: () => getRunCommand,
+  getWorkerEntryPoint: () => getWorkerEntryPoint,
+  hasBindings: () => hasBindings,
+  isPnpmWorkspace: () => isPnpmWorkspace,
+  readAndValidatePloyConfig: () => readAndValidatePloyConfig,
+  readAndValidatePloyConfigSync: () => readAndValidatePloyConfigSync,
+  readPloyConfig: () => readPloyConfig,
+  readPloyConfigSync: () => readPloyConfigSync,
+  validatePloyConfig: () => validatePloyConfig
+});
+var init_cli = __esm({
+  "../tools/dist/cli.js"() {
+    init_package_manager();
+    init_ploy_config();
+  }
+});
+
+// ../shared/dist/d1-runtime.js
+var DB_RUNTIME_CODE, DB_RUNTIME_CODE_PRODUCTION;
+var init_d1_runtime = __esm({
+  "../shared/dist/d1-runtime.js"() {
+    DB_RUNTIME_CODE = `
+interface DBResult {
+  results: unknown[];
+  success: boolean;
+  meta: {
+    duration: number;
+    rows_read: number;
+    rows_written: number;
+  };
+}
+
+interface DBPreparedStatement {
+  bind: (...values: unknown[]) => DBPreparedStatement;
+  run: () => Promise<DBResult>;
+  all: () => Promise<DBResult>;
+  first: (colName?: string) => Promise<unknown | null>;
+  raw: (options?: { columnNames?: boolean }) => Promise<unknown[][]>;
+}
+
+interface DBDatabase {
+  prepare: (query: string) => DBPreparedStatement;
+  dump: () => Promise<ArrayBuffer>;
+  batch: (statements: DBPreparedStatement[]) => Promise<DBResult[]>;
+  exec: (query: string) => Promise<DBResult>;
+}
+
+export function initializeDB(bindingName: string, serviceUrl: string): DBDatabase {
+  return {
+    prepare(query: string): DBPreparedStatement {
+      let boundParams: unknown[] = [];
+
+      const stmt: DBPreparedStatement = {
+        bind(...values: unknown[]) {
+          boundParams = values;
+          return this;
+        },
+
+        async run(): Promise<DBResult> {
+          const response = await fetch(serviceUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              bindingName,
+              method: "prepare",
+              query,
+              params: boundParams,
+            }),
+          });
+
+          if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error("DB query failed: " + errorText);
+          }
+
+          return await response.json();
+        },
+
+        async all(): Promise<DBResult> {
+          return await this.run();
+        },
+
+        async first(colName?: string): Promise<unknown | null> {
+          const result = await this.run();
+          if (result.results.length === 0) {
+            return null;
+          }
+
+          const firstRow = result.results[0] as Record<string, unknown>;
+          if (colName) {
+            return firstRow[colName] ?? null;
+          }
+          return firstRow;
+        },
+
+        async raw(options?: { columnNames?: boolean }): Promise<unknown[][]> {
+          const result = await this.run();
+          const rows = result.results as Record<string, unknown>[];
+
+          if (rows.length === 0) {
+            return [];
+          }
+
+          const keys = Object.keys(rows[0]);
+          const arrayRows = rows.map((row) => keys.map((key) => row[key]));
+
+          if (options?.columnNames) {
+            return [keys, ...arrayRows];
+          }
+
+          return arrayRows;
+        },
+      };
+
+      return stmt;
+    },
+
+    async dump(): Promise<ArrayBuffer> {
+      const response = await fetch(serviceUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          bindingName,
+          method: "dump",
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error("DB dump failed: " + response.statusText);
+      }
+
+      return await response.arrayBuffer();
+    },
+
+    async batch(statements: DBPreparedStatement[]): Promise<DBResult[]> {
+      const results: DBResult[] = [];
+      for (const stmt of statements) {
+        results.push(await stmt.run());
+      }
+      return results;
+    },
+
+    async exec(query: string): Promise<DBResult> {
+      const response = await fetch(serviceUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          bindingName,
+          method: "exec",
+          query,
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error("DB exec failed: " + response.statusText);
+      }
+
+      return await response.json();
+    },
+  };
+}
+`;
+    DB_RUNTIME_CODE_PRODUCTION = `export function initializeDB(databaseId, organizationId, serviceUrl) {
+	return {
+		prepare(query) {
+			let boundParams = [];
+			return {
+				bind(...values) {
+					boundParams = values;
+					return this;
+				},
+				async run() {
+					const response = await fetch(serviceUrl, {
+						method: "POST",
+						headers: { "Content-Type": "application/json" },
+						body: JSON.stringify({
+							databaseId,
+							organizationId,
+							method: "prepare",
+							query,
+							params: boundParams,
+						}),
+					});
+					if (!response.ok) {
+						const errorText = await response.text();
+						throw new Error(\`DB query failed: \${errorText}\`);
+					}
+					return await response.json();
+				},
+				async all() {
+					return await this.run();
+				},
+				async first(colName) {
+					const result = await this.run();
+					if (result.results.length === 0) {
+						return null;
+					}
+					const firstRow = result.results[0];
+					if (colName) {
+						return firstRow[colName] ?? null;
+					}
+					return firstRow;
+				},
+				async raw(options) {
+					const result = await this.run();
+					const rows = result.results;
+					if (rows.length === 0) {
+						return [];
+					}
+					const keys = Object.keys(rows[0]);
+					const arrayRows = rows.map((row) => keys.map((key) => row[key]));
+					if (options?.columnNames) {
+						return [keys, ...arrayRows];
+					}
+					return arrayRows;
+				},
+			};
+		},
+		async dump() {
+			const response = await fetch(serviceUrl, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					databaseId,
+					organizationId,
+					method: "dump",
+				}),
+			});
+			if (!response.ok) {
+				throw new Error(\`DB dump failed: \${response.statusText}\`);
+			}
+			return await response.arrayBuffer();
+		},
+		async batch(statements) {
+			const stmts = [];
+			for (const stmt of statements) {
+				const stmtData = stmt.__db_data;
+				if (stmtData) {
+					stmts.push(stmtData);
+				}
+			}
+			const response = await fetch(serviceUrl, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					databaseId,
+					organizationId,
+					method: "batch",
+					statements: stmts,
+				}),
+			});
+			if (!response.ok) {
+				throw new Error(\`DB batch failed: \${response.statusText}\`);
+			}
+			return await response.json();
+		},
+		async exec(query) {
+			const response = await fetch(serviceUrl, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					databaseId,
+					organizationId,
+					method: "exec",
+					query,
+				}),
+			});
+			if (!response.ok) {
+				throw new Error(\`DB exec failed: \${response.statusText}\`);
+			}
+			return await response.json();
+		},
+	};
+}`;
+  }
+});
+
+// ../shared/dist/error.js
+var init_error = __esm({
+  "../shared/dist/error.js"() {
+  }
+});
+
+// ../shared/dist/health-check.js
+var init_health_check = __esm({
+  "../shared/dist/health-check.js"() {
+  }
+});
+
+// ../shared/dist/trace-event.js
+var init_trace_event = __esm({
+  "../shared/dist/trace-event.js"() {
+  }
+});
+
+// ../shared/dist/url-validation.js
+var init_url_validation = __esm({
+  "../shared/dist/url-validation.js"() {
+  }
+});
+
+// ../shared/dist/index.js
+var init_dist = __esm({
+  "../shared/dist/index.js"() {
+    init_d1_runtime();
+    init_error();
+    init_health_check();
+    init_trace_event();
+    init_url_validation();
+  }
+});
+
+// ../emulator/dist/runtime/db-runtime.js
+var init_db_runtime = __esm({
+  "../emulator/dist/runtime/db-runtime.js"() {
+    init_dist();
+  }
+});
+
+// ../emulator/dist/runtime/queue-runtime.js
+var QUEUE_RUNTIME_CODE;
+var init_queue_runtime = __esm({
+  "../emulator/dist/runtime/queue-runtime.js"() {
+    QUEUE_RUNTIME_CODE = `
+interface QueueSendResult {
+  success: boolean;
+  messageId?: string;
+  error?: string;
+}
+
+interface QueueBatchSendResult {
+  success: boolean;
+  messageIds?: string[];
+  error?: string;
+}
+
+interface Queue<T = unknown> {
+  send: (payload: T, options?: { delaySeconds?: number }) => Promise<QueueSendResult>;
+  sendBatch: (messages: Array<{ payload: T; delaySeconds?: number }>) => Promise<QueueBatchSendResult>;
+}
+
+export function initializeQueue<T = unknown>(queueName: string, serviceUrl: string): Queue<T> {
+  return {
+    async send(payload: T, options?: { delaySeconds?: number }): Promise<QueueSendResult> {
+      const response = await fetch(serviceUrl + "/queue/send", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          queueName,
+          payload,
+          delaySeconds: options?.delaySeconds,
+        }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        return { success: false, error: "Queue send failed: " + errorText };
+      }
+
+      return await response.json();
+    },
+
+    async sendBatch(messages: Array<{ payload: T; delaySeconds?: number }>): Promise<QueueBatchSendResult> {
+      const response = await fetch(serviceUrl + "/queue/batch-send", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          queueName,
+          messages,
+        }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        return { success: false, error: "Queue batch send failed: " + errorText };
+      }
+
+      return await response.json();
+    },
+  };
+}
+`;
+  }
+});
+
+// ../emulator/dist/runtime/workflow-runtime.js
+var WORKFLOW_RUNTIME_CODE;
+var init_workflow_runtime = __esm({
+  "../emulator/dist/runtime/workflow-runtime.js"() {
+    WORKFLOW_RUNTIME_CODE = `
+interface WorkflowExecution {
+  id: string;
+  status: "pending" | "running" | "completed" | "failed" | "cancelled";
+  result?: unknown;
+  error?: string;
+}
+
+interface Workflow<TInput = unknown> {
+  trigger: (input: TInput) => Promise<{ executionId: string }>;
+  getExecution: (executionId: string) => Promise<WorkflowExecution>;
+  cancel: (executionId: string) => Promise<void>;
+}
+
+export function initializeWorkflow<TInput = unknown>(
+  workflowName: string,
+  serviceUrl: string
+): Workflow<TInput> {
+  return {
+    async trigger(input: TInput): Promise<{ executionId: string }> {
+      const response = await fetch(serviceUrl + "/workflow/trigger", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ workflowName, input }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("Workflow trigger failed: " + errorText);
+      }
+
+      const result = await response.json();
+      if (!result.success) {
+        throw new Error(result.error || "Workflow trigger failed");
+      }
+
+      return { executionId: result.executionId };
+    },
+
+    async getExecution(executionId: string): Promise<WorkflowExecution> {
+      const response = await fetch(serviceUrl + "/workflow/status", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ executionId }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("Workflow status failed: " + errorText);
+      }
+
+      const result = await response.json();
+      if (!result.success) {
+        throw new Error(result.error || "Workflow status failed");
+      }
+
+      const exec = result.execution;
+      return {
+        id: exec.id,
+        status: exec.status,
+        result: exec.output,
+        error: exec.error,
+      };
+    },
+
+    async cancel(executionId: string): Promise<void> {
+      const response = await fetch(serviceUrl + "/workflow/cancel", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ executionId }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error("Workflow cancel failed: " + errorText);
+      }
+
+      const result = await response.json();
+      if (!result.success) {
+        throw new Error(result.error || "Workflow cancel failed");
+      }
+    },
+  };
+}
+
+interface WorkflowStepContext {
+  run: <T>(stepName: string, fn: () => T | Promise<T>, options?: { retries?: number }) => Promise<T>;
+  sleep: (durationMs: number) => Promise<void>;
+}
+
+interface WorkflowContext<TInput = unknown, TEnv = unknown> {
+  input: TInput;
+  env: TEnv;
+  step: WorkflowStepContext;
+}
+
+export function createStepContext(executionId: string, serviceUrl: string): WorkflowStepContext {
+  let stepIndex = 0;
+
+  return {
+    async run<T>(stepName: string, fn: () => T | Promise<T>, options?: { retries?: number }): Promise<T> {
+      const currentStepIndex = stepIndex++;
+      const maxRetries = options?.retries ?? 0;
+
+      const startResponse = await fetch(serviceUrl + "/workflow/step/start", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ executionId, stepName, stepIndex: currentStepIndex }),
+      });
+
+      if (!startResponse.ok) {
+        const errorText = await startResponse.text();
+        throw new Error("Failed to start step: " + errorText);
+      }
+
+      const startResult = await startResponse.json();
+
+      if (startResult.alreadyCompleted) {
+        return startResult.output as T;
+      }
+
+      const startTime = Date.now();
+      let lastError: Error | null = null;
+
+      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+          const result = await fn();
+          const durationMs = Date.now() - startTime;
+
+          await fetch(serviceUrl + "/workflow/step/complete", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ executionId, stepName, output: result, durationMs }),
+          });
+
+          return result;
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          if (attempt < maxRetries) {
+            await new Promise((resolve) => setTimeout(resolve, Math.min(1000 * Math.pow(2, attempt), 30000)));
+          }
+        }
+      }
+
+      const durationMs = Date.now() - startTime;
+      await fetch(serviceUrl + "/workflow/step/fail", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ executionId, stepName, error: lastError?.message || "Step execution failed", durationMs }),
+      });
+
+      throw lastError;
+    },
+
+    async sleep(durationMs: number): Promise<void> {
+      const stepName = "__sleep_" + stepIndex++;
+
+      await fetch(serviceUrl + "/workflow/step/start", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ executionId, stepName, stepIndex: stepIndex - 1 }),
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, durationMs));
+
+      await fetch(serviceUrl + "/workflow/step/complete", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ executionId, stepName, output: { sleptMs: durationMs }, durationMs }),
+      });
+    },
+  };
+}
+
+export async function executeWorkflow<TInput, TOutput, TEnv>(
+  executionId: string,
+  workflowFn: (context: WorkflowContext<TInput, TEnv>) => Promise<TOutput>,
+  input: TInput,
+  env: TEnv,
+  serviceUrl: string
+): Promise<TOutput> {
+  const step = createStepContext(executionId, serviceUrl);
+  const context: WorkflowContext<TInput, TEnv> = { input, env, step };
+
+  try {
+    const output = await workflowFn(context);
+
+    await fetch(serviceUrl + "/workflow/complete", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ executionId, output }),
+    });
+
+    return output;
+  } catch (error) {
+    await fetch(serviceUrl + "/workflow/fail", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ executionId, error: error instanceof Error ? error.message : String(error) }),
+    });
+
+    throw error;
+  }
+}
+`;
+  }
+});
+function generateWrapperCode(config, mockServiceUrl) {
+  const imports = [];
+  const bindings = [];
+  if (config.db) {
+    imports.push('import { initializeDB } from "__ploy_db_runtime__";');
+    for (const [bindingName, dbName] of Object.entries(config.db)) {
+      bindings.push(`  ${bindingName}: initializeDB("${dbName}", "${mockServiceUrl}/db"),`);
+    }
+  }
+  if (config.queue) {
+    imports.push('import { initializeQueue } from "__ploy_queue_runtime__";');
+    for (const [bindingName, queueName] of Object.entries(config.queue)) {
+      bindings.push(`  ${bindingName}: initializeQueue("${queueName}", "${mockServiceUrl}"),`);
+    }
+  }
+  if (config.workflow) {
+    imports.push('import { initializeWorkflow, createStepContext, executeWorkflow } from "__ploy_workflow_runtime__";');
+    for (const [bindingName, workflowName] of Object.entries(config.workflow)) {
+      bindings.push(`  ${bindingName}: initializeWorkflow("${workflowName}", "${mockServiceUrl}"),`);
+    }
+  }
+  imports.push('import userWorker from "__ploy_user_worker__";');
+  const workflowHandlerCode = config.workflow ? `
+  // Handle workflow execution requests
+  if (request.headers.get("X-Ploy-Workflow-Execution") === "true") {
+    const workflowName = request.headers.get("X-Ploy-Workflow-Name");
+    const executionId = request.headers.get("X-Ploy-Execution-Id");
+
+    if (workflowName && executionId && userWorker.workflows && userWorker.workflows[workflowName]) {
+      const input = await request.json();
+      try {
+        await executeWorkflow(
+          executionId,
+          userWorker.workflows[workflowName],
+          input,
+          injectedEnv,
+          "${mockServiceUrl}"
+        );
+        return new Response(JSON.stringify({ success: true }), {
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (error) {
+        return new Response(JSON.stringify({ success: false, error: String(error) }), {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+  }` : "";
+  const queueHandlerCode = config.queue ? `
+  // Handle queue message delivery
+  if (request.headers.get("X-Ploy-Queue-Delivery") === "true") {
+    const queueName = request.headers.get("X-Ploy-Queue-Name");
+    const messageId = request.headers.get("X-Ploy-Message-Id");
+    const deliveryId = request.headers.get("X-Ploy-Delivery-Id");
+    const attempt = parseInt(request.headers.get("X-Ploy-Message-Attempt") || "1", 10);
+
+    if (queueName && messageId && userWorker.message) {
+      const payload = await request.json();
+      try {
+        await userWorker.message({
+          id: messageId,
+          queueName,
+          payload,
+          attempt,
+          timestamp: Date.now()
+        }, injectedEnv, ctx);
+        return new Response(JSON.stringify({ success: true }), {
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (error) {
+        return new Response(JSON.stringify({ success: false, error: String(error) }), {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+  }` : "";
+  return `${imports.join("\n")}
+
+const ployBindings = {
+${bindings.join("\n")}
+};
+
+export default {
+  async fetch(request, env, ctx) {
+    const injectedEnv = { ...env, ...ployBindings };
+    ${workflowHandlerCode}
+    ${queueHandlerCode}
+
+    if (userWorker.fetch) {
+      return userWorker.fetch(request, injectedEnv, ctx);
+    }
+
+    return new Response("Worker has no fetch handler", { status: 500 });
+  },
+
+  async scheduled(event, env, ctx) {
+    if (userWorker.scheduled) {
+      const injectedEnv = { ...env, ...ployBindings };
+      return userWorker.scheduled(event, injectedEnv, ctx);
+    }
+  }
+};
+`;
+}
+function createRuntimePlugin(_config) {
+  return {
+    name: "ploy-runtime",
+    setup(build2) {
+      build2.onResolve({ filter: /^__ploy_db_runtime__$/ }, () => ({
+        path: "__ploy_db_runtime__",
+        namespace: "ploy-runtime"
+      }));
+      build2.onResolve({ filter: /^__ploy_queue_runtime__$/ }, () => ({
+        path: "__ploy_queue_runtime__",
+        namespace: "ploy-runtime"
+      }));
+      build2.onResolve({ filter: /^__ploy_workflow_runtime__$/ }, () => ({
+        path: "__ploy_workflow_runtime__",
+        namespace: "ploy-runtime"
+      }));
+      build2.onLoad({ filter: /^__ploy_db_runtime__$/, namespace: "ploy-runtime" }, () => ({
+        contents: DB_RUNTIME_CODE,
+        loader: "ts"
+      }));
+      build2.onLoad({ filter: /^__ploy_queue_runtime__$/, namespace: "ploy-runtime" }, () => ({
+        contents: QUEUE_RUNTIME_CODE,
+        loader: "ts"
+      }));
+      build2.onLoad({ filter: /^__ploy_workflow_runtime__$/, namespace: "ploy-runtime" }, () => ({
+        contents: WORKFLOW_RUNTIME_CODE,
+        loader: "ts"
+      }));
+    }
+  };
 }
-function parseDevArgs(args) {
-    const options = {
-        port: undefined,
-        host: undefined,
-        config: undefined,
-        watch: true,
-        verbose: false,
+async function bundleWorker(options) {
+  const { projectDir, tempDir, entryPoint, config, mockServiceUrl } = options;
+  const wrapperCode = generateWrapperCode(config, mockServiceUrl);
+  const wrapperPath = join(tempDir, "wrapper.ts");
+  writeFileSync(wrapperPath, wrapperCode);
+  const bundlePath = join(tempDir, "worker.bundle.js");
+  const buildOptions = {
+    entryPoints: [wrapperPath],
+    bundle: true,
+    format: "esm",
+    platform: "neutral",
+    target: "es2022",
+    outfile: bundlePath,
+    minify: false,
+    sourcemap: false,
+    external: ["cloudflare:*"],
+    alias: {
+      __ploy_user_worker__: entryPoint
+    },
+    plugins: [createRuntimePlugin()],
+    absWorkingDir: projectDir,
+    logLevel: "warning"
+  };
+  await build(buildOptions);
+  return bundlePath;
+}
+var init_bundler = __esm({
+  "../emulator/dist/bundler/bundler.js"() {
+    init_db_runtime();
+    init_queue_runtime();
+    init_workflow_runtime();
+  }
+});
+function createFileWatcher(srcDir, onRebuild) {
+  let watcher = null;
+  let debounceTimer = null;
+  let isRebuilding = false;
+  function shouldRebuild(filePath) {
+    const extensions = [".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs"];
+    return extensions.some((ext) => filePath.endsWith(ext));
+  }
+  function scheduleRebuild() {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(async () => {
+      if (isRebuilding) {
+        return;
+      }
+      isRebuilding = true;
+      try {
+        await onRebuild();
+      } finally {
+        isRebuilding = false;
+      }
+    }, 100);
+  }
+  return {
+    start() {
+      if (watcher) {
+        return;
+      }
+      watcher = watch(srcDir, {
+        persistent: true,
+        ignoreInitial: true,
+        ignored: ["**/node_modules/**", "**/dist/**", "**/.ploy/**", "**/.*"]
+      });
+      watcher.on("change", (filePath) => {
+        if (shouldRebuild(filePath)) {
+          scheduleRebuild();
+        }
+      });
+      watcher.on("add", (filePath) => {
+        if (shouldRebuild(filePath)) {
+          scheduleRebuild();
+        }
+      });
+      watcher.on("unlink", (filePath) => {
+        if (shouldRebuild(filePath)) {
+          scheduleRebuild();
+        }
+      });
+    },
+    stop() {
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+      if (watcher) {
+        watcher.close();
+        watcher = null;
+      }
+    }
+  };
+}
+var init_watcher = __esm({
+  "../emulator/dist/bundler/watcher.js"() {
+  }
+});
+
+// ../emulator/dist/config/ploy-config.js
+function readPloyConfig2(projectDir, configPath) {
+  const config = readPloyConfigSync(projectDir, configPath);
+  if (!config.kind) {
+    throw new Error(`Missing required field 'kind' in ${configPath || "ploy.yaml"}`);
+  }
+  if (config.kind !== "dynamic" && config.kind !== "worker") {
+    throw new Error(`Invalid kind '${config.kind}' in ${configPath || "ploy.yaml"}. Must be 'dynamic' or 'worker'`);
+  }
+  return config;
+}
+function getWorkerEntryPoint2(projectDir, config) {
+  return getWorkerEntryPoint(projectDir, config);
+}
+var init_ploy_config2 = __esm({
+  "../emulator/dist/config/ploy-config.js"() {
+    init_cli();
+  }
+});
+function generateWorkerdConfig(options) {
+  const { port, mockServicePort } = options;
+  const services = [
+    '(name = "main", worker = .worker)',
+    `(name = "mock", external = (address = "localhost:${mockServicePort}", http = ()))`,
+    '(name = "internet", network = (allow = ["public", "private", "local"], tlsOptions = (trustBrowserCas = true)))'
+  ];
+  const bindings = [
+    '(name = "mock", service = "mock")',
+    '(name = "internet", service = "internet")'
+  ];
+  const configContent = `using Workerd = import "/workerd/workerd.capnp";
+
+const config :Workerd.Config = (
+  services = [
+    ${services.join(",\n    ")}
+  ],
+  sockets = [
+    (name = "http", address = "*:${port}", http = (), service = "main")
+  ]
+);
+
+const worker :Workerd.Worker = (
+  modules = [
+    (name = "worker.js", esModule = embed "worker.bundle.js")
+  ],
+  compatibilityDate = "2025-09-15",
+  compatibilityFlags = [
+    "experimental",
+    "nodejs_compat",
+    "nodejs_als"
+  ],
+  globalOutbound = "internet",
+  bindings = [
+    ${bindings.join(",\n    ")}
+  ]
+);
+`;
+  return configContent;
+}
+function writeWorkerdConfig(options) {
+  const configContent = generateWorkerdConfig(options);
+  const configPath = join(options.tempDir, "workerd.capnp");
+  writeFileSync(configPath, configContent);
+  return configPath;
+}
+var init_workerd_config = __esm({
+  "../emulator/dist/config/workerd-config.js"() {
+  }
+});
+function findDashboardDistPath() {
+  const possiblePaths = [
+    join(__dirname, "..", "dashboard-dist"),
+    join(__dirname, "..", "..", "src", "dashboard-dist")
+  ];
+  for (const p of possiblePaths) {
+    if (existsSync(p)) {
+      return p;
+    }
+  }
+  return null;
+}
+function getMimeType(filePath) {
+  const ext = filePath.substring(filePath.lastIndexOf("."));
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+function createDashboardRoutes(app, dbManager2, config) {
+  const dashboardDistPath = findDashboardDistPath();
+  const hasDashboard = dashboardDistPath !== null;
+  function getDbResourceName(bindingName) {
+    return config.db?.[bindingName] ?? null;
+  }
+  app.get("/api/config", (c) => {
+    return c.json({
+      db: config.db,
+      queue: config.queue,
+      workflow: config.workflow
+    });
+  });
+  app.post("/api/db/:binding/query", async (c) => {
+    const binding = c.req.param("binding");
+    const resourceName = getDbResourceName(binding);
+    if (!resourceName) {
+      return c.json({ error: `Database binding '${binding}' not found` }, 404);
+    }
+    const body = await c.req.json();
+    const { query } = body;
+    if (!query) {
+      return c.json({ error: "Query is required" }, 400);
+    }
+    try {
+      const db = dbManager2.getD1Database(resourceName);
+      const startTime = Date.now();
+      const stmt = db.prepare(query);
+      const isSelect = query.trim().toUpperCase().startsWith("SELECT");
+      let results = [];
+      let changes = 0;
+      if (isSelect) {
+        results = stmt.all();
+      } else {
+        const info = stmt.run();
+        changes = info.changes;
+      }
+      const duration = Date.now() - startTime;
+      return c.json({
+        results,
+        success: true,
+        meta: {
+          duration,
+          rows_read: results.length,
+          rows_written: changes
+        }
+      });
+    } catch (err) {
+      return c.json({
+        results: [],
+        success: false,
+        error: err instanceof Error ? err.message : String(err),
+        meta: { duration: 0, rows_read: 0, rows_written: 0 }
+      }, 400);
+    }
+  });
+  app.get("/api/db/:binding/tables", (c) => {
+    const binding = c.req.param("binding");
+    const resourceName = getDbResourceName(binding);
+    if (!resourceName) {
+      return c.json({ error: `Database binding '${binding}' not found` }, 404);
+    }
+    try {
+      const db = dbManager2.getD1Database(resourceName);
+      const tables = db.prepare(`SELECT name FROM sqlite_master
+					 WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '_litestream_%'
+					 ORDER BY name`).all();
+      return c.json({ tables });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.get("/api/db/:binding/tables/:tableName", (c) => {
+    const binding = c.req.param("binding");
+    const resourceName = getDbResourceName(binding);
+    if (!resourceName) {
+      return c.json({ error: `Database binding '${binding}' not found` }, 404);
+    }
+    const tableName = c.req.param("tableName");
+    const limit = parseInt(c.req.query("limit") || "50", 10);
+    const offset = parseInt(c.req.query("offset") || "0", 10);
+    try {
+      const db = dbManager2.getD1Database(resourceName);
+      const columnsResult = db.prepare(`PRAGMA table_info("${tableName}")`).all();
+      const columns = columnsResult.map((col) => col.name);
+      const countResult = db.prepare(`SELECT COUNT(*) as count FROM "${tableName}"`).get();
+      const total = countResult.count;
+      const data = db.prepare(`SELECT * FROM "${tableName}" LIMIT ? OFFSET ?`).all(limit, offset);
+      return c.json({ data, columns, total });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.get("/api/db/:binding/schema", (c) => {
+    const binding = c.req.param("binding");
+    const resourceName = getDbResourceName(binding);
+    if (!resourceName) {
+      return c.json({ error: `Database binding '${binding}' not found` }, 404);
+    }
+    try {
+      const db = dbManager2.getD1Database(resourceName);
+      const tablesResult = db.prepare(`SELECT name FROM sqlite_master
+					 WHERE type='table' AND name NOT LIKE 'sqlite_%'
+					 ORDER BY name`).all();
+      const tables = tablesResult.map((table) => {
+        const columnsResult = db.prepare(`PRAGMA table_info("${table.name}")`).all();
+        return {
+          name: table.name,
+          columns: columnsResult.map((col) => ({
+            name: col.name,
+            type: col.type,
+            notNull: col.notnull === 1,
+            primaryKey: col.pk === 1
+          }))
+        };
+      });
+      return c.json({ tables });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.get("/api/queue/:binding/metrics", (c) => {
+    const binding = c.req.param("binding");
+    const queueName = config.queue?.[binding];
+    if (!queueName) {
+      return c.json({ error: "Queue not found" }, 404);
+    }
+    try {
+      const db = dbManager2.emulatorDb;
+      const metrics = {
+        pending: 0,
+        processing: 0,
+        acknowledged: 0,
+        failed: 0,
+        deadLetter: 0
+      };
+      const statusCounts = db.prepare(`SELECT status, COUNT(*) as count
+					 FROM queue_messages
+					 WHERE queue_name = ?
+					 GROUP BY status`).all(queueName);
+      for (const row of statusCounts) {
+        if (row.status === "pending") {
+          metrics.pending = row.count;
+        } else if (row.status === "processing") {
+          metrics.processing = row.count;
+        } else if (row.status === "acknowledged") {
+          metrics.acknowledged = row.count;
+        } else if (row.status === "failed") {
+          metrics.failed = row.count;
+        } else if (row.status === "dead_letter") {
+          metrics.deadLetter = row.count;
+        }
+      }
+      return c.json({ metrics });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.get("/api/queue/:binding/messages", (c) => {
+    const binding = c.req.param("binding");
+    const queueName = config.queue?.[binding];
+    const limit = parseInt(c.req.query("limit") || "10", 10);
+    if (!queueName) {
+      return c.json({ error: "Queue not found" }, 404);
+    }
+    try {
+      const db = dbManager2.emulatorDb;
+      const messages = db.prepare(`SELECT id, status, payload, attempt, created_at
+					 FROM queue_messages
+					 WHERE queue_name = ?
+					 ORDER BY created_at DESC
+					 LIMIT ?`).all(queueName, limit);
+      return c.json({
+        messages: messages.map((m) => ({
+          id: m.id,
+          status: m.status.toUpperCase(),
+          payload: JSON.parse(m.payload),
+          attempt: m.attempt,
+          createdAt: new Date(m.created_at * 1e3).toISOString()
+        }))
+      });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.get("/api/workflow/:binding/executions", (c) => {
+    const binding = c.req.param("binding");
+    const workflowConfig = config.workflow?.[binding];
+    const limit = parseInt(c.req.query("limit") || "20", 10);
+    if (!workflowConfig) {
+      return c.json({ error: "Workflow not found" }, 404);
+    }
+    try {
+      const db = dbManager2.emulatorDb;
+      const workflowName = workflowConfig;
+      const executions = db.prepare(`SELECT
+						e.id,
+						e.workflow_name,
+						e.status,
+						e.error,
+						e.started_at,
+						e.completed_at,
+						e.created_at,
+						(SELECT COUNT(*) FROM workflow_steps WHERE execution_id = e.id) as steps_count,
+						(SELECT COUNT(*) FROM workflow_steps WHERE execution_id = e.id AND status = 'completed') as steps_completed
+					 FROM workflow_executions e
+					 WHERE e.workflow_name = ?
+					 ORDER BY e.created_at DESC
+					 LIMIT ?`).all(workflowName, limit);
+      return c.json({
+        executions: executions.map((e) => ({
+          id: e.id,
+          status: e.status.toUpperCase(),
+          startedAt: e.started_at ? new Date(e.started_at * 1e3).toISOString() : null,
+          completedAt: e.completed_at ? new Date(e.completed_at * 1e3).toISOString() : null,
+          durationMs: e.started_at && e.completed_at ? (e.completed_at - e.started_at) * 1e3 : null,
+          stepsCount: e.steps_count,
+          stepsCompleted: e.steps_completed,
+          errorMessage: e.error,
+          createdAt: new Date(e.created_at * 1e3).toISOString()
+        }))
+      });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.get("/api/workflow/:binding/executions/:executionId", (c) => {
+    const binding = c.req.param("binding");
+    const executionId = c.req.param("executionId");
+    const workflowConfig = config.workflow?.[binding];
+    if (!workflowConfig) {
+      return c.json({ error: "Workflow not found" }, 404);
+    }
+    try {
+      const db = dbManager2.emulatorDb;
+      const execution = db.prepare(`SELECT id, workflow_name, status, error, started_at, completed_at, created_at
+					 FROM workflow_executions
+					 WHERE id = ?`).get(executionId);
+      if (!execution) {
+        return c.json({ error: "Execution not found" }, 404);
+      }
+      const steps = db.prepare(`SELECT id, step_name, step_index, status, output, error, duration_ms, created_at
+					 FROM workflow_steps
+					 WHERE execution_id = ?
+					 ORDER BY step_index`).all(executionId);
+      return c.json({
+        execution: {
+          id: execution.id,
+          status: execution.status.toUpperCase(),
+          startedAt: execution.started_at ? new Date(execution.started_at * 1e3).toISOString() : null,
+          completedAt: execution.completed_at ? new Date(execution.completed_at * 1e3).toISOString() : null,
+          durationMs: execution.started_at && execution.completed_at ? (execution.completed_at - execution.started_at) * 1e3 : null,
+          stepsCount: steps.length,
+          stepsCompleted: steps.filter((s) => s.status === "completed").length,
+          errorMessage: execution.error,
+          createdAt: new Date(execution.created_at * 1e3).toISOString()
+        },
+        steps: steps.map((s) => ({
+          id: String(s.id),
+          stepName: s.step_name,
+          stepIndex: s.step_index,
+          status: s.status.toUpperCase(),
+          output: s.output ? JSON.parse(s.output) : null,
+          errorMessage: s.error,
+          durationMs: s.duration_ms,
+          createdAt: new Date(s.created_at * 1e3).toISOString()
+        }))
+      });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  if (hasDashboard) {
+    app.get("/assets/*", (c) => {
+      const path = c.req.path;
+      const filePath = join(dashboardDistPath, path);
+      if (!existsSync(filePath)) {
+        return c.notFound();
+      }
+      const content = readFileSync(filePath);
+      const mimeType = getMimeType(filePath);
+      return new Response(content, {
+        headers: {
+          "Content-Type": mimeType,
+          "Cache-Control": "public, max-age=31536000"
+        }
+      });
+    });
+    app.get("*", (c) => {
+      if (c.req.path.startsWith("/api/") || c.req.path.startsWith("/db") || c.req.path.startsWith("/queue") || c.req.path.startsWith("/workflow")) {
+        return c.notFound();
+      }
+      const indexPath = join(dashboardDistPath, "index.html");
+      if (!existsSync(indexPath)) {
+        return c.text("Dashboard not found. Run 'pnpm build' in packages/dev-dashboard.", 404);
+      }
+      const content = readFileSync(indexPath, "utf-8");
+      return c.html(content);
+    });
+  }
+}
+var __filename, __dirname, MIME_TYPES;
+var init_dashboard_routes = __esm({
+  "../emulator/dist/services/dashboard-routes.js"() {
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = dirname(__filename);
+    MIME_TYPES = {
+      ".html": "text/html",
+      ".js": "application/javascript",
+      ".css": "text/css",
+      ".json": "application/json",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".svg": "image/svg+xml",
+      ".ico": "image/x-icon",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2"
     };
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === "-p" || arg === "--port") {
-            const value = args[++i];
-            if (value) {
-                options.port = parseInt(value, 10);
+  }
+});
+
+// ../emulator/dist/services/db-service.js
+function createDbHandler(getDatabase) {
+  return async (c) => {
+    const startTime = Date.now();
+    try {
+      const body = await c.req.json();
+      const { bindingName, method, query, params, statements } = body;
+      const db = getDatabase(bindingName);
+      if (method === "prepare" && query) {
+        const stmt = db.prepare(query);
+        const isSelect = query.trim().toUpperCase().startsWith("SELECT");
+        let results;
+        let changes = 0;
+        if (isSelect) {
+          results = params?.length ? stmt.all(...params) : stmt.all();
+        } else {
+          const info = params?.length ? stmt.run(...params) : stmt.run();
+          changes = info.changes;
+          results = [];
+        }
+        const duration = Date.now() - startTime;
+        return c.json({
+          results,
+          success: true,
+          meta: {
+            duration,
+            rows_read: results.length,
+            rows_written: changes
+          }
+        });
+      }
+      if (method === "exec" && query) {
+        db.exec(query);
+        const duration = Date.now() - startTime;
+        return c.json({
+          results: [],
+          success: true,
+          meta: {
+            duration,
+            rows_read: 0,
+            rows_written: 0
+          }
+        });
+      }
+      if (method === "batch" && statements) {
+        const results = [];
+        const transaction = db.transaction(() => {
+          for (const stmt of statements) {
+            const prepared = db.prepare(stmt.query);
+            const isSelect = stmt.query.trim().toUpperCase().startsWith("SELECT");
+            if (isSelect) {
+              const rows = stmt.params?.length ? prepared.all(...stmt.params) : prepared.all();
+              results.push({
+                results: rows,
+                success: true,
+                meta: {
+                  duration: 0,
+                  rows_read: rows.length,
+                  rows_written: 0
+                }
+              });
+            } else {
+              const info = stmt.params?.length ? prepared.run(...stmt.params) : prepared.run();
+              results.push({
+                results: [],
+                success: true,
+                meta: {
+                  duration: 0,
+                  rows_read: 0,
+                  rows_written: info.changes
+                }
+              });
             }
+          }
+        });
+        transaction();
+        return c.json(results);
+      }
+      if (method === "dump") {
+        const buffer = db.serialize();
+        return new Response(new Uint8Array(buffer), {
+          headers: {
+            "Content-Type": "application/octet-stream"
+          }
+        });
+      }
+      return c.json({ error: "Invalid method" }, 400);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ error: message }, 500);
+    }
+  };
+}
+var init_db_service = __esm({
+  "../emulator/dist/services/db-service.js"() {
+  }
+});
+function createQueueHandlers(db) {
+  const sendHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { queueName, payload, delaySeconds = 0 } = body;
+      const id = randomUUID();
+      const now = Math.floor(Date.now() / 1e3);
+      const visibleAt = now + delaySeconds;
+      db.prepare(`INSERT INTO queue_messages (id, queue_name, payload, visible_at)
+				 VALUES (?, ?, ?, ?)`).run(id, queueName, JSON.stringify(payload), visibleAt);
+      return c.json({ success: true, messageId: id });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const batchSendHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { queueName, messages } = body;
+      const now = Math.floor(Date.now() / 1e3);
+      const messageIds = [];
+      const insert = db.prepare(`INSERT INTO queue_messages (id, queue_name, payload, visible_at)
+				 VALUES (?, ?, ?, ?)`);
+      const transaction = db.transaction(() => {
+        for (const msg of messages) {
+          const id = randomUUID();
+          const visibleAt = now + (msg.delaySeconds || 0);
+          insert.run(id, queueName, JSON.stringify(msg.payload), visibleAt);
+          messageIds.push(id);
         }
-        else if (arg === "-h" || arg === "--host") {
-            options.host = args[++i];
+      });
+      transaction();
+      return c.json({ success: true, messageIds });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const receiveHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { queueName, maxMessages = 10, visibilityTimeoutSeconds = 30 } = body;
+      const now = Math.floor(Date.now() / 1e3);
+      const deliveryId = randomUUID();
+      const newVisibleAt = now + visibilityTimeoutSeconds;
+      const rows = db.prepare(`SELECT id, queue_name, payload, attempt
+					 FROM queue_messages
+					 WHERE queue_name = ? AND status = 'pending' AND visible_at <= ?
+					 ORDER BY visible_at ASC
+					 LIMIT ?`).all(queueName, now, maxMessages);
+      if (rows.length === 0) {
+        return c.json({ success: true, messages: [] });
+      }
+      const ids = rows.map((r) => r.id);
+      const placeholders = ids.map(() => "?").join(",");
+      db.prepare(`UPDATE queue_messages
+				 SET status = 'processing', delivery_id = ?, visible_at = ?, attempt = attempt + 1, updated_at = ?
+				 WHERE id IN (${placeholders})`).run(deliveryId, newVisibleAt, now, ...ids);
+      const messages = rows.map((row) => ({
+        id: row.id,
+        payload: JSON.parse(row.payload),
+        attempt: row.attempt + 1,
+        deliveryId
+      }));
+      return c.json({ success: true, messages });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, messages: [], error: message }, 500);
+    }
+  };
+  const ackHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { messageId, deliveryId } = body;
+      const result = db.prepare(`DELETE FROM queue_messages
+					 WHERE id = ? AND delivery_id = ?`).run(messageId, deliveryId);
+      if (result.changes === 0) {
+        return c.json({ success: false, error: "Message not found or already processed" }, 404);
+      }
+      return c.json({ success: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const retryHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { messageId, deliveryId } = body;
+      const now = Math.floor(Date.now() / 1e3);
+      const backoffSeconds = 5;
+      const result = db.prepare(`UPDATE queue_messages
+					 SET status = 'pending', delivery_id = NULL, visible_at = ?, updated_at = ?
+					 WHERE id = ? AND delivery_id = ?`).run(now + backoffSeconds, now, messageId, deliveryId);
+      if (result.changes === 0) {
+        return c.json({ success: false, error: "Message not found or already processed" }, 404);
+      }
+      return c.json({ success: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  return {
+    sendHandler,
+    batchSendHandler,
+    receiveHandler,
+    ackHandler,
+    retryHandler
+  };
+}
+function createQueueProcessor(db, queueBindings, workerUrl) {
+  let interval = null;
+  async function processQueues() {
+    for (const [bindingName, queueName] of Object.entries(queueBindings)) {
+      await processQueue(bindingName, queueName);
+    }
+  }
+  async function processQueue(bindingName, queueName) {
+    const now = Math.floor(Date.now() / 1e3);
+    const deliveryId = randomUUID();
+    const visibilityTimeout = 30;
+    const rows = db.prepare(`SELECT id, payload, attempt
+				 FROM queue_messages
+				 WHERE queue_name = ? AND status = 'pending' AND visible_at <= ?
+				 LIMIT 10`).all(queueName, now);
+    if (rows.length === 0) {
+      return;
+    }
+    const ids = rows.map((r) => r.id);
+    const placeholders = ids.map(() => "?").join(",");
+    db.prepare(`UPDATE queue_messages
+			 SET status = 'processing', delivery_id = ?, visible_at = ?, attempt = attempt + 1, updated_at = ?
+			 WHERE id IN (${placeholders})`).run(deliveryId, now + visibilityTimeout, now, ...ids);
+    for (const row of rows) {
+      try {
+        const response = await fetch(workerUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-Ploy-Queue-Delivery": "true",
+            "X-Ploy-Queue-Name": queueName,
+            "X-Ploy-Queue-Binding": bindingName,
+            "X-Ploy-Message-Id": row.id,
+            "X-Ploy-Delivery-Id": deliveryId,
+            "X-Ploy-Message-Attempt": String(row.attempt + 1)
+          },
+          body: row.payload
+        });
+        if (response.ok) {
+          db.prepare(`DELETE FROM queue_messages WHERE id = ?`).run(row.id);
+        } else {
+          db.prepare(`UPDATE queue_messages
+						 SET status = 'pending', delivery_id = NULL, visible_at = ?, updated_at = ?
+						 WHERE id = ?`).run(now + 5, now, row.id);
+        }
+      } catch {
+        db.prepare(`UPDATE queue_messages
+					 SET status = 'pending', delivery_id = NULL, visible_at = ?, updated_at = ?
+					 WHERE id = ?`).run(now + 5, now, row.id);
+      }
+    }
+  }
+  return {
+    start() {
+      if (interval) {
+        return;
+      }
+      interval = setInterval(() => {
+        processQueues().catch(() => {
+        });
+      }, 1e3);
+    },
+    stop() {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+    }
+  };
+}
+var init_queue_service = __esm({
+  "../emulator/dist/services/queue-service.js"() {
+  }
+});
+function createWorkflowHandlers(db, workerUrl) {
+  const triggerHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { workflowName, input } = body;
+      const id = randomUUID();
+      const now = Math.floor(Date.now() / 1e3);
+      db.prepare(`INSERT INTO workflow_executions (id, workflow_name, status, input, started_at, created_at)
+				 VALUES (?, ?, 'running', ?, ?, ?)`).run(id, workflowName, JSON.stringify(input), now, now);
+      if (workerUrl) {
+        fetch(workerUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-Ploy-Workflow-Execution": "true",
+            "X-Ploy-Workflow-Name": workflowName,
+            "X-Ploy-Execution-Id": id
+          },
+          body: JSON.stringify(input)
+        }).catch(() => {
+        });
+      }
+      return c.json({ success: true, executionId: id });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const statusHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { executionId } = body;
+      const execution = db.prepare(`SELECT id, workflow_name, status, input, output, error, started_at, completed_at, created_at
+					 FROM workflow_executions WHERE id = ?`).get(executionId);
+      if (!execution) {
+        return c.json({ success: false, error: "Execution not found" }, 404);
+      }
+      const steps = db.prepare(`SELECT step_name, step_index, status, output, error, duration_ms
+					 FROM workflow_steps WHERE execution_id = ? ORDER BY step_index`).all(executionId);
+      return c.json({
+        success: true,
+        execution: {
+          id: execution.id,
+          workflowName: execution.workflow_name,
+          status: execution.status,
+          input: execution.input ? JSON.parse(execution.input) : null,
+          output: execution.output ? JSON.parse(execution.output) : null,
+          error: execution.error,
+          startedAt: execution.started_at ? new Date(execution.started_at * 1e3).toISOString() : null,
+          completedAt: execution.completed_at ? new Date(execution.completed_at * 1e3).toISOString() : null,
+          steps: steps.map((s) => ({
+            stepName: s.step_name,
+            stepIndex: s.step_index,
+            status: s.status,
+            output: s.output ? JSON.parse(s.output) : null,
+            error: s.error,
+            durationMs: s.duration_ms
+          }))
+        }
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const cancelHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { executionId } = body;
+      const now = Math.floor(Date.now() / 1e3);
+      const result = db.prepare(`UPDATE workflow_executions
+					 SET status = 'cancelled', completed_at = ?
+					 WHERE id = ? AND status IN ('pending', 'running')`).run(now, executionId);
+      if (result.changes === 0) {
+        return c.json({ success: false, error: "Execution not found or already completed" }, 404);
+      }
+      return c.json({ success: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const stepStartHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { executionId, stepName, stepIndex } = body;
+      const existing = db.prepare(`SELECT status, output FROM workflow_steps
+					 WHERE execution_id = ? AND step_name = ? AND step_index = ?`).get(executionId, stepName, stepIndex);
+      if (existing && existing.status === "completed") {
+        return c.json({
+          success: true,
+          alreadyCompleted: true,
+          output: existing.output ? JSON.parse(existing.output) : null
+        });
+      }
+      const now = Math.floor(Date.now() / 1e3);
+      if (existing) {
+        db.prepare(`UPDATE workflow_steps SET status = 'running' WHERE execution_id = ? AND step_name = ?`).run(executionId, stepName);
+      } else {
+        db.prepare(`INSERT INTO workflow_steps (execution_id, step_name, step_index, status, created_at)
+					 VALUES (?, ?, ?, 'running', ?)`).run(executionId, stepName, stepIndex, now);
+      }
+      return c.json({ success: true, alreadyCompleted: false });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const stepCompleteHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { executionId, stepName, output, durationMs } = body;
+      db.prepare(`UPDATE workflow_steps
+				 SET status = 'completed', output = ?, duration_ms = ?
+				 WHERE execution_id = ? AND step_name = ?`).run(JSON.stringify(output), durationMs, executionId, stepName);
+      return c.json({ success: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const stepFailHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { executionId, stepName, error: error2, durationMs } = body;
+      db.prepare(`UPDATE workflow_steps
+				 SET status = 'failed', error = ?, duration_ms = ?
+				 WHERE execution_id = ? AND step_name = ?`).run(error2, durationMs, executionId, stepName);
+      return c.json({ success: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const completeHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { executionId, output } = body;
+      const now = Math.floor(Date.now() / 1e3);
+      db.prepare(`UPDATE workflow_executions
+				 SET status = 'completed', output = ?, completed_at = ?
+				 WHERE id = ?`).run(JSON.stringify(output), now, executionId);
+      return c.json({ success: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  const failHandler = async (c) => {
+    try {
+      const body = await c.req.json();
+      const { executionId, error: error2 } = body;
+      const now = Math.floor(Date.now() / 1e3);
+      db.prepare(`UPDATE workflow_executions
+				 SET status = 'failed', error = ?, completed_at = ?
+				 WHERE id = ?`).run(error2, now, executionId);
+      return c.json({ success: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ success: false, error: message }, 500);
+    }
+  };
+  return {
+    triggerHandler,
+    statusHandler,
+    cancelHandler,
+    stepStartHandler,
+    stepCompleteHandler,
+    stepFailHandler,
+    completeHandler,
+    failHandler
+  };
+}
+var init_workflow_service = __esm({
+  "../emulator/dist/services/workflow-service.js"() {
+  }
+});
+async function startMockServer(dbManager2, config, options = {}) {
+  const app = new Hono();
+  if (config.db) {
+    const dbHandler = createDbHandler(dbManager2.getD1Database);
+    app.post("/db", dbHandler);
+  }
+  if (config.queue) {
+    const queueHandlers = createQueueHandlers(dbManager2.emulatorDb);
+    app.post("/queue/send", queueHandlers.sendHandler);
+    app.post("/queue/batch-send", queueHandlers.batchSendHandler);
+    app.post("/queue/receive", queueHandlers.receiveHandler);
+    app.post("/queue/ack", queueHandlers.ackHandler);
+    app.post("/queue/retry", queueHandlers.retryHandler);
+  }
+  if (config.workflow) {
+    const workflowHandlers = createWorkflowHandlers(dbManager2.emulatorDb, options.workerUrl);
+    app.post("/workflow/trigger", workflowHandlers.triggerHandler);
+    app.post("/workflow/status", workflowHandlers.statusHandler);
+    app.post("/workflow/cancel", workflowHandlers.cancelHandler);
+    app.post("/workflow/step/start", workflowHandlers.stepStartHandler);
+    app.post("/workflow/step/complete", workflowHandlers.stepCompleteHandler);
+    app.post("/workflow/step/fail", workflowHandlers.stepFailHandler);
+    app.post("/workflow/complete", workflowHandlers.completeHandler);
+    app.post("/workflow/fail", workflowHandlers.failHandler);
+  }
+  app.get("/health", (c) => c.json({ status: "ok" }));
+  if (options.dashboardEnabled !== false) {
+    createDashboardRoutes(app, dbManager2, config);
+  }
+  const serverPort = options.port ?? DEFAULT_MOCK_SERVER_PORT;
+  return await new Promise((resolve) => {
+    const server = serve({
+      fetch: app.fetch,
+      port: serverPort
+    }, (info) => {
+      resolve({
+        port: info.port,
+        close: () => new Promise((res) => {
+          server.close(() => res());
+        })
+      });
+    });
+  });
+}
+var DEFAULT_MOCK_SERVER_PORT;
+var init_mock_server = __esm({
+  "../emulator/dist/services/mock-server.js"() {
+    init_dashboard_routes();
+    init_db_service();
+    init_queue_service();
+    init_workflow_service();
+    DEFAULT_MOCK_SERVER_PORT = 4003;
+  }
+});
+
+// ../emulator/dist/utils/logger.js
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+}
+function log(message) {
+  console.log(`${COLORS.dim}[${timestamp()}]${COLORS.reset} ${COLORS.cyan}[ploy]${COLORS.reset} ${message}`);
+}
+function success(message) {
+  console.log(`${COLORS.dim}[${timestamp()}]${COLORS.reset} ${COLORS.green}[ploy]${COLORS.reset} ${message}`);
+}
+function error(message) {
+  console.error(`${COLORS.dim}[${timestamp()}]${COLORS.reset} ${COLORS.red}[ploy]${COLORS.reset} ${message}`);
+}
+function debug(message, verbose) {
+  if (verbose) {
+    console.log(`${COLORS.dim}[${timestamp()}]${COLORS.reset} ${COLORS.magenta}[ploy:debug]${COLORS.reset} ${message}`);
+  }
+}
+var COLORS;
+var init_logger = __esm({
+  "../emulator/dist/utils/logger.js"() {
+    COLORS = {
+      reset: "\x1B[0m",
+      dim: "\x1B[2m",
+      cyan: "\x1B[36m",
+      green: "\x1B[32m",
+      yellow: "\x1B[33m",
+      red: "\x1B[31m",
+      magenta: "\x1B[35m"
+    };
+  }
+});
+function getProjectHash(projectDir) {
+  return createHash("sha256").update(projectDir).digest("hex").slice(0, 12);
+}
+function getTempDir(projectDir) {
+  const hash = getProjectHash(projectDir);
+  return join(tmpdir(), `ploy-emulator-${hash}`);
+}
+function getDataDir(projectDir) {
+  return join(projectDir, ".ploy");
+}
+function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true });
+}
+function ensureTempDir(projectDir) {
+  const tempDir = getTempDir(projectDir);
+  ensureDir(tempDir);
+  return tempDir;
+}
+function ensureDataDir(projectDir) {
+  const dataDir = getDataDir(projectDir);
+  ensureDir(dataDir);
+  ensureDir(join(dataDir, "db"));
+  return dataDir;
+}
+var init_paths = __esm({
+  "../emulator/dist/utils/paths.js"() {
+  }
+});
+function initializeDatabases(projectDir) {
+  const dataDir = ensureDataDir(projectDir);
+  const d1Databases = /* @__PURE__ */ new Map();
+  const emulatorDb = new Database(join(dataDir, "emulator.db"));
+  emulatorDb.pragma("journal_mode = WAL");
+  emulatorDb.exec(EMULATOR_SCHEMA);
+  function getD1Database(bindingName) {
+    let db = d1Databases.get(bindingName);
+    if (!db) {
+      db = new Database(join(dataDir, "db", `${bindingName}.db`));
+      db.pragma("journal_mode = WAL");
+      d1Databases.set(bindingName, db);
+    }
+    return db;
+  }
+  function close() {
+    emulatorDb.close();
+    for (const db of d1Databases.values()) {
+      db.close();
+    }
+    d1Databases.clear();
+  }
+  return {
+    emulatorDb,
+    getD1Database,
+    close
+  };
+}
+var EMULATOR_SCHEMA;
+var init_sqlite = __esm({
+  "../emulator/dist/utils/sqlite.js"() {
+    init_paths();
+    EMULATOR_SCHEMA = `
+-- Queue messages table
+CREATE TABLE IF NOT EXISTS queue_messages (
+  id TEXT PRIMARY KEY,
+  queue_name TEXT NOT NULL,
+  payload TEXT NOT NULL,
+  status TEXT DEFAULT 'pending',
+  attempt INTEGER DEFAULT 0,
+  delivery_id TEXT,
+  visible_at INTEGER NOT NULL,
+  created_at INTEGER DEFAULT (strftime('%s', 'now')),
+  updated_at INTEGER DEFAULT (strftime('%s', 'now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_queue_messages_status
+  ON queue_messages(queue_name, status, visible_at);
+
+-- Workflow executions table
+CREATE TABLE IF NOT EXISTS workflow_executions (
+  id TEXT PRIMARY KEY,
+  workflow_name TEXT NOT NULL,
+  status TEXT DEFAULT 'pending',
+  input TEXT,
+  output TEXT,
+  error TEXT,
+  started_at INTEGER,
+  completed_at INTEGER,
+  created_at INTEGER DEFAULT (strftime('%s', 'now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_workflow_executions_status
+  ON workflow_executions(workflow_name, status);
+
+-- Workflow steps table
+CREATE TABLE IF NOT EXISTS workflow_steps (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  execution_id TEXT NOT NULL,
+  step_name TEXT NOT NULL,
+  step_index INTEGER NOT NULL,
+  status TEXT DEFAULT 'pending',
+  output TEXT,
+  error TEXT,
+  duration_ms INTEGER,
+  created_at INTEGER DEFAULT (strftime('%s', 'now')),
+  FOREIGN KEY (execution_id) REFERENCES workflow_executions(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_workflow_steps_execution
+  ON workflow_steps(execution_id, step_index);
+`;
+  }
+});
+async function startEmulator(options = {}) {
+  const emulator = new EmulatorServer(options);
+  await emulator.start();
+  return emulator;
+}
+var EmulatorServer;
+var init_emulator = __esm({
+  "../emulator/dist/emulator.js"() {
+    init_bundler();
+    init_watcher();
+    init_ploy_config2();
+    init_workerd_config();
+    init_mock_server();
+    init_queue_service();
+    init_logger();
+    init_paths();
+    init_sqlite();
+    EmulatorServer = class {
+      options;
+      projectDir;
+      tempDir = "";
+      config = null;
+      dbManager = null;
+      mockServer = null;
+      workerdProcess = null;
+      fileWatcher = null;
+      queueProcessor = null;
+      constructor(options = {}) {
+        const port = options.port ?? 8787;
+        this.options = {
+          port,
+          host: options.host ?? "localhost",
+          configPath: options.configPath ?? "ploy.yaml",
+          watch: options.watch ?? true,
+          verbose: options.verbose ?? false,
+          dashboardPort: options.dashboardPort ?? port + 1e3
+        };
+        this.projectDir = process.cwd();
+      }
+      async start() {
+        log("Starting Ploy emulator...");
+        try {
+          this.config = readPloyConfig2(this.projectDir, this.options.configPath);
+          debug(`Loaded config: ${JSON.stringify(this.config)}`, this.options.verbose);
+          this.tempDir = ensureTempDir(this.projectDir);
+          ensureDataDir(this.projectDir);
+          debug(`Temp dir: ${this.tempDir}`, this.options.verbose);
+          this.dbManager = initializeDatabases(this.projectDir);
+          debug("Initialized databases", this.options.verbose);
+          const workerUrl = `http://${this.options.host}:${this.options.port}`;
+          const dashboardPort = this.options.dashboardPort;
+          this.mockServer = await startMockServer(this.dbManager, this.config, {
+            workerUrl,
+            port: dashboardPort,
+            dashboardEnabled: true
+          });
+          debug(`Mock server started on port ${this.mockServer.port}`, this.options.verbose);
+          const mockServiceUrl = `http://localhost:${this.mockServer.port}`;
+          const entryPoint = getWorkerEntryPoint2(this.projectDir, this.config);
+          debug(`Entry point: ${entryPoint}`, this.options.verbose);
+          await this.bundle(entryPoint, mockServiceUrl);
+          const workerdConfigPath = writeWorkerdConfig({
+            tempDir: this.tempDir,
+            bundlePath: join(this.tempDir, "worker.bundle.js"),
+            port: this.options.port,
+            mockServicePort: this.mockServer.port,
+            config: this.config
+          });
+          await this.startWorkerd(workerdConfigPath);
+          if (this.options.watch) {
+            const srcDir = this.getSrcDir();
+            this.fileWatcher = createFileWatcher(srcDir, async () => {
+              log("Changes detected, rebuilding...");
+              try {
+                await this.bundle(entryPoint, mockServiceUrl);
+                success("Rebuild complete");
+              } catch (err) {
+                error(`Rebuild failed: ${err instanceof Error ? err.message : String(err)}`);
+              }
+            });
+            this.fileWatcher.start();
+            debug(`Watching ${srcDir} for changes`, this.options.verbose);
+          }
+          if (this.config.queue) {
+            const workerUrl2 = `http://${this.options.host}:${this.options.port}`;
+            this.queueProcessor = createQueueProcessor(this.dbManager.emulatorDb, this.config.queue, workerUrl2);
+            this.queueProcessor.start();
+            debug("Queue processor started", this.options.verbose);
+          }
+          success(`Emulator running at http://${this.options.host}:${this.options.port}`);
+          log(`  Dashboard: http://${this.options.host}:${this.mockServer.port}`);
+          if (this.config.db) {
+            log(`  DB bindings: ${Object.keys(this.config.db).join(", ")}`);
+          }
+          if (this.config.queue) {
+            log(`  Queue bindings: ${Object.keys(this.config.queue).join(", ")}`);
+          }
+          if (this.config.workflow) {
+            log(`  Workflow bindings: ${Object.keys(this.config.workflow).join(", ")}`);
+          }
+          this.setupSignalHandlers();
+        } catch (err) {
+          error(`Failed to start emulator: ${err instanceof Error ? err.message : String(err)}`);
+          await this.stop();
+          throw err;
+        }
+      }
+      async bundle(entryPoint, mockServiceUrl) {
+        if (!this.config) {
+          throw new Error("Config not loaded");
+        }
+        await bundleWorker({
+          projectDir: this.projectDir,
+          tempDir: this.tempDir,
+          entryPoint,
+          config: this.config,
+          mockServiceUrl
+        });
+      }
+      async startWorkerd(configPath) {
+        const args2 = ["serve", "--experimental", "--verbose", configPath];
+        if (this.options.watch) {
+          args2.push("--watch");
+        }
+        const workerdBin = this.findWorkerdBinary();
+        log(`[ploy] Using workerd binary: ${workerdBin}`);
+        debug(`Starting workerd: ${workerdBin} ${args2.join(" ")}`, this.options.verbose);
+        return await new Promise((resolve, reject) => {
+          const workerdBinDir = dirname(workerdBin);
+          this.workerdProcess = spawn(workerdBin, args2, {
+            cwd: this.tempDir,
+            stdio: ["pipe", "pipe", "pipe"],
+            shell: true,
+            env: {
+              ...process.env,
+              PATH: `${workerdBinDir}:${process.env.PATH || ""}`
+            }
+          });
+          let started = false;
+          let stderrOutput = "";
+          this.workerdProcess.stdout?.on("data", (data) => {
+            const output = data.toString();
+            if (this.options.verbose) {
+              process.stdout.write(output);
+            }
+            if (!started && (output.includes("Listening") || output.includes("running"))) {
+              started = true;
+              resolve();
+            }
+          });
+          this.workerdProcess.stderr?.on("data", (data) => {
+            const output = data.toString();
+            stderrOutput += output;
+            log(`[workerd stderr] ${output.trim()}`);
+            if (output.includes("error") || output.includes("Error")) {
+              error(output.trim());
+            } else if (this.options.verbose) {
+              process.stderr.write(output);
+            }
+            if (!started && output.includes("Listening")) {
+              started = true;
+              resolve();
+            }
+          });
+          this.workerdProcess.on("error", (err) => {
+            error(`workerd error: ${err.message}`);
+            if (!started) {
+              reject(err);
+            }
+          });
+          this.workerdProcess.on("exit", (code) => {
+            if (code !== 0 && code !== null) {
+              error(`workerd exited with code ${code}`);
+              if (stderrOutput) {
+                error(`workerd stderr: ${stderrOutput.trim()}`);
+              }
+            }
+            if (!started) {
+              reject(new Error(`workerd exited with code ${code}`));
+            }
+          });
+          setTimeout(() => {
+            if (!started) {
+              started = true;
+              resolve();
+            }
+          }, 2e3);
+        });
+      }
+      findWorkerdBinary() {
+        const __filename2 = fileURLToPath(import.meta.url);
+        const __dirname2 = dirname(__filename2);
+        const emulatorPkgDir = join(__dirname2, "..");
+        const possiblePaths = [
+          join(emulatorPkgDir, "node_modules", ".bin", "workerd"),
+          join(this.projectDir, "node_modules", ".bin", "workerd"),
+          "workerd"
+        ];
+        for (const p of possiblePaths) {
+          if (p === "workerd" || existsSync(p)) {
+            return p;
+          }
+        }
+        return "workerd";
+      }
+      getSrcDir() {
+        const possibleDirs = [join(this.projectDir, "src"), this.projectDir];
+        for (const dir of possibleDirs) {
+          if (existsSync(dir)) {
+            return dir;
+          }
         }
-        else if (arg === "-c" || arg === "--config") {
-            options.config = args[++i];
+        return this.projectDir;
+      }
+      setupSignalHandlers() {
+        const handler = async () => {
+          log("\nShutting down...");
+          await this.stop();
+          process.exit(0);
+        };
+        process.on("SIGINT", handler);
+        process.on("SIGTERM", handler);
+      }
+      async stop() {
+        if (this.queueProcessor) {
+          this.queueProcessor.stop();
+          this.queueProcessor = null;
         }
-        else if (arg === "--no-watch") {
-            options.watch = false;
+        if (this.fileWatcher) {
+          this.fileWatcher.stop();
+          this.fileWatcher = null;
         }
-        else if (arg === "-v" || arg === "--verbose") {
-            options.verbose = true;
+        if (this.workerdProcess) {
+          this.workerdProcess.kill("SIGTERM");
+          this.workerdProcess = null;
         }
+        if (this.mockServer) {
+          await this.mockServer.close();
+          this.mockServer = null;
+        }
+        if (this.dbManager) {
+          this.dbManager.close();
+          this.dbManager = null;
+        }
+        log("Emulator stopped");
+      }
+    };
+  }
+});
+
+// ../emulator/dist/nextjs-dev.js
+function createDevD1(databaseId, apiUrl) {
+  return {
+    async dump() {
+      const response = await fetch(`${apiUrl}/db`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          databaseId,
+          method: "dump"
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`DB dump failed: ${await response.text()}`);
+      }
+      return await response.arrayBuffer();
+    },
+    prepare(query) {
+      let boundParams = [];
+      const stmt = {
+        bind(...values) {
+          boundParams = values;
+          return stmt;
+        },
+        async run() {
+          const response = await fetch(`${apiUrl}/db`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              databaseId,
+              method: "prepare",
+              query,
+              params: boundParams
+            })
+          });
+          if (!response.ok) {
+            throw new Error(`DB query failed: ${await response.text()}`);
+          }
+          return await response.json();
+        },
+        async all() {
+          return await stmt.run();
+        },
+        async first(colName) {
+          const result = await stmt.run();
+          if (result.results.length === 0) {
+            return null;
+          }
+          const firstRow = result.results[0];
+          if (colName) {
+            return firstRow[colName] ?? null;
+          }
+          return firstRow;
+        },
+        async raw() {
+          const result = await stmt.run();
+          if (result.results.length === 0) {
+            return [];
+          }
+          const keys = Object.keys(result.results[0]);
+          return result.results.map((row) => keys.map((k) => row[k]));
+        }
+      };
+      return stmt;
+    },
+    async exec(query) {
+      const response = await fetch(`${apiUrl}/db`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          databaseId,
+          method: "exec",
+          query
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`DB exec failed: ${await response.text()}`);
+      }
+      return await response.json();
+    },
+    async batch(statements) {
+      const stmts = statements.map((s) => {
+        const data = s.__db_data;
+        return data || s;
+      });
+      const response = await fetch(`${apiUrl}/db`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          databaseId,
+          method: "batch",
+          statements: stmts
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`DB batch failed: ${await response.text()}`);
+      }
+      return await response.json();
     }
-    return options;
+  };
 }
-if (command === "dev") {
-    const options = parseDevArgs(args.slice(1));
-    const { startEmulator } = await import("@meetploy/emulator");
-    await startEmulator({
-        port: options.port,
-        host: options.host,
-        configPath: options.config,
-        watch: options.watch,
-        verbose: options.verbose,
+async function initPloyForDev(config) {
+  if (process.env.NODE_ENV !== "development") {
+    return;
+  }
+  if (globalThis.__PLOY_DEV_INITIALIZED__) {
+    return;
+  }
+  globalThis.__PLOY_DEV_INITIALIZED__ = true;
+  const configPath = config?.configPath || "./ploy.yaml";
+  const projectDir = process.cwd();
+  let ployConfig;
+  try {
+    ployConfig = readPloyConfig2(projectDir, configPath);
+  } catch {
+    if (config?.bindings?.db) {
+      ployConfig = { db: config.bindings.db };
+    } else {
+      return;
+    }
+  }
+  if (config?.bindings?.db) {
+    ployConfig = { ...ployConfig, db: config.bindings.db };
+  }
+  if (!ployConfig.db || Object.keys(ployConfig.db).length === 0) {
+    return;
+  }
+  ensureDataDir(projectDir);
+  dbManager = initializeDatabases(projectDir);
+  mockServer = await startMockServer(dbManager, ployConfig, {});
+  const apiUrl = `http://localhost:${mockServer.port}`;
+  const env = {};
+  for (const [bindingName, databaseId] of Object.entries(ployConfig.db)) {
+    env[bindingName] = createDevD1(databaseId, apiUrl);
+  }
+  const context = {
+    env,
+    cf: void 0,
+    ctx: void 0
+  };
+  globalThis.__PLOY_DEV_CONTEXT__ = context;
+  Object.defineProperty(globalThis, PLOY_CONTEXT_SYMBOL, {
+    get() {
+      return context;
+    },
+    configurable: true
+  });
+  const bindingNames = Object.keys(env);
+  console.log(`[Ploy] Development context initialized with bindings: ${bindingNames.join(", ")}`);
+  console.log(`[Ploy] Mock server running at ${apiUrl}`);
+  const cleanup = async () => {
+    if (mockServer) {
+      await mockServer.close();
+      mockServer = null;
+    }
+    if (dbManager) {
+      dbManager.close();
+      dbManager = null;
+    }
+  };
+  process.on("exit", () => {
+    if (dbManager) {
+      dbManager.close();
+    }
+  });
+  process.on("SIGINT", async () => {
+    await cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await cleanup();
+    process.exit(0);
+  });
+}
+var PLOY_CONTEXT_SYMBOL, mockServer, dbManager;
+var init_nextjs_dev = __esm({
+  "../emulator/dist/nextjs-dev.js"() {
+    init_ploy_config2();
+    init_mock_server();
+    init_paths();
+    init_sqlite();
+    PLOY_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("__ploy-context__");
+    mockServer = null;
+    dbManager = null;
+  }
+});
+
+// ../emulator/dist/dev-dashboard.js
+async function startDevDashboard(options = {}) {
+  const projectDir = process.cwd();
+  const configPath = options.configPath ?? "ploy.yaml";
+  const port = options.port ?? 4e3;
+  const verbose = options.verbose ?? false;
+  log("Starting Ploy development dashboard...");
+  let config;
+  try {
+    config = readPloyConfig2(projectDir, configPath);
+  } catch {
+    config = {};
+  }
+  debug(`Loaded config: ${JSON.stringify(config)}`, verbose);
+  ensureDataDir(projectDir);
+  const dbManager2 = initializeDatabases(projectDir);
+  debug("Initialized databases", verbose);
+  const mockServer2 = await startMockServer(dbManager2, config, {
+    port,
+    dashboardEnabled: true
+  });
+  debug(`Mock server started on port ${mockServer2.port}`, verbose);
+  if (config.db) {
+    log(`  DB bindings: ${Object.keys(config.db).join(", ")}`);
+  }
+  if (config.queue) {
+    log(`  Queue bindings: ${Object.keys(config.queue).join(", ")}`);
+  }
+  if (config.workflow) {
+    log(`  Workflow bindings: ${Object.keys(config.workflow).join(", ")}`);
+  }
+  return {
+    port: mockServer2.port,
+    close: async () => {
+      await mockServer2.close();
+      dbManager2.close();
+      log("Dashboard stopped");
+    }
+  };
+}
+var init_dev_dashboard = __esm({
+  "../emulator/dist/dev-dashboard.js"() {
+    init_ploy_config2();
+    init_mock_server();
+    init_logger();
+    init_paths();
+    init_sqlite();
+  }
+});
+
+// ../emulator/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  DB_RUNTIME_CODE: () => DB_RUNTIME_CODE,
+  DB_RUNTIME_CODE_PRODUCTION: () => DB_RUNTIME_CODE_PRODUCTION,
+  EmulatorServer: () => EmulatorServer,
+  initPloyForDev: () => initPloyForDev,
+  startDevDashboard: () => startDevDashboard,
+  startEmulator: () => startEmulator
+});
+var init_dist2 = __esm({
+  "../emulator/dist/index.js"() {
+    init_emulator();
+    init_nextjs_dev();
+    init_dev_dashboard();
+    init_db_runtime();
+  }
+});
+
+// src/commands/build.ts
+init_cli();
+function detectPackageManager() {
+  const cwd = process.cwd();
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync(join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  return "npm";
+}
+function runWranglerBuild() {
+  return new Promise((resolve, reject) => {
+    const packageManager = detectPackageManager();
+    let command2;
+    let args2;
+    if (packageManager === "npm") {
+      command2 = "npx";
+      args2 = ["wrangler", "build"];
+    } else if (packageManager === "yarn") {
+      command2 = "yarn";
+      args2 = ["wrangler", "build"];
+    } else {
+      command2 = "pnpm";
+      args2 = ["wrangler", "build"];
+    }
+    console.log(`Running: ${command2} ${args2.join(" ")}`);
+    const child = spawn(command2, args2, {
+      cwd: process.cwd(),
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", (error2) => {
+      reject(new Error(`Failed to run wrangler build: ${error2.message}`));
     });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`wrangler build exited with code ${code}`));
+      }
+    });
+  });
+}
+async function buildCommand(options = {}) {
+  const cwd = process.cwd();
+  const configFile = options.config || "ploy.yaml";
+  console.log("Validating ploy.yaml...");
+  const config = readPloyConfigSync(cwd, options.config);
+  validatePloyConfig(config, configFile);
+  console.log("Configuration valid.");
+  console.log("");
+  await runWranglerBuild();
+}
+function parseBuildArgs(args2) {
+  const options = {};
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "-c" || arg === "--config") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error(`Error: ${arg} requires a path argument`);
+        process.exit(1);
+      }
+      options.config = nextArg;
+      i++;
+    } else if (arg === "-h" || arg === "--help") {
+      printBuildHelp();
+      process.exit(0);
+    }
+  }
+  return options;
+}
+function printBuildHelp() {
+  console.log("Usage: ploy build [options]");
+  console.log("");
+  console.log("Build your Ploy project");
+  console.log("");
+  console.log("Options:");
+  console.log(
+    "  -c, --config <path>  Path to config file (default: ploy.yaml)"
+  );
+  console.log("  -h, --help           Show this help message");
+  console.log("");
+  console.log("Examples:");
+  console.log(
+    "  ploy build                     Build using ploy.yaml in current directory"
+  );
+  console.log(
+    "  ploy build -c custom.yaml      Build using a custom config file"
+  );
+}
+
+// src/commands/types.ts
+init_cli();
+async function updateTsConfigInclude(cwd, outputPath) {
+  const tsconfigPath = join(cwd, "tsconfig.json");
+  try {
+    const content = await readFile(tsconfigPath, "utf-8");
+    const tsconfig = JSON.parse(content);
+    if (!tsconfig.include) {
+      tsconfig.include = [];
+    }
+    if (tsconfig.include.includes(outputPath)) {
+      return false;
+    }
+    tsconfig.include.push(outputPath);
+    await writeFile(tsconfigPath, JSON.stringify(tsconfig, null, "	") + "\n");
+    return true;
+  } catch (error2) {
+    if (error2 && typeof error2 === "object" && "code" in error2) {
+      if (error2.code === "ENOENT") {
+        return false;
+      }
+    }
+    console.warn(`Warning: Could not update tsconfig.json: ${error2}`);
+    return false;
+  }
 }
-else if (command === "types") {
-    const options = parseTypesArgs(args.slice(1));
-    await typesCommand(options);
+function generateEnvType(config) {
+  const imports = [];
+  const properties = [];
+  if (config.ai) {
+    properties.push("	AI_URL: string;");
+    properties.push("	AI_TOKEN: string;");
+  }
+  if (config.db) {
+    imports.push("D1Database");
+    for (const bindingName of Object.keys(config.db)) {
+      properties.push(`	${bindingName}: D1Database;`);
+    }
+  }
+  if (config.queue) {
+    imports.push("QueueBinding");
+    for (const bindingName of Object.keys(config.queue)) {
+      properties.push(`	${bindingName}: QueueBinding;`);
+    }
+  }
+  if (config.workflow) {
+    imports.push("WorkflowBinding");
+    for (const bindingName of Object.keys(config.workflow)) {
+      properties.push(`	${bindingName}: WorkflowBinding;`);
+    }
+  }
+  const lines = [
+    "// This file is auto-generated by `ploy types`. Do not edit manually.",
+    ""
+  ];
+  if (imports.length > 0) {
+    lines.push(`import type { ${imports.join(", ")} } from "@meetploy/types";`);
+    lines.push("");
+  }
+  lines.push('declare module "@meetploy/nextjs" {');
+  lines.push("	interface PloyEnv {");
+  for (const prop of properties) {
+    lines.push(`	${prop}`);
+  }
+  lines.push("	}");
+  lines.push("}");
+  lines.push("");
+  lines.push("declare global {");
+  lines.push("	interface PloyEnv {");
+  for (const prop of properties) {
+    lines.push(`	${prop}`);
+  }
+  lines.push("	}");
+  lines.push("}");
+  lines.push("");
+  lines.push("export {};");
+  lines.push("");
+  return lines.join("\n");
 }
-else if (command === "build") {
-    const options = parseBuildArgs(args.slice(1));
-    await buildCommand(options);
+function getOutputPath(options) {
+  if (options.output) {
+    return options.output;
+  }
+  return "env.d.ts";
 }
-else {
-    console.error(`Unknown command: ${command}`);
-    console.error("\nAvailable commands:");
-    console.error("  build  Build your Ploy project");
-    console.error("  dev    Start development server");
-    console.error("  types  Generate TypeScript types from ploy.yaml");
+async function typesCommand(options = {}) {
+  const cwd = process.cwd();
+  const config = await readPloyConfig(cwd);
+  if (!config) {
+    console.error("Error: ploy.yaml not found in current directory");
     process.exit(1);
+  }
+  const hasBindings2 = config.ai || config.db || config.queue || config.workflow;
+  if (!hasBindings2) {
+    console.log("No bindings found in ploy.yaml. Generating empty Env.");
+  }
+  const content = generateEnvType(config);
+  const outputPath = getOutputPath(options);
+  const fullOutputPath = join(cwd, outputPath);
+  const outputDir = dirname(fullOutputPath);
+  await mkdir(outputDir, { recursive: true });
+  await writeFile(fullOutputPath, content, "utf-8");
+  console.log(`Generated ${outputPath}`);
+  const updated = await updateTsConfigInclude(cwd, outputPath);
+  if (updated) {
+    console.log(`Updated tsconfig.json to include ${outputPath}`);
+  }
+  process.exit(0);
+}
+function parseTypesArgs(args2) {
+  const options = {};
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "-o" || arg === "--output") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error(`Error: ${arg} requires a path argument`);
+        process.exit(1);
+      }
+      options.output = nextArg;
+      i++;
+    } else if (arg === "-h" || arg === "--help") {
+      printTypesHelp();
+      process.exit(0);
+    }
+  }
+  return options;
+}
+function printTypesHelp() {
+  console.log("Usage: ploy types [options]");
+  console.log("");
+  console.log("Generate TypeScript types from ploy.yaml bindings");
+  console.log("");
+  console.log("Options:");
+  console.log("  -o, --output <path>  Output file path (default: env.d.ts)");
+  console.log("  -h, --help           Show this help message");
+  console.log("");
+  console.log("Examples:");
+  console.log(
+    "  ploy types                    Generate env.d.ts in current directory"
+  );
+  console.log("  ploy types -o env.d.ts    Generate types to specific path");
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+var command = args[0];
+if (!command) {
+  console.error("Usage: ploy <command>");
+  console.error("\nAvailable commands:");
+  console.error("  build  Build your Ploy project");
+  console.error("  dev    Start development server");
+  console.error("  types  Generate TypeScript types from ploy.yaml");
+  process.exit(1);
+}
+function parseDevArgs(args2) {
+  const options = {
+    port: void 0,
+    host: void 0,
+    config: void 0,
+    watch: true,
+    verbose: false,
+    dashboardPort: void 0
+  };
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "-p" || arg === "--port") {
+      const value = args2[++i];
+      if (value) {
+        options.port = parseInt(value, 10);
+      }
+    } else if (arg === "-h" || arg === "--host") {
+      options.host = args2[++i];
+    } else if (arg === "-c" || arg === "--config") {
+      options.config = args2[++i];
+    } else if (arg === "--no-watch") {
+      options.watch = false;
+    } else if (arg === "-v" || arg === "--verbose") {
+      options.verbose = true;
+    } else if (arg === "--dashboard-port") {
+      const value = args2[++i];
+      if (value) {
+        options.dashboardPort = parseInt(value, 10);
+      }
+    }
+  }
+  return options;
+}
+async function isNextJsProject(projectDir, configPath) {
+  const { readPloyConfig: readPloyConfig3 } = await Promise.resolve().then(() => (init_cli(), cli_exports));
+  try {
+    const config = await readPloyConfig3(projectDir, configPath);
+    if (config?.kind === "nextjs") {
+      return true;
+    }
+  } catch {
+  }
+  const nextConfigFiles = [
+    "next.config.ts",
+    "next.config.js",
+    "next.config.mts",
+    "next.config.mjs"
+  ];
+  for (const file of nextConfigFiles) {
+    if (existsSync(join(projectDir, file))) {
+      return true;
+    }
+  }
+  return false;
+}
+function findNextBinary(projectDir) {
+  const possiblePaths = [
+    join(projectDir, "node_modules", ".bin", "next"),
+    "npx next"
+  ];
+  for (const p of possiblePaths) {
+    if (p.includes("npx") || existsSync(p)) {
+      return p;
+    }
+  }
+  return "npx next";
+}
+async function startNextJsDev(options) {
+  const projectDir = process.cwd();
+  const nextPort = options.port ?? 3e3;
+  const dashboardPort = options.dashboardPort ?? nextPort + 1e3;
+  const { startDevDashboard: startDevDashboard2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
+  const dashboard = await startDevDashboard2({
+    configPath: options.config,
+    port: dashboardPort,
+    verbose: options.verbose
+  });
+  console.log(
+    `
+  Ploy Dashboard: http://${options.host ?? "localhost"}:${dashboard.port}`
+  );
+  const nextBin = findNextBinary(projectDir);
+  const nextArgs = ["dev", "-p", String(nextPort)];
+  if (options.host) {
+    nextArgs.push("-H", options.host);
+  }
+  console.log(`  Starting Next.js dev server...`);
+  let nextProcess;
+  if (nextBin.includes("npx")) {
+    nextProcess = spawn("npx", ["next", ...nextArgs], {
+      cwd: projectDir,
+      stdio: "inherit",
+      shell: true,
+      env: {
+        ...process.env,
+        // Set environment variable so initPloyForDev knows the mock server URL
+        PLOY_MOCK_SERVER_URL: `http://localhost:${dashboard.port}`
+      }
+    });
+  } else {
+    nextProcess = spawn(nextBin, nextArgs, {
+      cwd: projectDir,
+      stdio: "inherit",
+      shell: true,
+      env: {
+        ...process.env,
+        PLOY_MOCK_SERVER_URL: `http://localhost:${dashboard.port}`
+      }
+    });
+  }
+  const cleanup = async () => {
+    console.log("\nShutting down...");
+    nextProcess.kill("SIGTERM");
+    await dashboard.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  nextProcess.on("exit", async (code) => {
+    await dashboard.close();
+    process.exit(code ?? 0);
+  });
+}
+if (command === "dev") {
+  const options = parseDevArgs(args.slice(1));
+  const projectDir = process.cwd();
+  const isNextJs = await isNextJsProject(projectDir, options.config);
+  if (isNextJs) {
+    await startNextJsDev({
+      port: options.port,
+      host: options.host,
+      config: options.config,
+      verbose: options.verbose,
+      dashboardPort: options.dashboardPort
+    });
+  } else {
+    const { startEmulator: startEmulator2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
+    await startEmulator2({
+      port: options.port,
+      host: options.host,
+      configPath: options.config,
+      watch: options.watch,
+      verbose: options.verbose,
+      dashboardPort: options.dashboardPort
+    });
+  }
+} else if (command === "types") {
+  const options = parseTypesArgs(args.slice(1));
+  await typesCommand(options);
+} else if (command === "build") {
+  const options = parseBuildArgs(args.slice(1));
+  await buildCommand(options);
+} else {
+  console.error(`Unknown command: ${command}`);
+  console.error("\nAvailable commands:");
+  console.error("  build  Build your Ploy project");
+  console.error("  dev    Start development server");
+  console.error("  types  Generate TypeScript types from ploy.yaml");
+  process.exit(1);
 }
-//# sourceMappingURL=index.js.map