@meetploy/emulator 1.0.0

package/dist/bundler/bundler.d.ts

@@ -0,0 +1,9 @@
+import type { PloyConfig } from "../config/ploy-config.js";
+export interface BundlerOptions {
+    projectDir: string;
+    tempDir: string;
+    entryPoint: string;
+    config: PloyConfig;
+    mockServiceUrl: string;
+}
+export declare function bundleWorker(options: BundlerOptions): Promise<string>;

package/dist/bundler/bundler.js

@@ -0,0 +1,174 @@
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { build } from "esbuild";
+import { DB_RUNTIME_CODE } from "../runtime/db-runtime.js";
+import { QUEUE_RUNTIME_CODE } from "../runtime/queue-runtime.js";
+import { WORKFLOW_RUNTIME_CODE } from "../runtime/workflow-runtime.js";
+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(build) {
+            build.onResolve({ filter: /^__ploy_db_runtime__$/ }, () => ({
+                path: "__ploy_db_runtime__",
+                namespace: "ploy-runtime",
+            }));
+            build.onResolve({ filter: /^__ploy_queue_runtime__$/ }, () => ({
+                path: "__ploy_queue_runtime__",
+                namespace: "ploy-runtime",
+            }));
+            build.onResolve({ filter: /^__ploy_workflow_runtime__$/ }, () => ({
+                path: "__ploy_workflow_runtime__",
+                namespace: "ploy-runtime",
+            }));
+            build.onLoad({ filter: /^__ploy_db_runtime__$/, namespace: "ploy-runtime" }, () => ({
+                contents: DB_RUNTIME_CODE,
+                loader: "ts",
+            }));
+            build.onLoad({ filter: /^__ploy_queue_runtime__$/, namespace: "ploy-runtime" }, () => ({
+                contents: QUEUE_RUNTIME_CODE,
+                loader: "ts",
+            }));
+            build.onLoad({ filter: /^__ploy_workflow_runtime__$/, namespace: "ploy-runtime" }, () => ({
+                contents: WORKFLOW_RUNTIME_CODE,
+                loader: "ts",
+            }));
+        },
+    };
+}
+export 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(config)],
+        absWorkingDir: projectDir,
+        logLevel: "warning",
+    };
+    await build(buildOptions);
+    return bundlePath;
+}
+//# sourceMappingURL=bundler.js.map

package/dist/bundler/bundler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundler.js","sourceRoot":"","sources":["../../src/bundler/bundler.ts"],"names":[],"mappings":"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"}

package/dist/bundler/watcher.d.ts

@@ -0,0 +1,5 @@
+export interface FileWatcher {
+    start: () => void;
+    stop: () => void;
+}
+export declare function createFileWatcher(srcDir: string, onRebuild: () => Promise<void>): FileWatcher;

package/dist/bundler/watcher.js

@@ -0,0 +1,65 @@
+import { watch } from "chokidar";
+export 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;
+            }
+        },
+    };
+}
+//# sourceMappingURL=watcher.js.map

package/dist/bundler/watcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watcher.js","sourceRoot":"","sources":["../../src/bundler/watcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAkB,MAAM,UAAU,CAAC;AAOjD,MAAM,UAAU,iBAAiB,CAChC,MAAc,EACd,SAA8B;IAE9B,IAAI,OAAO,GAAqB,IAAI,CAAC;IACrC,IAAI,aAAa,GAAyC,IAAI,CAAC;IAC/D,IAAI,YAAY,GAAG,KAAK,CAAC;IAEzB,SAAS,aAAa,CAAC,QAAgB;QACtC,MAAM,UAAU,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QAClE,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IACzD,CAAC;IAED,SAAS,eAAe;QACvB,IAAI,aAAa,EAAE,CAAC;YACnB,YAAY,CAAC,aAAa,CAAC,CAAC;QAC7B,CAAC;QAED,aAAa,GAAG,UAAU,CAAC,KAAK,IAAI,EAAE;YACrC,IAAI,YAAY,EAAE,CAAC;gBAClB,OAAO;YACR,CAAC;YAED,YAAY,GAAG,IAAI,CAAC;YACpB,IAAI,CAAC;gBACJ,MAAM,SAAS,EAAE,CAAC;YACnB,CAAC;oBAAS,CAAC;gBACV,YAAY,GAAG,KAAK,CAAC;YACtB,CAAC;QACF,CAAC,EAAE,GAAG,CAAC,CAAC;IACT,CAAC;IAED,OAAO;QACN,KAAK;YACJ,IAAI,OAAO,EAAE,CAAC;gBACb,OAAO;YACR,CAAC;YAED,OAAO,GAAG,KAAK,CAAC,MAAM,EAAE;gBACvB,UAAU,EAAE,IAAI;gBAChB,aAAa,EAAE,IAAI;gBACnB,OAAO,EAAE,CAAC,oBAAoB,EAAE,YAAY,EAAE,aAAa,EAAE,OAAO,CAAC;aACrE,CAAC,CAAC;YAEH,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,EAAE;gBACjC,IAAI,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;oBAC7B,eAAe,EAAE,CAAC;gBACnB,CAAC;YACF,CAAC,CAAC,CAAC;YAEH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,EAAE;gBAC9B,IAAI,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;oBAC7B,eAAe,EAAE,CAAC;gBACnB,CAAC;YACF,CAAC,CAAC,CAAC;YAEH,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,EAAE;gBACjC,IAAI,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;oBAC7B,eAAe,EAAE,CAAC;gBACnB,CAAC;YACF,CAAC,CAAC,CAAC;QACJ,CAAC;QAED,IAAI;YACH,IAAI,aAAa,EAAE,CAAC;gBACnB,YAAY,CAAC,aAAa,CAAC,CAAC;gBAC5B,aAAa,GAAG,IAAI,CAAC;YACtB,CAAC;YAED,IAAI,OAAO,EAAE,CAAC;gBACb,OAAO,CAAC,KAAK,EAAE,CAAC;gBAChB,OAAO,GAAG,IAAI,CAAC;YAChB,CAAC;QACF,CAAC;KACD,CAAC;AACH,CAAC"}

package/dist/config/ploy-config.d.ts

@@ -0,0 +1,13 @@
+export interface PloyConfig {
+    kind: "dynamic" | "worker";
+    build?: string;
+    out?: string;
+    main?: string;
+    db?: Record<string, string>;
+    queue?: Record<string, string>;
+    workflow?: Record<string, string>;
+    ai?: boolean;
+}
+export declare function readPloyConfig(projectDir: string, configPath?: string): PloyConfig;
+export declare function getWorkerEntryPoint(projectDir: string, config: PloyConfig): string;
+export declare function hasBindings(config: PloyConfig): boolean;

package/dist/config/ploy-config.js

@@ -0,0 +1,40 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { parse } from "yaml";
+export function readPloyConfig(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");
+    const config = parse(content);
+    if (!config.kind) {
+        throw new Error(`Missing required field 'kind' in ${configFile}`);
+    }
+    if (config.kind !== "dynamic" && config.kind !== "worker") {
+        throw new Error(`Invalid kind '${config.kind}' in ${configFile}. Must be 'dynamic' or 'worker'`);
+    }
+    return config;
+}
+export 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");
+}
+export function hasBindings(config) {
+    return !!(config.db || config.queue || config.workflow || config.ai);
+}
+//# sourceMappingURL=ploy-config.js.map

package/dist/config/ploy-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ploy-config.js","sourceRoot":"","sources":["../../src/config/ploy-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAa7B,MAAM,UAAU,cAAc,CAC7B,UAAkB,EAClB,UAAmB;IAEnB,MAAM,UAAU,GAAG,UAAU,IAAI,WAAW,CAAC;IAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IAE9C,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,KAAK,CAAC,0BAA0B,QAAQ,EAAE,CAAC,CAAC;IACvD,CAAC;IAED,MAAM,OAAO,GAAG,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAChD,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAe,CAAC;IAE5C,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QAClB,MAAM,IAAI,KAAK,CAAC,oCAAoC,UAAU,EAAE,CAAC,CAAC;IACnE,CAAC;IAED,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC3D,MAAM,IAAI,KAAK,CACd,iBAAiB,MAAM,CAAC,IAAI,QAAQ,UAAU,iCAAiC,CAC/E,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AACf,CAAC;AAED,MAAM,UAAU,mBAAmB,CAClC,UAAkB,EAClB,MAAkB;IAElB,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;QACjB,OAAO,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;IACtC,CAAC;IAGD,MAAM,YAAY,GAAG;QACpB,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC;QAC5B,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC;QAC5B,IAAI,CAAC,UAAU,EAAE,KAAK,EAAE,UAAU,CAAC;QACnC,IAAI,CAAC,UAAU,EAAE,KAAK,EAAE,UAAU,CAAC;KACnC,CAAC;IAEF,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;QACjC,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;YACtB,OAAO,IAAI,CAAC;QACb,CAAC;IACF,CAAC;IAED,MAAM,IAAI,KAAK,CACd,gEAAgE,CAChE,CAAC;AACH,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,MAAkB;IAC7C,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,EAAE,CAAC,CAAC;AACtE,CAAC"}

package/dist/config/workerd-config.d.ts

@@ -0,0 +1,10 @@
+import type { PloyConfig } from "./ploy-config.js";
+export interface WorkerdConfigOptions {
+    tempDir: string;
+    bundlePath: string;
+    port: number;
+    mockServicePort: number;
+    config: PloyConfig;
+}
+export declare function generateWorkerdConfig(options: WorkerdConfigOptions): string;
+export declare function writeWorkerdConfig(options: WorkerdConfigOptions): string;

package/dist/config/workerd-config.js

@@ -0,0 +1,49 @@
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+export 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;
+}
+export function writeWorkerdConfig(options) {
+    const configContent = generateWorkerdConfig(options);
+    const configPath = join(options.tempDir, "workerd.capnp");
+    writeFileSync(configPath, configContent);
+    return configPath;
+}
+//# sourceMappingURL=workerd-config.js.map

package/dist/config/workerd-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerd-config.js","sourceRoot":"","sources":["../../src/config/workerd-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAYjC,MAAM,UAAU,qBAAqB,CAAC,OAA6B;IAClE,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC;IAE1C,MAAM,QAAQ,GAAG;QAChB,mCAAmC;QACnC,oDAAoD,eAAe,gBAAgB;QACnF,gHAAgH;KAChH,CAAC;IAEF,MAAM,QAAQ,GAAG;QAChB,mCAAmC;QACnC,2CAA2C;KAC3C,CAAC;IAEF,MAAM,aAAa,GAAG;;;;MAIjB,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC;;;mCAGK,IAAI;;;;;;;;;;;;;;;;MAgBjC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC;;;CAG7B,CAAC;IAED,OAAO,aAAa,CAAC;AACtB,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,OAA6B;IAC/D,MAAM,aAAa,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAAC;IACrD,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC;IAC1D,aAAa,CAAC,UAAU,EAAE,aAAa,CAAC,CAAC;IACzC,OAAO,UAAU,CAAC;AACnB,CAAC"}

package/dist/emulator.d.ts

@@ -0,0 +1,27 @@
+export interface EmulatorOptions {
+    port?: number;
+    host?: string;
+    configPath?: string;
+    watch?: boolean;
+    verbose?: boolean;
+}
+export declare class EmulatorServer {
+    private options;
+    private projectDir;
+    private tempDir;
+    private config;
+    private dbManager;
+    private mockServer;
+    private workerdProcess;
+    private fileWatcher;
+    private queueProcessor;
+    constructor(options?: EmulatorOptions);
+    start(): Promise<void>;
+    private bundle;
+    private startWorkerd;
+    private findWorkerdBinary;
+    private getSrcDir;
+    private setupSignalHandlers;
+    stop(): Promise<void>;
+}
+export declare function startEmulator(options?: EmulatorOptions): Promise<EmulatorServer>;

package/dist/emulator.js

@@ -0,0 +1,247 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { bundleWorker } from "./bundler/bundler.js";
+import { createFileWatcher } from "./bundler/watcher.js";
+import { readPloyConfig, getWorkerEntryPoint, } from "./config/ploy-config.js";
+import { writeWorkerdConfig } from "./config/workerd-config.js";
+import { startMockServer } from "./services/mock-server.js";
+import { createQueueProcessor, } from "./services/queue-service.js";
+import * as logger from "./utils/logger.js";
+import { ensureTempDir, ensureDataDir } from "./utils/paths.js";
+import { initializeDatabases } from "./utils/sqlite.js";
+export class EmulatorServer {
+    options;
+    projectDir;
+    tempDir = "";
+    config = null;
+    dbManager = null;
+    mockServer = null;
+    workerdProcess = null;
+    fileWatcher = null;
+    queueProcessor = null;
+    constructor(options = {}) {
+        this.options = {
+            port: options.port ?? 8787,
+            host: options.host ?? "localhost",
+            configPath: options.configPath ?? "ploy.yaml",
+            watch: options.watch ?? true,
+            verbose: options.verbose ?? false,
+        };
+        this.projectDir = process.cwd();
+    }
+    async start() {
+        logger.log("Starting Ploy emulator...");
+        try {
+            this.config = readPloyConfig(this.projectDir, this.options.configPath);
+            logger.debug(`Loaded config: ${JSON.stringify(this.config)}`, this.options.verbose);
+            this.tempDir = ensureTempDir(this.projectDir);
+            ensureDataDir(this.projectDir);
+            logger.debug(`Temp dir: ${this.tempDir}`, this.options.verbose);
+            this.dbManager = initializeDatabases(this.projectDir);
+            logger.debug("Initialized databases", this.options.verbose);
+            const workerUrl = `http://${this.options.host}:${this.options.port}`;
+            this.mockServer = await startMockServer(this.dbManager, this.config, {
+                workerUrl,
+            });
+            logger.debug(`Mock server started on port ${this.mockServer.port}`, this.options.verbose);
+            const mockServiceUrl = `http://localhost:${this.mockServer.port}`;
+            const entryPoint = getWorkerEntryPoint(this.projectDir, this.config);
+            logger.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 () => {
+                    logger.log("Changes detected, rebuilding...");
+                    try {
+                        await this.bundle(entryPoint, mockServiceUrl);
+                        logger.success("Rebuild complete");
+                    }
+                    catch (err) {
+                        logger.error(`Rebuild failed: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                });
+                this.fileWatcher.start();
+                logger.debug(`Watching ${srcDir} for changes`, this.options.verbose);
+            }
+            if (this.config.queue) {
+                const workerUrl = `http://${this.options.host}:${this.options.port}`;
+                this.queueProcessor = createQueueProcessor(this.dbManager.emulatorDb, this.config.queue, workerUrl);
+                this.queueProcessor.start();
+                logger.debug("Queue processor started", this.options.verbose);
+            }
+            logger.success(`Emulator running at http://${this.options.host}:${this.options.port}`);
+            if (this.config.db) {
+                logger.log(`  DB bindings: ${Object.keys(this.config.db).join(", ")}`);
+            }
+            if (this.config.queue) {
+                logger.log(`  Queue bindings: ${Object.keys(this.config.queue).join(", ")}`);
+            }
+            if (this.config.workflow) {
+                logger.log(`  Workflow bindings: ${Object.keys(this.config.workflow).join(", ")}`);
+            }
+            this.setupSignalHandlers();
+        }
+        catch (err) {
+            logger.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 args = ["serve", "--experimental", "--verbose", configPath];
+        if (this.options.watch) {
+            args.push("--watch");
+        }
+        const workerdBin = this.findWorkerdBinary();
+        logger.log(`[ploy] Using workerd binary: ${workerdBin}`);
+        logger.debug(`Starting workerd: ${workerdBin} ${args.join(" ")}`, this.options.verbose);
+        return await new Promise((resolve, reject) => {
+            const workerdBinDir = dirname(workerdBin);
+            this.workerdProcess = spawn(workerdBin, args, {
+                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;
+                logger.log(`[workerd stderr] ${output.trim()}`);
+                if (output.includes("error") || output.includes("Error")) {
+                    logger.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) => {
+                logger.error(`workerd error: ${err.message}`);
+                if (!started) {
+                    reject(err);
+                }
+            });
+            this.workerdProcess.on("exit", (code) => {
+                if (code !== 0 && code !== null) {
+                    logger.error(`workerd exited with code ${code}`);
+                    if (stderrOutput) {
+                        logger.error(`workerd stderr: ${stderrOutput.trim()}`);
+                    }
+                }
+                if (!started) {
+                    reject(new Error(`workerd exited with code ${code}`));
+                }
+            });
+            setTimeout(() => {
+                if (!started) {
+                    started = true;
+                    resolve();
+                }
+            }, 2000);
+        });
+    }
+    findWorkerdBinary() {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const emulatorPkgDir = join(__dirname, "..");
+        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;
+            }
+        }
+        return this.projectDir;
+    }
+    setupSignalHandlers() {
+        const handler = async () => {
+            logger.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;
+        }
+        if (this.fileWatcher) {
+            this.fileWatcher.stop();
+            this.fileWatcher = null;
+        }
+        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;
+        }
+        logger.log("Emulator stopped");
+    }
+}
+export async function startEmulator(options = {}) {
+    const emulator = new EmulatorServer(options);
+    await emulator.start();
+    return emulator;
+}
+//# sourceMappingURL=emulator.js.map