devflare 1.0.0-next.7 → 1.0.0-next.71

package/dist/dev-rsdssknb.js

@@ -1,2707 +0,0 @@
-import {
-  detectViteProject,
-  stopSpawnedProcessTree,
-  waitForViteReady
-} from "./index-18hvb6gb.js";
-import {
-  findFiles
-} from "./index-rbht7m9r.js";
-import {
-  findDurableObjectClasses
-} from "./index-gz1gndna.js";
-import {
-  loadConfig,
-  resolveConfigPath
-} from "./index-hcex3rgh.js";
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/cli/commands/dev.ts
-import { createConsola } from "consola";
-import { resolve as resolve3 } from "pathe";
-
-// src/dev-server/server.ts
-import { dirname as dirname2, relative as relative2, resolve as resolve2 } from "pathe";
-
-// src/bundler/do-bundler.ts
-import { resolve, dirname, relative } from "pathe";
-import picomatch from "picomatch";
-function classToBindingName(className) {
-  return className.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toUpperCase();
-}
-async function discoverDOs(cwd, pattern) {
-  const fs = await import("node:fs/promises");
-  const discovered = [];
-  const files = await findFiles(pattern, { cwd });
-  for (const filePath of files) {
-    try {
-      const code = await fs.readFile(filePath, "utf-8");
-      const classNames = findDurableObjectClasses(code);
-      for (const className of classNames) {
-        discovered.push({
-          filePath,
-          className,
-          bindingName: classToBindingName(className)
-        });
-      }
-    } catch {}
-  }
-  return discovered;
-}
-function stripDecoratorSyntax(code) {
-  let result = code;
-  result = result.replace(/@durableObject\s*\([^)]*\)\s*\n?\s*(?=export\s+class)/g, "");
-  result = result.replace(/import\s*\{([^}]*)\bdurableObject\b[^}]*\}\s*from\s*['"]devflare\/runtime['"]\s*;?/g, (match, imports) => {
-    const cleanedImports = imports.split(",").map((s) => s.trim()).filter((s) => !s.startsWith("durableObject")).join(", ");
-    if (cleanedImports.trim() === "") {
-      return "";
-    }
-    return `import { ${cleanedImports} } from 'devflare/runtime'`;
-  });
-  return result;
-}
-async function bundleDOFile(sourcePath, className, outDir, cwd) {
-  const { rolldown } = await import("rolldown");
-  const fs = await import("node:fs/promises");
-  await fs.mkdir(outDir, { recursive: true });
-  const sourceCode = await fs.readFile(sourcePath, "utf-8");
-  const cleanedCode = stripDecoratorSyntax(sourceCode);
-  const entryCode = `${cleanedCode}
-
-// Default export for worker (required by Miniflare)
-export default {
-	async fetch(request) {
-		return new Response('DO Worker for ${className}', { status: 200 });
-	}
-};
-`;
-  const tempFilePath = resolve(outDir, `_temp_${className}.ts`);
-  await fs.writeFile(tempFilePath, entryCode, "utf-8");
-  const classOutDir = resolve(outDir, className);
-  try {
-    await fs.rm(classOutDir, { recursive: true, force: true });
-  } catch {}
-  await fs.mkdir(classOutDir, { recursive: true });
-  const debugShimCode = `
-// Debug module shim for local development
-const createDebug = (namespace) => {
-	const logger = (...args) => {
-		if (createDebug.enabled) console.debug(\`[\${namespace}]\`, ...args)
-	}
-	logger.enabled = false
-	logger.namespace = namespace
-	logger.extend = (sub) => createDebug(\`\${namespace}:\${sub}\`)
-	return logger
-}
-createDebug.enabled = false
-createDebug.formatters = {}
-export default createDebug
-`;
-  const debugShimPath = resolve(outDir, "_debug_shim.js");
-  await fs.writeFile(debugShimPath, debugShimCode, "utf-8");
-  const bundle = await rolldown({
-    input: tempFilePath,
-    platform: "neutral",
-    tsconfig: resolve(cwd, "tsconfig.json"),
-    external: [
-      /^cloudflare:/,
-      /^node:/,
-      "buffer",
-      "crypto",
-      "events",
-      "http",
-      "https",
-      "net",
-      "os",
-      "path",
-      "stream",
-      "tls",
-      "url",
-      "util",
-      "zlib",
-      "fs",
-      "child_process",
-      "async_hooks",
-      "querystring",
-      "string_decoder",
-      "assert",
-      "dns"
-    ],
-    resolve: {
-      alias: {
-        debug: debugShimPath
-      }
-    }
-  });
-  const outFile = resolve(classOutDir, "index.js");
-  await bundle.write({
-    file: outFile,
-    format: "esm",
-    sourcemap: false,
-    inlineDynamicImports: true
-  });
-  await bundle.close();
-  try {
-    await fs.unlink(tempFilePath);
-  } catch {}
-  return resolve(classOutDir, "index.js");
-}
-async function bundleAllDOs(discovered, outDir, cwd, logger) {
-  const fs = await import("node:fs/promises");
-  const bundles = new Map;
-  const classes = new Map;
-  const sourceFiles = new Map;
-  const errors = [];
-  for (const do_ of discovered) {
-    const existing = sourceFiles.get(do_.filePath) || [];
-    existing.push(do_.className);
-    sourceFiles.set(do_.filePath, existing);
-  }
-  for (const do_ of discovered) {
-    try {
-      logger?.debug(`Bundling ${do_.className} from ${do_.filePath}`);
-      const outFile = await bundleDOFile(do_.filePath, do_.className, outDir, cwd);
-      bundles.set(do_.bindingName, outFile);
-      classes.set(do_.bindingName, do_.className);
-      logger?.debug(`  → ${outFile}`);
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      errors.push(err);
-      logger?.error(`Failed to bundle ${do_.className}:`, err.message);
-    }
-  }
-  return { bundles, classes, sourceFiles, errors };
-}
-function createDOBundler(options) {
-  const { cwd, pattern, outDir, logger, onRebuild } = options;
-  let result = {
-    bundles: new Map,
-    classes: new Map,
-    sourceFiles: new Map,
-    errors: []
-  };
-  let watcher = null;
-  let chokidarWatcher = null;
-  async function build() {
-    const discovered = await discoverDOs(cwd, pattern);
-    if (discovered.length === 0) {
-      logger?.debug("No DOs found matching pattern:", pattern);
-      return result;
-    }
-    logger?.info(`Found ${discovered.length} Durable Object(s)`);
-    for (const do_ of discovered) {
-      logger?.info(`  • ${do_.className} → ${do_.bindingName}`);
-    }
-    result = await bundleAllDOs(discovered, outDir, cwd, logger);
-    if (result.errors.length === 0) {
-      logger?.success(`Bundled ${result.bundles.size} DO(s) to ${outDir}`);
-    }
-    return result;
-  }
-  async function watch() {
-    const chokidar = await import("chokidar");
-    const files = await findFiles(pattern, { cwd });
-    let dirsToWatch;
-    if (files.length > 0) {
-      dirsToWatch = [...new Set(files.map((f) => dirname(f)))];
-    } else {
-      const patternDir = dirname(pattern);
-      const absolutePatternDir = resolve(cwd, patternDir === "." ? "" : patternDir) || cwd;
-      dirsToWatch = [absolutePatternDir];
-      logger?.debug(`No DO files yet, watching pattern directory: ${absolutePatternDir}`);
-    }
-    logger?.info(`Watching ${files.length} DO file(s) in ${dirsToWatch.length} director(ies)...`);
-    const isWindows = process.platform === "win32";
-    chokidarWatcher = chokidar.watch(dirsToWatch, {
-      ignoreInitial: true,
-      usePolling: isWindows,
-      interval: isWindows ? 300 : undefined,
-      awaitWriteFinish: {
-        stabilityThreshold: 100,
-        pollInterval: 50
-      },
-      depth: 0
-    });
-    const normalizePath = (p) => {
-      let normalized = p.replace(/\\/g, "/");
-      if (isWindows && /^[a-zA-Z]:/.test(normalized)) {
-        normalized = normalized[0].toLowerCase() + normalized.slice(1);
-      }
-      return normalized;
-    };
-    const isMatch = picomatch(pattern, {
-      cwd,
-      dot: true,
-      matchBase: false
-    });
-    const matchesPattern = (filePath) => {
-      const normalizedPath = normalizePath(filePath);
-      const relativePath = relative(normalizePath(cwd), normalizedPath);
-      return isMatch(relativePath);
-    };
-    let isRebuilding = false;
-    let pendingRebuild = null;
-    let rebuildTimeout = null;
-    const scheduleRebuild = (changedPath) => {
-      if (rebuildTimeout) {
-        clearTimeout(rebuildTimeout);
-      }
-      rebuildTimeout = setTimeout(() => {
-        triggerRebuild(changedPath);
-      }, 150);
-    };
-    const triggerRebuild = async (changedPath) => {
-      if (isRebuilding) {
-        pendingRebuild = changedPath;
-        logger?.debug(`Rebuild already in progress, queuing: ${changedPath}`);
-        return;
-      }
-      isRebuilding = true;
-      try {
-        logger?.info(`DO file changed: ${changedPath}`);
-        logger?.info("Rebuilding DOs...");
-        const startTime = Date.now();
-        result = await build();
-        const elapsed = Date.now() - startTime;
-        logger?.success(`DO rebuild complete (${elapsed}ms)`);
-        await onRebuild?.(result);
-      } catch (error) {
-        logger?.error("DO rebuild failed:", error);
-      } finally {
-        isRebuilding = false;
-        if (pendingRebuild) {
-          const nextPath = pendingRebuild;
-          pendingRebuild = null;
-          triggerRebuild(nextPath);
-        }
-      }
-    };
-    chokidarWatcher.on("change", (filePath) => {
-      if (matchesPattern(filePath)) {
-        logger?.debug(`File changed: ${filePath}`);
-        scheduleRebuild(filePath);
-      }
-    });
-    chokidarWatcher.on("add", (filePath) => {
-      if (matchesPattern(filePath)) {
-        logger?.debug(`File added: ${filePath}`);
-        scheduleRebuild(filePath);
-      }
-    });
-    chokidarWatcher.on("unlink", (filePath) => {
-      if (matchesPattern(filePath)) {
-        logger?.debug(`File removed: ${filePath}`);
-        scheduleRebuild(filePath);
-      }
-    });
-    chokidarWatcher.on("ready", () => {
-      logger?.info("DO file watcher ready");
-    });
-    chokidarWatcher.on("error", (error) => {
-      logger?.error("DO file watcher error:", error);
-    });
-  }
-  async function close() {
-    if (watcher) {
-      await watcher.close();
-      watcher = null;
-    }
-    if (chokidarWatcher) {
-      await chokidarWatcher.close();
-      chokidarWatcher = null;
-    }
-  }
-  function getResult() {
-    return result;
-  }
-  return {
-    build,
-    watch,
-    close,
-    getResult
-  };
-}
-// src/browser-shim/server.ts
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { existsSync } from "node:fs";
-import { createServer } from "node:http";
-import puppeteerCore from "puppeteer-core";
-import {
-  install,
-  resolveBuildId,
-  detectBrowserPlatform,
-  Browser as BrowserType
-} from "@puppeteer/browsers";
-var sessions = new Map;
-var history = [];
-var cachedExecutablePath = null;
-async function ensureChrome(cacheDir, logger) {
-  if (cachedExecutablePath && existsSync(cachedExecutablePath)) {
-    return cachedExecutablePath;
-  }
-  const platform = detectBrowserPlatform();
-  if (!platform) {
-    throw new Error("Could not detect browser platform");
-  }
-  const buildId = await resolveBuildId(BrowserType.CHROMEHEADLESSSHELL, platform, "stable");
-  logger?.debug(`[BrowserShim] Resolved Chrome Headless Shell build: ${buildId}`);
-  const installedBrowser = await install({
-    browser: BrowserType.CHROMEHEADLESSSHELL,
-    buildId,
-    cacheDir,
-    downloadProgressCallback: (downloadedBytes, totalBytes) => {
-      if (totalBytes > 0) {
-        const percent = Math.round(downloadedBytes / totalBytes * 100);
-        if (percent % 20 === 0) {
-          logger?.info(`[BrowserShim] Downloading Chrome... ${percent}%`);
-        }
-      }
-    }
-  });
-  cachedExecutablePath = installedBrowser.executablePath;
-  logger?.success(`[BrowserShim] Chrome ready: ${installedBrowser.executablePath}`);
-  return installedBrowser.executablePath;
-}
-function createBrowserShim(options = {}) {
-  const {
-    port = 8788,
-    host = "127.0.0.1",
-    logger,
-    verbose = false,
-    keepAlive = 60000,
-    cacheDir = join(homedir(), ".devflare", "chrome")
-  } = options;
-  let server = null;
-  let executablePath = null;
-  let WebSocketServerClass = null;
-  let WebSocketClass = null;
-  async function acquireSession(acquireOptions) {
-    if (!executablePath) {
-      throw new Error("Chrome not initialized");
-    }
-    const browser = await puppeteerCore.launch({
-      executablePath,
-      headless: true,
-      protocolTimeout: 120000,
-      args: [
-        "--no-sandbox",
-        "--disable-setuid-sandbox",
-        "--disable-dev-shm-usage",
-        "--disable-gpu",
-        "--disable-software-rasterizer",
-        "--disable-extensions",
-        "--disable-background-networking",
-        "--disable-background-timer-throttling",
-        "--disable-backgrounding-occluded-windows",
-        "--disable-renderer-backgrounding",
-        "--disable-features=TranslateUI",
-        "--disable-ipc-flooding-protection",
-        "--disable-default-apps",
-        "--mute-audio",
-        "--js-flags=--max-old-space-size=4096"
-      ]
-    });
-    const wsEndpoint = browser.wsEndpoint();
-    const sessionId = crypto.randomUUID();
-    const session = {
-      sessionId,
-      browser,
-      wsEndpoint,
-      startTime: Date.now()
-    };
-    sessions.set(sessionId, session);
-    const timeout = acquireOptions?.keep_alive ?? keepAlive;
-    if (timeout > 0) {
-      session.idleTimeout = setTimeout(async () => {
-        const s = sessions.get(sessionId);
-        if (s && !s.connectionId) {
-          await closeSession(sessionId, 2, "BrowserIdle");
-        }
-      }, timeout);
-    }
-    if (verbose) {
-      logger?.debug(`[BrowserShim] Acquired session ${sessionId}`);
-    }
-    return { sessionId };
-  }
-  async function closeSession(sessionId, closeReason = 1, closeReasonText = "NormalClosure") {
-    const session = sessions.get(sessionId);
-    if (!session)
-      return;
-    if (session.idleTimeout) {
-      clearTimeout(session.idleTimeout);
-    }
-    try {
-      await session.browser.close();
-    } catch {}
-    sessions.delete(sessionId);
-    history.unshift({
-      sessionId,
-      startTime: session.startTime,
-      endTime: Date.now(),
-      closeReason,
-      closeReasonText
-    });
-    if (history.length > 100) {
-      history.pop();
-    }
-    if (verbose) {
-      logger?.debug(`[BrowserShim] Closed session ${sessionId}: ${closeReasonText}`);
-    }
-  }
-  async function handleRequest(req, res) {
-    const url = new URL(req.url || "/", `http://${host}:${port}`);
-    const method = req.method || "GET";
-    logger?.debug(`[BrowserShim] ${method} ${url.pathname}${url.search ? url.search : ""}`);
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-    if (method === "OPTIONS") {
-      res.writeHead(204);
-      res.end();
-      return;
-    }
-    if (url.pathname === "/v1/acquire" && (method === "POST" || method === "GET")) {
-      try {
-        let acquireOptions = {};
-        if (method === "GET") {
-          const keepAlive2 = url.searchParams.get("keep_alive");
-          if (keepAlive2) {
-            acquireOptions.keep_alive = parseInt(keepAlive2, 10);
-          }
-        } else {
-          try {
-            const body = await readBody(req);
-            acquireOptions = JSON.parse(body);
-          } catch {}
-        }
-        const result = await acquireSession(acquireOptions);
-        sendJson(res, 200, result);
-      } catch (error) {
-        const msg = error instanceof Error ? error.message : "Failed to acquire browser";
-        logger?.error(`[BrowserShim] Acquire failed: ${msg}`);
-        sendJson(res, 500, { error: msg });
-      }
-      return;
-    }
-    if (url.pathname === "/v1/sessions" && method === "GET") {
-      const activeSessions = Array.from(sessions.values()).map((s) => ({
-        sessionId: s.sessionId,
-        startTime: s.startTime,
-        connectionId: s.connectionId,
-        connectionStartTime: s.connectionStartTime
-      }));
-      sendJson(res, 200, activeSessions);
-      return;
-    }
-    if (url.pathname === "/v1/history" && method === "GET") {
-      sendJson(res, 200, history.slice(0, 50));
-      return;
-    }
-    if (url.pathname === "/v1/limits" && method === "GET") {
-      sendJson(res, 200, {
-        activeSessions: Array.from(sessions.keys()).map((id) => ({ id })),
-        allowedBrowserAcquisitions: 10,
-        maxConcurrentSessions: 10,
-        timeUntilNextAllowedBrowserAcquisition: 0
-      });
-      return;
-    }
-    if (url.pathname.startsWith("/v1/session/") && method === "GET") {
-      const sessionId = url.pathname.slice("/v1/session/".length);
-      const session = sessions.get(sessionId);
-      if (!session) {
-        sendJson(res, 404, { error: "Session not found" });
-        return;
-      }
-      sendJson(res, 200, {
-        sessionId: session.sessionId,
-        wsEndpoint: session.wsEndpoint,
-        startTime: session.startTime,
-        connectionId: session.connectionId,
-        connectionStartTime: session.connectionStartTime
-      });
-      return;
-    }
-    if (url.pathname === "/_devflare/browser/health") {
-      sendJson(res, 200, {
-        ok: true,
-        activeSessions: sessions.size,
-        historySize: history.length,
-        executablePath
-      });
-      return;
-    }
-    if (url.pathname === "/v1/connectDevtools") {
-      res.writeHead(426, { "Content-Type": "text/plain" });
-      res.end("WebSocket upgrade required");
-      return;
-    }
-    res.writeHead(404, { "Content-Type": "text/plain" });
-    res.end("Not found");
-  }
-  function readBody(req) {
-    return new Promise((resolve2, reject) => {
-      const chunks = [];
-      req.on("data", (chunk) => chunks.push(chunk));
-      req.on("end", () => resolve2(Buffer.concat(chunks).toString()));
-      req.on("error", reject);
-    });
-  }
-  function sendJson(res, status, data) {
-    const body = JSON.stringify(data);
-    res.writeHead(status, {
-      "Content-Type": "application/json",
-      "Content-Length": Buffer.byteLength(body)
-    });
-    res.end(body);
-  }
-  async function start() {
-    logger?.info("[BrowserShim] Ensuring Chrome Headless Shell is available...");
-    executablePath = await ensureChrome(cacheDir, logger);
-    try {
-      const wsModule = await import("ws");
-      WebSocketServerClass = wsModule.WebSocketServer || wsModule.default?.WebSocketServer;
-      WebSocketClass = wsModule.WebSocket || wsModule.default?.WebSocket || wsModule.default;
-    } catch {
-      logger?.warn("[BrowserShim] ws package not found, WebSocket proxy disabled");
-      logger?.warn("[BrowserShim] Install with: npm install ws");
-    }
-    server = createServer((req, res) => {
-      handleRequest(req, res).catch((error) => {
-        logger?.error("[BrowserShim] Request error:", error);
-        res.writeHead(500);
-        res.end("Internal server error");
-      });
-    });
-    if (WebSocketServerClass) {
-      const wss = new WebSocketServerClass({ noServer: true });
-      server.on("upgrade", (request, socket, head) => {
-        const url = new URL(request.url || "/", `http://${host}:${port}`);
-        if (url.pathname !== "/v1/connectDevtools") {
-          socket.destroy();
-          return;
-        }
-        const sessionId = url.searchParams.get("browser_session");
-        if (!sessionId) {
-          socket.write(`HTTP/1.1 400 Bad Request\r
-\r
-`);
-          socket.destroy();
-          return;
-        }
-        const session = sessions.get(sessionId);
-        if (!session) {
-          socket.write(`HTTP/1.1 404 Not Found\r
-\r
-`);
-          socket.destroy();
-          return;
-        }
-        const connectionId = crypto.randomUUID();
-        session.connectionId = connectionId;
-        session.connectionStartTime = Date.now();
-        if (session.idleTimeout) {
-          clearTimeout(session.idleTimeout);
-          session.idleTimeout = undefined;
-        }
-        wss.handleUpgrade(request, socket, head, (ws) => {
-          if (verbose) {
-            logger?.debug(`[BrowserShim] WebSocket connected for session ${sessionId}`);
-          }
-          const chromeWs = new WebSocketClass(session.wsEndpoint);
-          let chromeConnected = false;
-          const connectTimeout = setTimeout(() => {
-            if (!chromeConnected) {
-              logger?.error("[BrowserShim] Chrome connection timeout");
-              try {
-                ws.close(1011, "Chrome connection timeout");
-                chromeWs.close();
-              } catch {}
-              closeSession(sessionId, 5, "ChromeConnectionTimeout").catch(() => {});
-            }
-          }, 1e4);
-          chromeWs.on("open", () => {
-            chromeConnected = true;
-            clearTimeout(connectTimeout);
-            if (verbose) {
-              logger?.debug("[BrowserShim] Connected to Chrome DevTools");
-            }
-          });
-          chromeWs.on("message", (data) => {
-            if (ws.readyState === 1) {
-              ws.send(data);
-            }
-          });
-          chromeWs.on("close", (code, reason) => {
-            if (verbose) {
-              logger?.debug(`[BrowserShim] Chrome WS closed: ${code}`);
-            }
-            const validCode = typeof code === "number" && code >= 1000 && code <= 4999 ? code : 1000;
-            try {
-              ws.close(validCode, reason?.toString?.() || "");
-            } catch {}
-            closeSession(sessionId, 2, "ChromeDisconnected").catch((err) => {
-              logger?.error("[BrowserShim] Error closing session after Chrome disconnect:", err);
-            });
-          });
-          chromeWs.on("error", (error) => {
-            logger?.error("[BrowserShim] Chrome WS error:", error.message);
-            try {
-              ws.close(1011, "Chrome WebSocket error");
-            } catch {}
-            closeSession(sessionId, 4, "ChromeError").catch((err) => {
-              logger?.error("[BrowserShim] Error closing session after Chrome error:", err);
-            });
-          });
-          ws.on("message", (data) => {
-            if (chromeWs.readyState === 1) {
-              chromeWs.send(data);
-            }
-          });
-          ws.on("close", (code, reason) => {
-            if (verbose) {
-              logger?.debug(`[BrowserShim] Client WS closed for session ${sessionId}`);
-            }
-            const validCode = typeof code === "number" && code >= 1000 && code <= 4999 ? code : 1000;
-            try {
-              chromeWs.close(validCode, reason?.toString?.() || "");
-            } catch {}
-            const s = sessions.get(sessionId);
-            if (s && s.connectionId === connectionId) {
-              s.connectionId = undefined;
-              s.connectionStartTime = undefined;
-              closeSession(sessionId, 1, "ClientDisconnected").catch((err) => {
-                logger?.error("[BrowserShim] Error closing session after disconnect:", err);
-              });
-            }
-          });
-          ws.on("error", (error) => {
-            logger?.error("[BrowserShim] Client WS error:", error.message);
-            try {
-              chromeWs.close();
-            } catch {}
-          });
-        });
-      });
-    }
-    await new Promise((resolve2, reject) => {
-      server.on("error", reject);
-      server.listen(port, host, () => {
-        resolve2();
-      });
-    });
-    logger?.success(`Browser shim server ready on http://${host}:${port}`);
-  }
-  async function stop() {
-    for (const sessionId of sessions.keys()) {
-      await closeSession(sessionId, 3, "ServerShutdown");
-    }
-    if (server) {
-      await new Promise((resolve2) => {
-        server.close(() => resolve2());
-      });
-      server = null;
-    }
-    logger?.info("Browser shim server stopped");
-  }
-  function getUrl() {
-    return `http://${host}:${port}`;
-  }
-  return {
-    start,
-    stop,
-    getUrl
-  };
-}
-// src/browser-shim/binding-worker.ts
-var MAX_CHUNK_SIZE = 1048575;
-function getBrowserBindingScript(browserShimUrl, debug = false) {
-  const safeUrl = JSON.stringify(browserShimUrl);
-  return `
-// Browser Binding Worker — Proxies puppeteer requests to external browser shim
-// Handles WebSocket upgrades using WebSocketPair for @cloudflare/puppeteer compatibility
-
-const BROWSER_SHIM_URL = ${safeUrl}
-const MAX_CHUNK_SIZE = ${MAX_CHUNK_SIZE}
-const DEBUG = ${debug}
-const log = (...args) => DEBUG && console.log('[BrowserBinding]', ...args)
-
-export default {
-	async fetch(request, env, ctx) {
-		const url = new URL(request.url)
-		const upgradeHeader = request.headers.get('Upgrade')
-		const isWebSocket = upgradeHeader && upgradeHeader.toLowerCase() === 'websocket'
-		
-		log('Request:', url.pathname, isWebSocket ? '(WebSocket)' : '(HTTP)')
-
-		// Handle WebSocket upgrade for DevTools connection
-		if (url.pathname === '/v1/connectDevtools' && isWebSocket) {
-			return handleDevToolsWebSocket(request, url)
-		}
-
-		// Proxy all other requests to the browser shim server
-		return proxyToBrowserShim(request, url)
-	}
-}
-
-// Proxy HTTP requests to the external browser shim server
-async function proxyToBrowserShim(request, url) {
-	const shimUrl = new URL(url.pathname + url.search, BROWSER_SHIM_URL)
-	
-	log('Proxying to:', shimUrl.toString())
-	
-	const response = await fetch(shimUrl.toString(), {
-		method: request.method,
-		headers: request.headers,
-		body: request.method !== 'GET' && request.method !== 'HEAD' ? request.body : undefined
-	})
-	
-	log('Response:', response.status)
-	
-	// Return the response as-is
-	return new Response(response.body, {
-		status: response.status,
-		statusText: response.statusText,
-		headers: response.headers
-	})
-}
-
-// Validate WebSocket close code to be in valid range
-function validateCloseCode(code) {
-	if (typeof code !== 'number' || isNaN(code)) return 1000
-	if (code < 1000 || code > 4999) return 1000
-	return code
-}
-
-// Split a message into chunks following @cloudflare/puppeteer protocol
-// First chunk has 4-byte LE length header, subsequent chunks are raw payload
-function messageToChunks(message) {
-	const data = typeof message === 'string'
-		? new TextEncoder().encode(message)
-		: new Uint8Array(message)
-	
-	const chunks = []
-	const totalLength = data.length
-	let offset = 0
-	let isFirst = true
-	
-	while (offset < totalLength) {
-		const remaining = totalLength - offset
-		let chunkSize
-		
-		if (isFirst) {
-			// First chunk: 4-byte header + payload
-			chunkSize = Math.min(remaining, MAX_CHUNK_SIZE - 4)
-			const chunk = new Uint8Array(chunkSize + 4)
-			new DataView(chunk.buffer).setUint32(0, totalLength, true) // little-endian
-			chunk.set(data.subarray(offset, offset + chunkSize), 4)
-			chunks.push(chunk)
-			isFirst = false
-		} else {
-			// Subsequent chunks: raw payload only
-			chunkSize = Math.min(remaining, MAX_CHUNK_SIZE)
-			const chunk = data.subarray(offset, offset + chunkSize)
-			chunks.push(chunk)
-		}
-		
-		offset += chunkSize
-	}
-	
-	return chunks
-}
-
-// Reassemble chunks back into a complete message
-// Returns null if more chunks are needed
-function chunksToMessage(chunks) {
-	if (chunks.length === 0) return null
-	
-	// First chunk must have 4-byte header
-	const firstChunk = chunks[0]
-	if (firstChunk.length < 4) return null
-	
-	const expectedLength = new DataView(firstChunk.buffer, firstChunk.byteOffset).getUint32(0, true)
-	
-	// Calculate total received payload
-	let totalReceived = firstChunk.length - 4 // first chunk payload (minus header)
-	for (let i = 1; i < chunks.length; i++) {
-		totalReceived += chunks[i].length
-	}
-	
-	if (totalReceived < expectedLength) {
-		return null // Need more chunks
-	}
-	
-	// Reassemble the message
-	const assembled = new Uint8Array(expectedLength)
-	let offset = 0
-	
-	// Copy first chunk payload (skip 4-byte header)
-	const firstPayload = firstChunk.subarray(4)
-	assembled.set(firstPayload, offset)
-	offset += firstPayload.length
-	
-	// Copy remaining chunks
-	for (let i = 1; i < chunks.length; i++) {
-		const chunk = chunks[i]
-		const toCopy = Math.min(chunk.length, expectedLength - offset)
-		assembled.set(chunk.subarray(0, toCopy), offset)
-		offset += toCopy
-	}
-	
-	return new TextDecoder().decode(assembled)
-}
-
-// Handle WebSocket upgrade for DevTools connection
-// Creates a WebSocketPair and proxies to Chrome's DevTools WebSocket
-async function handleDevToolsWebSocket(request, url) {
-	const sessionId = url.searchParams.get('browser_session')
-	if (!sessionId) {
-		return new Response('browser_session parameter required', { status: 400 })
-	}
-	
-	log('DevTools WebSocket request for session:', sessionId)
-	
-	// Get session info from browser shim (includes Chrome's wsEndpoint)
-	const sessionUrl = new URL('/v1/session/' + sessionId, BROWSER_SHIM_URL)
-	
-	// Add timeout for session fetch
-	const controller = new AbortController()
-	const timeout = setTimeout(() => controller.abort(), 5000)
-	
-	let sessionRes
-	try {
-		sessionRes = await fetch(sessionUrl.toString(), { signal: controller.signal })
-	} catch (e) {
-		DEBUG && console.error('[BrowserBinding] Session fetch timeout or error:', e.message)
-		return new Response('Session fetch timeout', { status: 504 })
-	} finally {
-		clearTimeout(timeout)
-	}
-	
-	if (!sessionRes.ok) {
-		DEBUG && console.error('[BrowserBinding] Session not found:', sessionId)
-		return new Response('Session not found', { status: 404 })
-	}
-	
-	const sessionInfo = await sessionRes.json()
-	const wsEndpoint = sessionInfo.wsEndpoint
-	
-	if (!wsEndpoint) {
-		DEBUG && console.error('[BrowserBinding] No wsEndpoint in session info')
-		return new Response('No wsEndpoint for session', { status: 500 })
-	}
-	
-	log('Connecting to Chrome DevTools:', wsEndpoint)
-	
-	// Connect to Chrome's DevTools WebSocket
-	// Chrome uses ws:// but fetch expects http:// for WebSocket upgrade
-	const chromeUrl = wsEndpoint.replace('ws://', 'http://').replace('wss://', 'https://')
-	
-	const chromeRes = await fetch(chromeUrl, {
-		headers: { Upgrade: 'websocket' }
-	})
-	
-	if (!chromeRes.webSocket) {
-		DEBUG && console.error('[BrowserBinding] Failed to connect to Chrome DevTools')
-		return new Response('Failed to connect to Chrome DevTools', { status: 502 })
-	}
-	
-	const chromeWs = chromeRes.webSocket
-	chromeWs.accept()
-	
-	log('Connected to Chrome DevTools')
-	
-	// Create WebSocketPair for client connection
-	const { 0: client, 1: server } = new WebSocketPair()
-	server.accept()
-	
-	// Chunk buffer for reassembling multi-chunk messages from puppeteer
-	let chunks = []
-	const MAX_BUFFER_SIZE = 50 * 1024 * 1024 // 50MB max buffer
-	let bufferSize = 0
-	
-	// Proxy messages from client (puppeteer) to Chrome
-	// Handle multi-chunk framing protocol
-	server.addEventListener('message', (event) => {
-		// Keep-alive ping from puppeteer
-		if (event.data === 'ping') {
-			return
-		}
-		
-		// Handle binary data (chunked protocol)
-		if (event.data instanceof ArrayBuffer) {
-			const chunk = new Uint8Array(event.data)
-			bufferSize += chunk.length
-			
-			// Prevent unbounded buffering
-			if (bufferSize > MAX_BUFFER_SIZE) {
-				DEBUG && console.error('[BrowserBinding] Buffer overflow, closing connection')
-				server.close(1009, 'Message too big')
-				chromeWs.close(1009, 'Message too big')
-				return
-			}
-			
-			chunks.push(chunk)
-			
-			// Try to reassemble complete message
-			const message = chunksToMessage(chunks)
-			if (message !== null) {
-				// Send complete message to Chrome
-				if (chromeWs.readyState === 1) { // OPEN
-					chromeWs.send(message)
-				}
-				// Clear buffer
-				chunks = []
-				bufferSize = 0
-			}
-		} else if (typeof event.data === 'string') {
-			// Shouldn't happen in normal protocol, but handle it
-			if (chromeWs.readyState === 1) {
-				chromeWs.send(event.data)
-			}
-		}
-	})
-	
-	// Proxy messages from Chrome to client (puppeteer)
-	// Split into chunks following the multi-chunk protocol
-	chromeWs.addEventListener('message', (event) => {
-		if (server.readyState !== 1) return // Not OPEN
-		
-		// Split message into chunks
-		const outChunks = messageToChunks(event.data)
-		for (const chunk of outChunks) {
-			server.send(chunk)
-		}
-	})
-	
-	// Handle close events with validated codes
-	server.addEventListener('close', (event) => {
-		log('Client WebSocket closed:', event.code)
-		const code = validateCloseCode(event.code)
-		try {
-			if (chromeWs.readyState === 1 || chromeWs.readyState === 0) {
-				chromeWs.close(code, event.reason || '')
-			}
-		} catch {}
-	})
-	
-	chromeWs.addEventListener('close', (event) => {
-		log('Chrome WebSocket closed:', event.code)
-		const code = validateCloseCode(event.code)
-		try {
-			if (server.readyState === 1 || server.readyState === 0) {
-				server.close(code, event.reason || '')
-			}
-		} catch {}
-	})
-	
-	// Handle errors
-	server.addEventListener('error', (event) => {
-		DEBUG && console.error('[BrowserBinding] Client WebSocket error')
-		try { chromeWs.close(1011, 'Client error') } catch {}
-	})
-	
-	chromeWs.addEventListener('error', (event) => {
-		DEBUG && console.error('[BrowserBinding] Chrome WebSocket error')
-		try { server.close(1011, 'Chrome error') } catch {}
-	})
-	
-	log('WebSocket proxy established')
-	
-	// Return Cloudflare-style WebSocket response
-	return new Response(null, {
-		status: 101,
-		webSocket: client
-	})
-}
-`;
-}
-
-// src/cli/wrangler-auth.ts
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-var execAsync = promisify(exec);
-function detectRemoteBindings(config) {
-  const remoteBindings = [];
-  const bindings = config.bindings;
-  if (!bindings)
-    return remoteBindings;
-  if (bindings.ai) {
-    remoteBindings.push(`AI (binding: ${bindings.ai.binding})`);
-  }
-  if (bindings.vectorize) {
-    for (const [name] of Object.entries(bindings.vectorize)) {
-      remoteBindings.push(`Vectorize (binding: ${name})`);
-    }
-  }
-  return remoteBindings;
-}
-async function checkWranglerAuth() {
-  try {
-    const { stdout, stderr } = await execAsync("bunx wrangler whoami", {
-      timeout: 15000
-    });
-    const output = stdout + stderr;
-    if (output.includes("not authenticated") || output.includes("Not logged in") || output.includes("wrangler login")) {
-      return {
-        loggedIn: false,
-        error: "Not logged in to Wrangler"
-      };
-    }
-    const emailMatch = output.match(/email[:\s]+([^\s!]+)/i);
-    const accountMatch = output.match(/Account\s+ID[:\s]+([a-f0-9]+)/i);
-    return {
-      loggedIn: true,
-      email: emailMatch?.[1],
-      accountId: accountMatch?.[1]
-    };
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    if (msg.includes("ENOENT") || msg.includes("not found")) {
-      return {
-        loggedIn: false,
-        error: "Wrangler not installed. Run: npm install -g wrangler"
-      };
-    }
-    return {
-      loggedIn: false,
-      error: msg
-    };
-  }
-}
-async function checkRemoteBindingRequirements(config) {
-  const remoteBindings = detectRemoteBindings(config);
-  if (remoteBindings.length === 0) {
-    return {
-      hasRemoteBindings: false,
-      remoteBindings: [],
-      missingAccountId: false,
-      notLoggedIn: false
-    };
-  }
-  const missingAccountId = !config.accountId;
-  const authStatus = await checkWranglerAuth();
-  const notLoggedIn = !authStatus.loggedIn;
-  return {
-    hasRemoteBindings: true,
-    remoteBindings,
-    missingAccountId,
-    notLoggedIn
-  };
-}
-
-// src/dev-server/server.ts
-var DEFAULT_FETCH_ENTRY_FILES = [
-  "src/fetch.ts",
-  "src/fetch.js",
-  "src/fetch.mts",
-  "src/fetch.mjs"
-];
-var DEFAULT_QUEUE_ENTRY_FILES = [
-  "src/queue.ts",
-  "src/queue.js",
-  "src/queue.mts",
-  "src/queue.mjs"
-];
-var DEFAULT_SCHEDULED_ENTRY_FILES = [
-  "src/scheduled.ts",
-  "src/scheduled.js",
-  "src/scheduled.mts",
-  "src/scheduled.mjs"
-];
-var DEFAULT_EMAIL_ENTRY_FILES = [
-  "src/email.ts",
-  "src/email.js",
-  "src/email.mts",
-  "src/email.mjs"
-];
-var INTERNAL_APP_SERVICE_BINDING = "__DEVFLARE_APP";
-async function resolveWorkerHandlerPath(cwd, configuredPath, defaultEntries) {
-  if (configuredPath === false) {
-    return null;
-  }
-  const fs = await import("node:fs/promises");
-  const candidates = new Set;
-  if (typeof configuredPath === "string" && configuredPath) {
-    candidates.add(configuredPath);
-  }
-  for (const defaultEntry of defaultEntries) {
-    candidates.add(defaultEntry);
-  }
-  for (const candidate of candidates) {
-    const absolutePath = resolve2(cwd, candidate);
-    try {
-      await fs.access(absolutePath);
-      return absolutePath;
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-async function resolveMainWorkerSurfacePaths(cwd, config) {
-  return {
-    fetch: await resolveWorkerHandlerPath(cwd, config.files?.fetch, DEFAULT_FETCH_ENTRY_FILES),
-    queue: await resolveWorkerHandlerPath(cwd, config.files?.queue, DEFAULT_QUEUE_ENTRY_FILES),
-    scheduled: await resolveWorkerHandlerPath(cwd, config.files?.scheduled, DEFAULT_SCHEDULED_ENTRY_FILES),
-    email: await resolveWorkerHandlerPath(cwd, config.files?.email, DEFAULT_EMAIL_ENTRY_FILES)
-  };
-}
-function getFirstWorkerSurfacePath(surfacePaths) {
-  return surfacePaths.fetch ?? surfacePaths.queue ?? surfacePaths.scheduled ?? surfacePaths.email;
-}
-function hasWorkerSurfacePaths(surfacePaths) {
-  return Object.values(surfacePaths).some((surfacePath) => typeof surfacePath === "string" && surfacePath.length > 0);
-}
-function toImportSpecifier(fromFilePath, toFilePath) {
-  const specifier = relative2(dirname2(fromFilePath), toFilePath).replace(/\\/g, "/");
-  return specifier.startsWith(".") ? specifier : `./${specifier}`;
-}
-function getMainWorkerEntryScript(surfaceImportPaths) {
-  const importLines = [`import { runWithContext } from 'devflare/runtime'`];
-  const moduleFallbackLines = [];
-  const registerSurfaceModule = (identifier, importPath) => {
-    if (importPath) {
-      importLines.push(`import * as ${identifier} from '${importPath}'`);
-      return;
-    }
-    moduleFallbackLines.push(`const ${identifier} = {}`);
-  };
-  registerSurfaceModule("__devflareFetchModule", surfaceImportPaths.fetch);
-  registerSurfaceModule("__devflareQueueModule", surfaceImportPaths.queue);
-  registerSurfaceModule("__devflareScheduledModule", surfaceImportPaths.scheduled);
-  registerSurfaceModule("__devflareEmailModule", surfaceImportPaths.email);
-  return `
-${importLines.join(`
-`)}
-${moduleFallbackLines.join(`
-`)}
-
-const __devflareResolveHandler = (module, namedExport) => {
-	const defaultExport = module.default
-
-	if (typeof defaultExport === 'function') {
-		return defaultExport
-	}
-
-	if (defaultExport && typeof defaultExport[namedExport] === 'function') {
-		return defaultExport[namedExport].bind(defaultExport)
-	}
-
-	if (typeof module[namedExport] === 'function') {
-		return module[namedExport]
-	}
-
-	return null
-}
-
-const __devflareFetchHandler = __devflareResolveHandler(__devflareFetchModule, 'fetch')
-const __devflareQueueHandler = __devflareResolveHandler(__devflareQueueModule, 'queue')
-const __devflareScheduledHandler = __devflareResolveHandler(__devflareScheduledModule, 'scheduled')
-const __devflareEmailHandler = __devflareResolveHandler(__devflareEmailModule, 'email')
-
-function __devflareCreateEmailHeaders(rawBody) {
-	const headers = new Headers()
-	const lines = rawBody.split(/\\r?\\n/)
-
-	for (const line of lines) {
-		if (line.trim() === '') {
-			break
-		}
-
-		const colonIndex = line.indexOf(':')
-		if (colonIndex <= 0) {
-			continue
-		}
-
-		headers.append(line.slice(0, colonIndex).trim(), line.slice(colonIndex + 1).trim())
-	}
-
-	return headers
-}
-
-function __devflareCreateEmailRawStream(rawBody) {
-	return new ReadableStream({
-		start(controller) {
-			controller.enqueue(new TextEncoder().encode(rawBody))
-			controller.close()
-		}
-	})
-}
-
-async function __devflareHandleInternalEmail(request, env, ctx) {
-	if (!__devflareEmailHandler) {
-		return new Response('Email handler not configured', { status: 501 })
-	}
-
-	const from = request.headers.get('x-devflare-email-from') || 'unknown@example.com'
-	const to = request.headers.get('x-devflare-email-to') || 'worker@example.com'
-	const rawBody = await request.text()
-	const emailMessage = {
-		from,
-		to,
-		headers: __devflareCreateEmailHeaders(rawBody),
-		raw: __devflareCreateEmailRawStream(rawBody),
-		rawSize: rawBody.length,
-		setReject(reason) {
-			console.warn('[Devflare email rejected]', reason)
-		},
-		async forward(rcptTo) {
-			console.log('[Devflare email forwarded]', rcptTo)
-			return Promise.resolve()
-		},
-		async reply(message) {
-			console.log('[Devflare email reply sent]', message?.from)
-			return Promise.resolve()
-		}
-	}
-
-	await runWithContext(
-		env,
-		ctx,
-		null,
-		() => __devflareEmailHandler(emailMessage, env, ctx),
-		'email'
-	)
-
-	return new Response(JSON.stringify({ ok: true, from, to }), {
-		headers: { 'Content-Type': 'application/json' }
-	})
-}
-
-export default {
-	async fetch(request, env, ctx) {
-		const url = new URL(request.url)
-
-		if (
-			request.headers.get('x-devflare-event') === 'email' &&
-			url.pathname === '/_devflare/internal/email'
-		) {
-			return __devflareHandleInternalEmail(request, env, ctx)
-		}
-
-		if (!__devflareFetchHandler) {
-			return new Response('Fetch handler not configured', { status: 404 })
-		}
-
-		return runWithContext(
-			env,
-			ctx,
-			request,
-			() => __devflareFetchHandler(request, env, ctx),
-			'fetch'
-		)
-	},
-	...(__devflareQueueHandler
-		? {
-			async queue(batch, env, ctx) {
-				return runWithContext(
-					env,
-					ctx,
-					null,
-					() => __devflareQueueHandler(batch, env, ctx),
-					'queue'
-				)
-			}
-		}
-		: {}),
-	...(__devflareScheduledHandler
-		? {
-			async scheduled(controller, env, ctx) {
-				return runWithContext(
-					env,
-					ctx,
-					null,
-					() => __devflareScheduledHandler(controller, env, ctx),
-					'scheduled'
-				)
-			}
-		}
-		: {}),
-	...(__devflareEmailHandler
-		? {
-			async email(message, env, ctx) {
-				return runWithContext(
-					env,
-					ctx,
-					null,
-					() => __devflareEmailHandler(message, env, ctx),
-					'email'
-				)
-			}
-		}
-		: {})
-}
-`;
-}
-function addWorkerWatchRoots(roots, cwd, configuredPath, defaultEntries) {
-  if (configuredPath === false) {
-    return;
-  }
-  if (typeof configuredPath === "string" && configuredPath) {
-    roots.add(dirname2(resolve2(cwd, configuredPath)));
-    return;
-  }
-  for (const defaultEntry of defaultEntries) {
-    roots.add(dirname2(resolve2(cwd, defaultEntry)));
-  }
-}
-function collectWorkerWatchRoots(cwd, config, mainWorkerSurfacePaths) {
-  const roots = new Set;
-  const addFileParent = (filePath) => {
-    if (typeof filePath !== "string" || !filePath) {
-      return;
-    }
-    roots.add(dirname2(resolve2(cwd, filePath)));
-  };
-  for (const surfacePath of Object.values(mainWorkerSurfacePaths)) {
-    if (surfacePath) {
-      roots.add(dirname2(surfacePath));
-    }
-  }
-  addWorkerWatchRoots(roots, cwd, config.files?.fetch, DEFAULT_FETCH_ENTRY_FILES);
-  addWorkerWatchRoots(roots, cwd, config.files?.queue, DEFAULT_QUEUE_ENTRY_FILES);
-  addWorkerWatchRoots(roots, cwd, config.files?.scheduled, DEFAULT_SCHEDULED_ENTRY_FILES);
-  addWorkerWatchRoots(roots, cwd, config.files?.email, DEFAULT_EMAIL_ENTRY_FILES);
-  addFileParent(config.files?.transport);
-  if (config.files?.routes && typeof config.files.routes === "object") {
-    roots.add(resolve2(cwd, config.files.routes.dir));
-  }
-  return [...roots];
-}
-function getGatewayScript(wsRoutes = [], debug = false, appServiceBindingName = null) {
-  const wsRoutesJson = JSON.stringify(wsRoutes);
-  const appServiceBindingJson = JSON.stringify(appServiceBindingName);
-  return `
-// Bridge Gateway Worker — RPC Handler
-// Handles all binding operations via WebSocket RPC
-// Also handles WebSocket proxying to Durable Objects
-
-const DEBUG = ${debug}
-const log = (...args) => DEBUG && console.log('[Gateway]', ...args)
-
-const activeStreams = new Map()
-const wsProxies = new Map()
-const incomingStreams = new Map()
-
-// WebSocket routes configuration (injected at build time)
-const WS_ROUTES = ${wsRoutesJson}
-const APP_SERVICE_BINDING = ${appServiceBindingJson}
-
-export default {
-	async fetch(request, env, ctx) {
-		const url = new URL(request.url)
-		const isWebSocket = request.headers.get('Upgrade') === 'websocket'
-
-		// Check if this is a WebSocket request matching a DO route
-		if (isWebSocket) {
-			const matchedRoute = matchWsRoute(url.pathname)
-			if (matchedRoute) {
-				return handleDoWebSocket(request, env, url, matchedRoute)
-			}
-			// Otherwise handle as bridge RPC WebSocket
-			return handleBridgeWebSocket(request, env, ctx)
-		}
-
-		// HTTP endpoint for large file transfers
-		if (url.pathname.startsWith('/_devflare/transfer/')) {
-			return handleHttpTransfer(request, env, url)
-		}
-
-		// D1 migration endpoint
-		if (url.pathname === '/_devflare/migrate' && request.method === 'POST') {
-			return handleMigration(request, env)
-		}
-
-		// Email handler endpoint (simulates incoming email)
-		if (url.pathname === '/cdn-cgi/handler/email' && request.method === 'POST') {
-			return handleEmailIncoming(request, env, ctx, url)
-		}
-
-		// Health check
-		if (url.pathname === '/_devflare/health') {
-			return new Response(JSON.stringify({
-				ok: true,
-				bindings: Object.keys(env),
-				wsRoutes: WS_ROUTES
-			}), { headers: { 'Content-Type': 'application/json' } })
-		}
-
-		if (APP_SERVICE_BINDING) {
-			const appWorker = env[APP_SERVICE_BINDING]
-			if (appWorker && typeof appWorker.fetch === 'function') {
-				return appWorker.fetch(request)
-			}
-		}
-
-		return new Response('Devflare Bridge Gateway', { status: 200 })
-	}
-}
-
-// Handle D1 migrations
-async function handleMigration(request, env) {
-	try {
-		const { bindingName, statements } = await request.json()
-		log('Migration request for binding:', bindingName, 'statements count:', statements?.length, 'bindings:', Object.keys(env))
-		const db = env[bindingName]
-		if (!db) {
-			return Response.json({ error: 'Binding not found: ' + bindingName }, { status: 404 })
-		}
-
-		const results = []
-		for (const sql of statements) {
-			try {
-				log('Running migration SQL:', sql.slice(0, 80))
-				await db.prepare(sql).run()
-				results.push({ sql: sql.slice(0, 50), success: true })
-				log('Migration SQL succeeded')
-			} catch (error) {
-				const msg = error?.message || String(error)
-				log('Migration SQL error:', msg)
-				if (msg.includes('already exists')) {
-					results.push({ sql: sql.slice(0, 50), success: true, skipped: true })
-				} else {
-					results.push({ sql: sql.slice(0, 50), success: false, error: msg })
-				}
-			}
-		}
-		
-		// Verify table exists after migration
-		try {
-			const tables = await db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all()
-			log('Tables after migration:', JSON.stringify(tables))
-		} catch (e) {
-			log('Error listing tables:', e.message)
-		}
-		
-		return Response.json({ success: true, results })
-	} catch (error) {
-		return Response.json({ error: error?.message || String(error) }, { status: 500 })
-	}
-}
-
-// Handle incoming email (simulates email() handler)
-async function handleEmailIncoming(request, env, ctx, url) {
-	try {
-		const from = url.searchParams.get('from') || 'unknown@example.com'
-		const to = url.searchParams.get('to') || 'worker@example.com'
-		const rawBody = await request.text()
-		
-		log('Email incoming:', { from, to, bodyLength: rawBody.length })
-
-		if (APP_SERVICE_BINDING) {
-			const appWorker = env[APP_SERVICE_BINDING]
-			if (appWorker && typeof appWorker.fetch === 'function') {
-				const response = await appWorker.fetch(new Request('http://devflare.internal/_devflare/internal/email', {
-					method: 'POST',
-					headers: {
-						'x-devflare-event': 'email',
-						'x-devflare-email-from': from,
-						'x-devflare-email-to': to,
-						'content-type': request.headers.get('content-type') || 'text/plain'
-					},
-					body: rawBody
-				}))
-
-				if (!response.ok) {
-					return response
-				}
-			}
-		}
-		
-		return new Response(JSON.stringify({ ok: true, from, to }), {
-			headers: { 'Content-Type': 'application/json' }
-		})
-	} catch (error) {
-		console.error('[Gateway] Email handler error:', error)
-		return Response.json({ error: error?.message || String(error) }, { status: 500 })
-	}
-}
-
-// Match URL path against configured WS routes
-function matchWsRoute(pathname) {
-	for (const route of WS_ROUTES) {
-		// Simple exact match for now (could add glob/regex later)
-		if (pathname === route.pattern || pathname.startsWith(route.pattern + '?')) {
-			return route
-		}
-	}
-	return null
-}
-
-// Handle WebSocket upgrade that should go to a Durable Object
-async function handleDoWebSocket(request, env, url, route) {
-	try {
-		// Get the DO namespace
-		const namespace = env[route.doNamespace]
-		if (!namespace) {
-			console.error('[Gateway] DO namespace not found:', route.doNamespace)
-			return new Response('DO namespace not found: ' + route.doNamespace, { status: 500 })
-		}
-
-		// Get the instance ID from query params
-		const idValue = url.searchParams.get(route.idParam) || 'default'
-
-		// Get or create DO instance
-		const doId = namespace.idFromName(idValue)
-		const stub = namespace.get(doId)
-
-		// Construct the forward URL for the DO
-		const forwardUrl = new URL(route.forwardPath, url.origin)
-		// Forward all query params
-		url.searchParams.forEach((v, k) => forwardUrl.searchParams.set(k, v))
-
-		log('Forwarding WebSocket to DO:', route.doNamespace, 'id:', idValue, 'path:', forwardUrl.pathname)
-
-		// Forward the request to the DO
-		return stub.fetch(forwardUrl.toString(), {
-			method: request.method,
-			headers: request.headers
-		})
-	} catch (error) {
-		console.error('[Gateway] Error forwarding to DO:', error)
-		return new Response('Error forwarding to DO: ' + error.message, { status: 500 })
-	}
-}
-
-// Handle bridge RPC WebSocket (for Node.js Vite server communication)
-function handleBridgeWebSocket(request, env, ctx) {
-	const { 0: client, 1: server } = new WebSocketPair()
-	server.accept()
-
-	server.addEventListener('message', async (event) => {
-		try {
-			if (typeof event.data === 'string') {
-				await handleJsonMessage(event.data, server, env, ctx)
-			}
-		} catch (error) {
-			console.error('[Gateway] Error:', error)
-		}
-	})
-
-	server.addEventListener('close', () => {
-		activeStreams.clear()
-		wsProxies.clear()
-	})
-
-	return new Response(null, { status: 101, webSocket: client })
-}
-
-async function handleJsonMessage(data, ws, env, ctx) {
-	const msg = JSON.parse(data)
-
-	switch (msg.t) {
-		case 'rpc.call':
-			await handleRpcCall(msg, ws, env, ctx)
-			break
-		case 'ws.open':
-			await handleWsOpen(msg, ws, env)
-			break
-		case 'ws.close':
-			handleWsClose(msg)
-			break
-	}
-}
-
-async function handleRpcCall(msg, ws, env, ctx) {
-	try {
-		const result = await executeRpcMethod(msg.method, msg.params, env, ctx)
-		ws.send(JSON.stringify({ t: 'rpc.ok', id: msg.id, result }))
-	} catch (error) {
-		ws.send(JSON.stringify({
-			t: 'rpc.err',
-			id: msg.id,
-			error: { code: error.code || 'INTERNAL_ERROR', message: error.message }
-		}))
-	}
-}
-
-async function executeRpcMethod(method, params, env, ctx) {
-	const parts = method.split('.')
-	const bindingName = parts[0]
-	const operation = parts.slice(1).join('.')
-	const binding = env[bindingName]
-
-	if (!binding) throw new Error('Binding not found: ' + bindingName)
-
-	// KV operations
-	if (operation === 'get') return binding.get(params[0], params[1])
-	if (operation === 'put') return binding.put(params[0], params[1], params[2])
-	if (operation === 'delete') return binding.delete(params[0])
-	if (operation === 'list') return binding.list(params[0])
-	if (operation === 'getWithMetadata') return binding.getWithMetadata(params[0], params[1])
-
-	// R2 operations
-	if (operation === 'head') return serializeR2Object(await binding.head(params[0]))
-	if (operation === 'r2.get') {
-		const obj = await binding.get(params[0], params[1])
-		if (!obj) return null
-		const body = await obj.arrayBuffer()
-		return serializeR2ObjectBody(obj, arrayBufferToBase64(body))
-	}
-	if (operation === 'r2.put') {
-		// Deserialize the value if it's a serialized ArrayBuffer/Uint8Array
-		let value = params[1]
-		if (value && typeof value === 'object') {
-			if (value.__type === 'ArrayBuffer') {
-				value = base64ToArrayBuffer(value.data)
-			} else if (value.__type === 'Uint8Array') {
-				value = base64ToArrayBuffer(value.data)
-			}
-		}
-		return serializeR2Object(await binding.put(params[0], value, params[2]))
-	}
-	if (operation === 'r2.delete') return binding.delete(params[0])
-	if (operation === 'r2.list') return serializeR2Objects(await binding.list(params[0]))
-
-	// D1 operations
-	if (operation === 'exec') return binding.exec(params[0])
-	if (operation.startsWith('stmt.')) {
-		log('D1 RPC:', bindingName, operation, 'sql:', String(params[0]).slice(0, 60))
-		const mode = operation.split('.')[1]
-		const [sql, ...rest] = params
-		
-		// For first/raw, the last element is the column/options parameter (may be undefined)
-		// For all/run, rest contains only bindings
-		let bindings = rest
-		let extraParam = undefined
-		
-		if (mode === 'first' || mode === 'raw') {
-			// Last element is the column/options (may be undefined)
-			extraParam = rest[rest.length - 1]
-			bindings = rest.slice(0, -1)
-		}
-		
-		let stmt = binding.prepare(sql)
-		if (bindings.length > 0) stmt = stmt.bind(...bindings)
-		
-		if (mode === 'first') {
-			// Only pass column if it's a non-empty string
-			if (typeof extraParam === 'string' && extraParam.length > 0) {
-				return stmt.first(extraParam)
-			}
-			return stmt.first()
-		}
-		if (mode === 'all') return stmt.all()
-		if (mode === 'run') return stmt.run()
-		if (mode === 'raw') return stmt.raw(extraParam)
-	}
-
-	// DO operations
-	if (operation === 'idFromName') {
-		const id = binding.idFromName(params[0])
-		return { __type: 'DOId', hex: id.toString() }
-	}
-	if (operation === 'idFromString') {
-		const id = binding.idFromString(params[0])
-		return { __type: 'DOId', hex: id.toString() }
-	}
-	if (operation === 'newUniqueId') {
-		const id = binding.newUniqueId(params[0])
-		return { __type: 'DOId', hex: id.toString() }
-	}
-	if (operation === 'stub.fetch') {
-		const [, serializedId, serializedReq] = params
-		log('stub.fetch request:', {
-			url: serializedReq.url,
-			method: serializedReq.method,
-			headers: serializedReq.headers,
-			hasBody: !!serializedReq.body
-		})
-		const id = binding.idFromString(serializedId.hex)
-		const stub = binding.get(id)
-		try {
-			const response = await stub.fetch(new Request(serializedReq.url, {
-				method: serializedReq.method,
-				headers: serializedReq.headers,
-				body: serializedReq.body?.type === 'bytes' ? base64ToArrayBuffer(serializedReq.body.data) : undefined
-			}))
-			// Clone to read body for logging if there's an error
-			const cloned = response.clone()
-			const serialized = await serializeResponse(response)
-			log('stub.fetch response:', {
-				status: serialized.status,
-				headers: serialized.headers,
-				bodyLength: serialized.body?.data?.length || 0
-			})
-			// If 500, log the body content
-			if (response.status >= 400) {
-				const errBody = await cloned.text()
-				log('Error response body:', errBody)
-			}
-			return serialized
-		} catch (err) {
-			console.error('[Gateway] stub.fetch error:', err)
-			throw err
-		}
-	}
-	if (operation === 'stub.rpc') {
-		const [, serializedId, methodName, args] = params
-		const id = binding.idFromString(serializedId.hex)
-		const stub = binding.get(id)
-		const response = await stub.fetch(new Request('http://do/_rpc', {
-			method: 'POST',
-			headers: { 'Content-Type': 'application/json' },
-			body: JSON.stringify({ method: methodName, params: args })
-		}))
-		const result = await response.json()
-		if (!result.ok) throw new Error(result.error?.message || 'RPC failed')
-		return result.result
-	}
-
-	// Queue operations
-	if (operation === 'send') return binding.send(params[0], params[1])
-	if (operation === 'sendBatch') return binding.sendBatch(params[0], params[1])
-
-	// Email send operations (send_email binding)
-	if (operation === 'email.send') {
-		log('Email send:', { from: params[0]?.from, to: params[0]?.to })
-		// In local dev, we just log the email - Miniflare handles writing to file
-		if (binding && typeof binding.send === 'function') {
-			return binding.send(params[0])
-		}
-		// Return success even if no real binding (simulated)
-		return { ok: true, simulated: true }
-	}
-
-	throw new Error('Unknown operation: ' + method)
-}
-
-async function handleWsOpen(msg, ws, env) {
-	try {
-		const binding = env[msg.target.binding]
-		const id = binding.idFromString(msg.target.id)
-		const stub = binding.get(id)
-
-		const headers = new Headers(msg.target.headers || [])
-		headers.set('Upgrade', 'websocket')
-
-		const response = await stub.fetch(new Request(msg.target.url, { method: 'GET', headers }))
-		const doWs = response.webSocket
-
-		if (!doWs) {
-			ws.send(JSON.stringify({ t: 'rpc.err', id: 'ws_' + msg.wid, error: { code: 'WS_FAILED', message: 'No WebSocket returned' } }))
-			return
-		}
-
-		doWs.accept()
-		wsProxies.set(msg.wid, { doWs })
-
-		doWs.addEventListener('message', (event) => {
-			const isText = typeof event.data === 'string'
-			const data = isText ? event.data : arrayBufferToBase64(event.data)
-			ws.send(JSON.stringify({ t: 'ws.data', wid: msg.wid, data, isText }))
-		})
-
-		doWs.addEventListener('close', (event) => {
-			ws.send(JSON.stringify({ t: 'ws.close', wid: msg.wid, code: event.code, reason: event.reason }))
-			wsProxies.delete(msg.wid)
-		})
-
-		ws.send(JSON.stringify({ t: 'ws.opened', wid: msg.wid }))
-	} catch (error) {
-		ws.send(JSON.stringify({ t: 'rpc.err', id: 'ws_' + msg.wid, error: { code: 'WS_FAILED', message: error.message } }))
-	}
-}
-
-function handleWsClose(msg) {
-	const proxy = wsProxies.get(msg.wid)
-	if (proxy) {
-		proxy.doWs.close(msg.code, msg.reason)
-		wsProxies.delete(msg.wid)
-	}
-}
-
-async function handleHttpTransfer(request, env, url) {
-	const transferIdEncoded = url.pathname.split('/').pop()
-	const transferId = decodeURIComponent(transferIdEncoded || '')
-	const [binding, ...keyParts] = transferId.split(':')
-	const key = keyParts.join(':')
-	const bucket = env[binding]
-
-	if (!bucket) return new Response('Bucket not found: ' + binding, { status: 404 })
-
-	if (request.method === 'PUT' || request.method === 'POST') {
-		const result = await bucket.put(key, request.body)
-		return new Response(JSON.stringify(result), { headers: { 'Content-Type': 'application/json' } })
-	}
-
-	if (request.method === 'GET') {
-		const object = await bucket.get(key)
-		if (!object) return new Response('Not found', { status: 404 })
-		return new Response(object.body, {
-			headers: {
-				'Content-Type': object.httpMetadata?.contentType || 'application/octet-stream',
-				'Content-Length': String(object.size)
-			}
-		})
-	}
-
-	return new Response('Method not allowed', { status: 405 })
-}
-
-// Helpers
-function serializeR2Object(obj) {
-	if (!obj) return null
-	return {
-		__type: 'R2Object',
-		key: obj.key,
-		version: obj.version,
-		size: obj.size,
-		etag: obj.etag,
-		httpEtag: obj.httpEtag,
-		checksums: obj.checksums,
-		uploaded: obj.uploaded?.toISOString(),
-		httpMetadata: obj.httpMetadata,
-		customMetadata: obj.customMetadata,
-		range: obj.range,
-		storageClass: obj.storageClass
-	}
-}
-function serializeR2ObjectBody(obj, bodyData) {
-	if (!obj) return null
-	return {
-		__type: 'R2ObjectBody',
-		key: obj.key,
-		version: obj.version,
-		size: obj.size,
-		etag: obj.etag,
-		httpEtag: obj.httpEtag,
-		checksums: obj.checksums,
-		uploaded: obj.uploaded?.toISOString(),
-		httpMetadata: obj.httpMetadata,
-		customMetadata: obj.customMetadata,
-		range: obj.range,
-		storageClass: obj.storageClass,
-		bodyData
-	}
-}
-function serializeR2Objects(result) {
-	if (!result) return null
-	return { objects: result.objects.map(serializeR2Object), truncated: result.truncated, cursor: result.cursor }
-}
-async function serializeResponse(response) {
-	// Read body as bytes and encode as base64
-	let body = null
-	if (response.body) {
-		const bytes = await response.arrayBuffer()
-		if (bytes.byteLength > 0) {
-			body = { type: 'bytes', data: arrayBufferToBase64(bytes) }
-		}
-	}
-	return { status: response.status, statusText: response.statusText, headers: [...response.headers.entries()], body }
-}
-function arrayBufferToBase64(buffer) {
-	const bytes = new Uint8Array(buffer)
-	let binary = ''
-	for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i])
-	return btoa(binary)
-}
-function base64ToArrayBuffer(base64) {
-	const binary = atob(base64)
-	const bytes = new Uint8Array(binary.length)
-	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i)
-	return bytes.buffer
-}
-`;
-}
-function createDevServer(options) {
-  const {
-    cwd,
-    configPath,
-    vitePort = 5173,
-    miniflarePort = 8787,
-    enableVite = true,
-    persist = true,
-    logger,
-    verbose = false,
-    debug = process.env.DEVFLARE_DEBUG === "true"
-  } = options;
-  let miniflare = null;
-  let doBundler = null;
-  let workerSourceWatcher = null;
-  let workerWatchTargets = [];
-  let viteProcess = null;
-  let config = null;
-  let browserShim = null;
-  let browserShimPort = 8788;
-  let mainWorkerSurfacePaths = {
-    fetch: null,
-    queue: null,
-    scheduled: null,
-    email: null
-  };
-  let resolvedWorkerConfigPath = null;
-  let mainWorkerScriptPath = null;
-  let bundledMainWorkerScriptPath = null;
-  let currentDoResult = null;
-  let reloadChain = Promise.resolve();
-  async function bundleMainWorker() {
-    if (!hasWorkerSurfacePaths(mainWorkerSurfacePaths)) {
-      bundledMainWorkerScriptPath = null;
-      return;
-    }
-    if (typeof Bun === "undefined" || typeof Bun.build !== "function") {
-      throw new Error("Worker-only dev mode requires the Bun runtime for main worker bundling");
-    }
-    const fs = await import("node:fs/promises");
-    const outDir = resolve2(cwd, ".devflare", "worker-bundles");
-    const entryDir = resolve2(cwd, ".devflare", "worker-entrypoints");
-    await fs.rm(outDir, { recursive: true, force: true });
-    await fs.mkdir(outDir, { recursive: true });
-    await fs.mkdir(entryDir, { recursive: true });
-    const entryPath = resolve2(entryDir, "fetch-entry.ts");
-    const surfaceImportPaths = {
-      fetch: mainWorkerSurfacePaths.fetch ? toImportSpecifier(entryPath, mainWorkerSurfacePaths.fetch) : null,
-      queue: mainWorkerSurfacePaths.queue ? toImportSpecifier(entryPath, mainWorkerSurfacePaths.queue) : null,
-      scheduled: mainWorkerSurfacePaths.scheduled ? toImportSpecifier(entryPath, mainWorkerSurfacePaths.scheduled) : null,
-      email: mainWorkerSurfacePaths.email ? toImportSpecifier(entryPath, mainWorkerSurfacePaths.email) : null
-    };
-    await fs.writeFile(entryPath, getMainWorkerEntryScript(surfaceImportPaths));
-    const result = await Bun.build({
-      entrypoints: [entryPath],
-      outdir: outDir,
-      target: "browser",
-      conditions: ["browser"],
-      format: "esm",
-      minify: false,
-      splitting: false,
-      external: ["cloudflare:workers", "cloudflare:*", "node:*"]
-    });
-    if (!result.success || result.outputs.length === 0) {
-      const logs = result.logs.map((log) => ("message" in log) ? log.message : String(log)).join(`
-`);
-      throw new Error(`Failed to bundle main worker:
-${logs}`);
-    }
-    bundledMainWorkerScriptPath = result.outputs[0].path;
-    logger?.debug(`Bundled main worker → ${bundledMainWorkerScriptPath}`);
-  }
-  function buildMiniflareConfig(doResult) {
-    if (!config)
-      throw new Error("Config not loaded");
-    const loadedConfig = config;
-    const bindings = loadedConfig.bindings ?? {};
-    const persistPath = resolve2(cwd, ".devflare/data");
-    const appWorkerName = loadedConfig.name;
-    const shouldRunMainWorker = !enableVite && hasWorkerSurfacePaths(mainWorkerSurfacePaths);
-    const queueProducers = (() => {
-      if (!bindings.queues?.producers) {
-        return;
-      }
-      const producers = {};
-      for (const [bindingName, queueName] of Object.entries(bindings.queues.producers)) {
-        producers[bindingName] = { queueName };
-      }
-      return producers;
-    })();
-    const queueConsumers = (() => {
-      if (!bindings.queues?.consumers || bindings.queues.consumers.length === 0) {
-        return;
-      }
-      const consumers = {};
-      for (const consumer of bindings.queues.consumers) {
-        consumers[consumer.queue] = {
-          ...consumer.maxBatchSize !== undefined && { maxBatchSize: consumer.maxBatchSize },
-          ...consumer.maxBatchTimeout !== undefined && { maxBatchTimeout: consumer.maxBatchTimeout },
-          ...consumer.maxRetries !== undefined && { maxRetries: consumer.maxRetries },
-          ...consumer.deadLetterQueue && { deadLetterQueue: consumer.deadLetterQueue },
-          ...consumer.maxConcurrency !== undefined && { maxConcurrency: consumer.maxConcurrency },
-          ...consumer.retryDelay !== undefined && { retryDelay: consumer.retryDelay }
-        };
-      }
-      return consumers;
-    })();
-    const sharedOptions = {
-      port: miniflarePort,
-      host: "127.0.0.1",
-      kvPersist: persist ? `${persistPath}/kv` : undefined,
-      r2Persist: persist ? `${persistPath}/r2` : undefined,
-      d1Persist: persist ? `${persistPath}/d1` : undefined,
-      durableObjectsPersist: persist ? `${persistPath}/do` : undefined
-    };
-    const createServiceBindings = (extraBindings = {}) => {
-      const serviceBindings = {};
-      if (bindings.services) {
-        for (const [bindingName, serviceConfig] of Object.entries(bindings.services)) {
-          serviceBindings[bindingName] = {
-            name: serviceConfig.service,
-            ...serviceConfig.entrypoint && { entrypoint: serviceConfig.entrypoint }
-          };
-        }
-      }
-      for (const [bindingName, target] of Object.entries(extraBindings)) {
-        serviceBindings[bindingName] = target;
-      }
-      return Object.keys(serviceBindings).length > 0 ? serviceBindings : undefined;
-    };
-    const createWorkerConfig = (options2) => {
-      const baseFlags = loadedConfig.compatibilityFlags ?? [];
-      const compatFlags = baseFlags.includes("nodejs_compat") ? baseFlags : [...baseFlags, "nodejs_compat"];
-      const workerConfig = {
-        name: options2.name,
-        modules: true,
-        compatibilityDate: loadedConfig.compatibilityDate,
-        compatibilityFlags: compatFlags,
-        ...bindings.kv && { kvNamespaces: bindings.kv },
-        ...bindings.r2 && { r2Buckets: bindings.r2 },
-        ...bindings.d1 && { d1Databases: bindings.d1 },
-        ...loadedConfig.vars && Object.keys(loadedConfig.vars).length > 0 && { bindings: loadedConfig.vars },
-        ...queueProducers && { queueProducers },
-        ...options2.queueConsumers && { queueConsumers: options2.queueConsumers },
-        ...options2.triggers && { triggers: options2.triggers }
-      };
-      if (options2.scriptPath) {
-        workerConfig.scriptPath = options2.scriptPath;
-        workerConfig.modulesRoot = cwd;
-        workerConfig.modulesRules = [
-          { type: "ESModule", include: ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.mjs"] },
-          { type: "CommonJS", include: ["**/*.js", "**/*.cjs"] },
-          { type: "ESModule", include: ["**/*.jsx"] }
-        ];
-      }
-      if (options2.script) {
-        workerConfig.script = options2.script;
-      }
-      if (options2.durableObjects && Object.keys(options2.durableObjects).length > 0) {
-        workerConfig.durableObjects = options2.durableObjects;
-      }
-      if (options2.serviceBindings && Object.keys(options2.serviceBindings).length > 0) {
-        workerConfig.serviceBindings = options2.serviceBindings;
-      }
-      return workerConfig;
-    };
-    const gatewayWorker = createWorkerConfig({
-      name: "gateway",
-      script: getGatewayScript(loadedConfig.wsRoutes, debug, shouldRunMainWorker ? INTERNAL_APP_SERVICE_BINDING : null),
-      serviceBindings: shouldRunMainWorker ? createServiceBindings({
-        [INTERNAL_APP_SERVICE_BINDING]: { name: appWorkerName }
-      }) : createServiceBindings()
-    });
-    gatewayWorker.routes = ["*"];
-    const hasDurableObjectBundles = !!doResult && doResult.bundles.size > 0;
-    const browserBindingName = bindings.browser?.binding;
-    const needsBrowserWorker = Boolean(browserBindingName && (hasDurableObjectBundles || shouldRunMainWorker));
-    if (!shouldRunMainWorker && !hasDurableObjectBundles && !needsBrowserWorker) {
-      return {
-        ...sharedOptions,
-        ...gatewayWorker
-      };
-    }
-    const workers = [];
-    const durableObjects = {};
-    const browserShimUrl = `http://127.0.0.1:${browserShimPort}`;
-    const browserWorkerName = "browser-binding";
-    if (shouldRunMainWorker && mainWorkerScriptPath) {
-      const mainWorkerServiceBindings = createServiceBindings(browserBindingName ? {
-        [browserBindingName]: { name: browserWorkerName }
-      } : {});
-      const mainWorkerConfig = createWorkerConfig({
-        name: appWorkerName,
-        scriptPath: bundledMainWorkerScriptPath ?? mainWorkerScriptPath,
-        serviceBindings: mainWorkerServiceBindings,
-        queueConsumers,
-        triggers: loadedConfig.triggers?.crons?.length ? { crons: loadedConfig.triggers.crons } : undefined
-      });
-      workers.push(mainWorkerConfig);
-    }
-    if (doResult) {
-      for (const [bindingName, bundlePath] of doResult.bundles) {
-        const className = doResult.classes.get(bindingName);
-        if (!className)
-          continue;
-        const workerName = `do-${bindingName.toLowerCase()}`;
-        const workerConfig = createWorkerConfig({
-          name: workerName,
-          scriptPath: bundlePath,
-          durableObjects: {
-            [bindingName]: className
-          },
-          serviceBindings: createServiceBindings(browserBindingName ? {
-            [browserBindingName]: { name: browserWorkerName }
-          } : {})
-        });
-        if (browserBindingName) {
-          logger?.debug(`DO ${workerName} has browser service binding: ${browserBindingName} → ${browserWorkerName}`);
-        }
-        logger?.debug(`DO ${workerName} config:`, JSON.stringify(workerConfig, null, 2));
-        workers.push(workerConfig);
-        durableObjects[bindingName] = {
-          className,
-          scriptName: workerName
-        };
-      }
-    }
-    if (needsBrowserWorker) {
-      const browserWorker = createWorkerConfig({
-        name: browserWorkerName,
-        script: getBrowserBindingScript(browserShimUrl, debug)
-      });
-      workers.push(browserWorker);
-      logger?.info(`Browser binding worker configured: ${browserBindingName} → ${browserShimUrl}`);
-    }
-    if (Object.keys(durableObjects).length > 0) {
-      gatewayWorker.durableObjects = durableObjects;
-      if (shouldRunMainWorker) {
-        const mainWorker = workers.find((worker) => worker.name === appWorkerName);
-        if (mainWorker) {
-          mainWorker.durableObjects = durableObjects;
-        }
-      }
-    }
-    return {
-      ...sharedOptions,
-      workers: [gatewayWorker, ...workers]
-    };
-  }
-  async function startMiniflare(doResult) {
-    const { Miniflare, Log, LogLevel } = await import("miniflare");
-    const mfConfig = buildMiniflareConfig(doResult);
-    mfConfig.log = new Log(LogLevel.DEBUG);
-    logger?.info("=== MINIFLARE CONFIG DEBUG ===");
-    logger?.info("Full config:", JSON.stringify(mfConfig, (key, value) => {
-      if (key === "script" && typeof value === "string" && value.length > 200) {
-        return value.substring(0, 200) + "...[truncated]";
-      }
-      return value;
-    }, 2));
-    if (mfConfig.workers) {
-      logger?.info("Workers order:");
-      for (const w of mfConfig.workers) {
-        logger?.info(`  → ${w.name}:`);
-        logger?.info(`      script: ${w.script ? "inline" : w.scriptPath}`);
-        logger?.info(`      browserRendering: ${JSON.stringify(w.browserRendering)}`);
-        logger?.info(`      durableObjects: ${JSON.stringify(w.durableObjects)}`);
-      }
-    }
-    miniflare = new Miniflare(mfConfig);
-    await miniflare.ready;
-    logger?.success(`Miniflare ready on http://localhost:${miniflarePort}`);
-    try {
-      const gatewayBindings = await miniflare.getBindings("gateway");
-      logger?.info("Gateway worker bindings:", Object.keys(gatewayBindings));
-      if (mfConfig.workers) {
-        for (const w of mfConfig.workers) {
-          if (w.name !== "gateway") {
-            try {
-              const doBindings = await miniflare.getBindings(w.name);
-              logger?.info(`${w.name} worker bindings:`, Object.keys(doBindings));
-              if ("BROWSER" in doBindings) {
-                logger?.success(`${w.name} has BROWSER binding!`);
-              } else {
-                logger?.warn(`${w.name} is MISSING BROWSER binding`);
-              }
-            } catch (e) {
-              logger?.warn(`Could not get bindings for ${w.name}:`, e);
-            }
-          }
-        }
-      }
-    } catch (e) {
-      logger?.warn("Error getting bindings:", e);
-    }
-  }
-  async function reloadMiniflare(doResult) {
-    currentDoResult = doResult;
-    const queuedReload = reloadChain.then(async () => {
-      if (!miniflare)
-        return;
-      const { Log, LogLevel } = await import("miniflare");
-      const mfConfig = buildMiniflareConfig(currentDoResult);
-      mfConfig.log = new Log(LogLevel.DEBUG);
-      logger?.info("Reloading Miniflare...");
-      await miniflare.setOptions(mfConfig);
-      logger?.success("Miniflare reloaded");
-    });
-    reloadChain = queuedReload.catch(() => {});
-    await queuedReload;
-  }
-  async function resolveWorkerConfigWatchPath() {
-    if (configPath) {
-      const explicitPath = resolve2(cwd, configPath);
-      const fs = await import("node:fs/promises");
-      try {
-        await fs.access(explicitPath);
-        return explicitPath;
-      } catch {}
-    }
-    return await resolveConfigPath(cwd) ?? null;
-  }
-  async function refreshWorkerOnlySurfaceState() {
-    if (!config) {
-      return;
-    }
-    mainWorkerSurfacePaths = await resolveMainWorkerSurfacePaths(cwd, config);
-    mainWorkerScriptPath = getFirstWorkerSurfacePath(mainWorkerSurfacePaths);
-    if (hasWorkerSurfacePaths(mainWorkerSurfacePaths)) {
-      await bundleMainWorker();
-    } else {
-      bundledMainWorkerScriptPath = null;
-    }
-    await syncWorkerWatchTargets();
-  }
-  function getWorkerWatchTargets() {
-    if (enableVite || !config) {
-      return [];
-    }
-    const targets = collectWorkerWatchRoots(cwd, config, mainWorkerSurfacePaths);
-    if (resolvedWorkerConfigPath) {
-      targets.push(resolvedWorkerConfigPath);
-    }
-    return [...new Set(targets)];
-  }
-  async function syncWorkerWatchTargets() {
-    if (!workerSourceWatcher) {
-      return;
-    }
-    const nextWatchTargets = getWorkerWatchTargets();
-    const nextWatchTargetSet = new Set(nextWatchTargets);
-    const targetsToRemove = workerWatchTargets.filter((target) => !nextWatchTargetSet.has(target));
-    const targetsToAdd = nextWatchTargets.filter((target) => !workerWatchTargets.includes(target));
-    if (targetsToRemove.length > 0) {
-      await workerSourceWatcher.unwatch(targetsToRemove);
-    }
-    if (targetsToAdd.length > 0) {
-      workerSourceWatcher.add(targetsToAdd);
-    }
-    workerWatchTargets = nextWatchTargets;
-  }
-  async function reloadWorkerOnlyConfig() {
-    config = await loadConfig({ cwd, configFile: configPath });
-    resolvedWorkerConfigPath = await resolveWorkerConfigWatchPath();
-    await refreshWorkerOnlySurfaceState();
-    await reloadMiniflare(currentDoResult);
-  }
-  async function startWorkerSourceWatcher() {
-    if (enableVite || !config) {
-      return;
-    }
-    const watchTargets = getWorkerWatchTargets();
-    if (watchTargets.length === 0) {
-      return;
-    }
-    const chokidar = await import("chokidar");
-    const isWindows = process.platform === "win32";
-    const ignoredSegments = ["/node_modules/", "/.git/", "/.devflare/", "/dist/"];
-    const normalizePath = (filePath) => filePath.replace(/\\/g, "/");
-    const isIgnoredPath = (filePath) => {
-      const normalizedPath = normalizePath(filePath);
-      return ignoredSegments.some((segment) => normalizedPath.includes(segment));
-    };
-    let reloadTimeout = null;
-    let reloadInProgress = false;
-    let pendingReloadPath = null;
-    const triggerReload = async (filePath) => {
-      if (reloadInProgress) {
-        pendingReloadPath = filePath;
-        return;
-      }
-      reloadInProgress = true;
-      try {
-        const normalizedConfigPath = resolvedWorkerConfigPath ? normalizePath(resolvedWorkerConfigPath) : null;
-        if (normalizedConfigPath && normalizePath(filePath) === normalizedConfigPath) {
-          logger?.info(`Devflare config changed: ${filePath}`);
-          await reloadWorkerOnlyConfig();
-          return;
-        }
-        logger?.info(`Worker source changed: ${filePath}`);
-        await refreshWorkerOnlySurfaceState();
-        await reloadMiniflare(currentDoResult);
-      } catch (error) {
-        logger?.error("Worker source reload failed:", error);
-      } finally {
-        reloadInProgress = false;
-        if (pendingReloadPath) {
-          const nextPath = pendingReloadPath;
-          pendingReloadPath = null;
-          await triggerReload(nextPath);
-        }
-      }
-    };
-    const scheduleReload = (filePath) => {
-      if (reloadTimeout) {
-        clearTimeout(reloadTimeout);
-      }
-      reloadTimeout = setTimeout(() => {
-        triggerReload(filePath);
-      }, 150);
-    };
-    workerWatchTargets = watchTargets;
-    workerSourceWatcher = chokidar.watch(watchTargets, {
-      ignoreInitial: true,
-      usePolling: isWindows,
-      interval: isWindows ? 300 : undefined,
-      awaitWriteFinish: {
-        stabilityThreshold: 100,
-        pollInterval: 50
-      },
-      ignored: (filePath) => isIgnoredPath(filePath)
-    });
-    const onFileEvent = (filePath) => {
-      if (isIgnoredPath(filePath)) {
-        return;
-      }
-      scheduleReload(filePath);
-    };
-    workerSourceWatcher.on("change", onFileEvent);
-    workerSourceWatcher.on("add", onFileEvent);
-    workerSourceWatcher.on("unlink", onFileEvent);
-    workerSourceWatcher.on("ready", () => {
-      logger?.info(`Worker source watcher ready (${watchTargets.length} target(s))`);
-    });
-    workerSourceWatcher.on("error", (error) => {
-      logger?.error("Worker source watcher error:", error);
-    });
-  }
-  async function runD1Migrations() {
-    if (!miniflare || !config?.bindings?.d1)
-      return;
-    const { existsSync: existsSync2, readdirSync, readFileSync } = await import("node:fs");
-    const migrationsDir = resolve2(cwd, "migrations");
-    if (!existsSync2(migrationsDir)) {
-      logger?.debug("No migrations/ directory found, skipping D1 migrations");
-      return;
-    }
-    const files = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")).sort();
-    if (files.length === 0) {
-      logger?.debug("No SQL migration files found");
-      return;
-    }
-    logger?.info(`Running ${files.length} D1 migration(s)...`);
-    const allStatements = [];
-    for (const file of files) {
-      const sql = readFileSync(resolve2(migrationsDir, file), "utf-8");
-      const cleanedSql = sql.split(`
-`).filter((line) => !line.trim().startsWith("--")).join(`
-`);
-      const statements = cleanedSql.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
-      allStatements.push(...statements);
-      logger?.debug(`File ${file}: ${statements.length} statement(s)`);
-    }
-    for (const [bindingName] of Object.entries(config.bindings.d1)) {
-      for (let attempt = 0;attempt < 5; attempt++) {
-        await new Promise((r) => setTimeout(r, 500 * (attempt + 1)));
-        try {
-          const response = await fetch(`http://127.0.0.1:${miniflarePort}/_devflare/migrate`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ bindingName, statements: allStatements })
-          });
-          if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`HTTP ${response.status}: ${text}`);
-          }
-          const result = await response.json();
-          if (result.success) {
-            logger?.success(`D1 migrations applied to ${bindingName}`);
-            break;
-          } else {
-            throw new Error(result.error || "Unknown error");
-          }
-        } catch (error) {
-          if (attempt === 4) {
-            logger?.warn(`Failed to apply migrations to ${bindingName}: ${error}`);
-          }
-        }
-      }
-    }
-  }
-  async function startVite() {
-    const { spawn } = await import("node:child_process");
-    const args = ["vite", "dev", "--port", String(vitePort)];
-    viteProcess = spawn("bunx", args, {
-      cwd,
-      stdio: ["inherit", "pipe", "pipe"],
-      windowsHide: true,
-      env: {
-        ...process.env,
-        DEVFLARE_DEV: "true",
-        DEVFLARE_BRIDGE_PORT: String(miniflarePort),
-        FORCE_COLOR: "1"
-      }
-    });
-    const readyUrl = await waitForViteReady(viteProcess, {
-      onStdout(chunk) {
-        process.stdout.write(chunk);
-      },
-      onStderr(chunk) {
-        process.stderr.write(chunk);
-      }
-    });
-    if (readyUrl) {
-      logger?.success(`Vite dev server started on ${readyUrl}`);
-      return;
-    }
-    logger?.warn("Vite process started, but the final local URL could not be confirmed yet");
-  }
-  async function start() {
-    logger?.info("Starting unified dev server...");
-    config = await loadConfig({ cwd, configFile: configPath });
-    resolvedWorkerConfigPath = await resolveWorkerConfigWatchPath();
-    logger?.debug("Loaded config:", config.name);
-    await refreshWorkerOnlySurfaceState();
-    if (!enableVite && hasWorkerSurfacePaths(mainWorkerSurfacePaths)) {
-      const detectedWorkerHandlers = Object.entries(mainWorkerSurfacePaths).filter(([, surfacePath]) => !!surfacePath).map(([surfaceName, surfacePath]) => `${surfaceName}=${surfacePath}`).join(", ");
-      logger?.info(`Worker handlers detected: ${detectedWorkerHandlers}`);
-    } else if (!enableVite) {
-      logger?.warn("No local worker handler entry was found for worker-only mode");
-    }
-    const remoteCheck = await checkRemoteBindingRequirements(config);
-    if (remoteCheck.hasRemoteBindings) {
-      logger?.info("");
-      logger?.warn("⚠️  Remote-only bindings detected:");
-      for (const binding of remoteCheck.remoteBindings) {
-        logger?.warn(`   • ${binding}`);
-      }
-      logger?.info("");
-      if (remoteCheck.missingAccountId) {
-        logger?.warn("⚠️  WARN: accountId is not set in devflare.config.ts");
-        logger?.warn("   Remote bindings (AI, Vectorize) require accountId to charge the correct account.");
-        logger?.warn("   Add: accountId: 'your-cloudflare-account-id'");
-        logger?.info("");
-      }
-      if (remoteCheck.notLoggedIn) {
-        logger?.warn("⚠️  WARN: Not logged in to Wrangler");
-        logger?.warn("   Remote bindings require authentication.");
-        logger?.warn("   Run: bunx wrangler login");
-        logger?.info("");
-      }
-      if (!remoteCheck.missingAccountId && !remoteCheck.notLoggedIn) {
-        logger?.success("✓ Remote binding requirements met");
-        logger?.info("");
-      }
-    }
-    const browserBinding = config.bindings?.browser?.binding;
-    if (browserBinding) {
-      logger?.info(`Starting Browser Rendering shim (binding: ${browserBinding})...`);
-      browserShim = createBrowserShim({
-        port: browserShimPort,
-        host: "127.0.0.1",
-        logger,
-        verbose
-      });
-      await browserShim.start();
-    }
-    const doPattern = config.files?.durableObjects;
-    let doResult = null;
-    if (typeof doPattern === "string" && doPattern) {
-      const outDir = resolve2(cwd, ".devflare/do-bundles");
-      doBundler = createDOBundler({
-        cwd,
-        pattern: doPattern,
-        outDir,
-        logger,
-        onRebuild: async (result) => {
-          await reloadMiniflare(result);
-        }
-      });
-      doResult = await doBundler.build();
-      currentDoResult = doResult;
-      await doBundler.watch();
-    }
-    currentDoResult = doResult;
-    await startMiniflare(doResult);
-    await startWorkerSourceWatcher();
-    if (enableVite) {
-      await startVite();
-    } else {
-      logger?.info("Vite startup skipped (no local vite.config.* found for this package)");
-    }
-    await new Promise((r) => setTimeout(r, 1000));
-    await runD1Migrations();
-  }
-  async function stop() {
-    if (doBundler) {
-      await doBundler.close();
-      doBundler = null;
-    }
-    if (workerSourceWatcher) {
-      await workerSourceWatcher.close();
-      workerSourceWatcher = null;
-    }
-    if (miniflare) {
-      await miniflare.dispose();
-      miniflare = null;
-    }
-    if (viteProcess) {
-      await stopSpawnedProcessTree(viteProcess);
-      viteProcess = null;
-    }
-    if (browserShim) {
-      await browserShim.stop();
-      browserShim = null;
-    }
-  }
-  function getMiniflare() {
-    return miniflare;
-  }
-  return {
-    start,
-    stop,
-    getMiniflare
-  };
-}
-// src/cli/commands/dev.ts
-async function createLogWriter(cwd, options) {
-  if (!options.log && !options.logTemp) {
-    return null;
-  }
-  const fs = await import("node:fs");
-  let logPath;
-  if (options.logTemp) {
-    logPath = resolve3(cwd, ".log");
-  } else {
-    const now = new Date;
-    const timestamp = now.toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
-    logPath = resolve3(cwd, `.log-${timestamp}`);
-  }
-  const fileStream = fs.createWriteStream(logPath, { flags: "w" });
-  const ansiRegex = /\x1b\[[0-9;]*m/g;
-  return {
-    write(data, source) {
-      const str = typeof data === "string" ? data : data.toString();
-      if (!str.trim())
-        return;
-      const timestamp = new Date().toISOString().slice(11, 23);
-      const prefix = source ? `[${timestamp}][${source.toUpperCase()}] ` : `[${timestamp}] `;
-      const cleanStr = str.replace(ansiRegex, "");
-      fileStream.write(prefix + cleanStr + (cleanStr.endsWith(`
-`) ? "" : `
-`));
-    },
-    close() {
-      fileStream.end();
-    }
-  };
-}
-async function runDevCommand(parsed, logger, options) {
-  const cwd = options.cwd || parsed.options.cwd || process.cwd();
-  const configPath = parsed.options.config;
-  const port = parsed.options.port;
-  const logEnabled = parsed.options.log === true;
-  const logTempEnabled = parsed.options["log-temp"] === true;
-  const persistEnabled = parsed.options.persist === true;
-  const debugEnabled = parsed.options.debug === true || process.env.DEVFLARE_DEBUG === "true";
-  const verbose = parsed.options.verbose === true || debugEnabled;
-  const viteProject = await detectViteProject(cwd);
-  const logWriter = await createLogWriter(cwd, {
-    log: logEnabled,
-    logTemp: logTempEnabled
-  });
-  if (logWriter) {
-    const logFile = logTempEnabled ? ".log" : `.log-{datetime}`;
-    logger.info(`\uD83D\uDCDD Logging enabled → ${logFile}`);
-  }
-  const devLogger = createConsola({
-    level: verbose ? 4 : 3
-  });
-  if (logWriter) {
-    const wrapLog = (original, prefix = "") => {
-      return (message, ...args) => {
-        original(message, ...args);
-        const formatted = prefix ? `${prefix} ${[message, ...args].join(" ")}` : [message, ...args].join(" ");
-        logWriter.write(formatted);
-      };
-    };
-    Object.assign(devLogger.info, wrapLog(devLogger.info.bind(devLogger)));
-    Object.assign(devLogger.error, wrapLog(devLogger.error.bind(devLogger), "[ERROR]"));
-    Object.assign(devLogger.warn, wrapLog(devLogger.warn.bind(devLogger), "[WARN]"));
-    Object.assign(devLogger.success, wrapLog(devLogger.success.bind(devLogger), "[OK]"));
-    Object.assign(devLogger.debug, wrapLog(devLogger.debug.bind(devLogger), "[DEBUG]"));
-  }
-  try {
-    logger.info("");
-    if (viteProject.shouldStartVite) {
-      logger.info("\uD83D\uDE80 Devflare Unified Dev Server");
-      logger.info("   ├─ Vite: Full HMR for frontend");
-      logger.info("   ├─ Miniflare: All Cloudflare bindings");
-      logger.info("   ├─ Rolldown: Fast DO bundling with watch");
-      logger.info("   └─ Bridge: WebSocket RPC connection");
-    } else {
-      logger.info("\uD83D\uDE80 Devflare Worker Dev Server");
-      logger.info("   ├─ Miniflare: All Cloudflare bindings");
-      logger.info("   ├─ Rolldown: Fast DO bundling with watch");
-      logger.info("   └─ Vite: Disabled (no local vite.config.* found)");
-      if (viteProject.wantsViteIntegration) {
-        logger.warn("Vite-related dependencies were found, but no local vite.config.* was detected");
-        logger.warn("Skipping Vite startup and running in worker-only mode");
-      }
-    }
-    logger.info("");
-    const devServer = createDevServer({
-      cwd,
-      configPath,
-      vitePort: port ? parseInt(port, 10) : 5173,
-      miniflarePort: 8787,
-      enableVite: viteProject.shouldStartVite,
-      persist: persistEnabled,
-      logger: devLogger,
-      verbose,
-      debug: debugEnabled
-    });
-    let isCleaningUp = false;
-    const cleanupHandlers = new Map;
-    const removeCleanupHandlers = () => {
-      for (const [event, handler] of cleanupHandlers) {
-        process.off(event, handler);
-      }
-      cleanupHandlers.clear();
-    };
-    const cleanup = async (exitCode, reason) => {
-      if (isCleaningUp) {
-        return;
-      }
-      isCleaningUp = true;
-      removeCleanupHandlers();
-      if (reason) {
-        const message = reason instanceof Error ? reason.stack ?? reason.message : String(reason);
-        logger.error(message);
-      }
-      logger.info("");
-      logger.info("Shutting down...");
-      try {
-        await devServer.stop();
-      } finally {
-        logWriter?.close();
-        process.exit(exitCode);
-      }
-    };
-    const registerCleanupHandler = (event, handler) => {
-      cleanupHandlers.set(event, handler);
-      process.on(event, handler);
-    };
-    registerCleanupHandler("SIGINT", () => {
-      cleanup(0);
-    });
-    registerCleanupHandler("SIGTERM", () => {
-      cleanup(0);
-    });
-    registerCleanupHandler("SIGHUP", () => {
-      cleanup(0);
-    });
-    registerCleanupHandler("uncaughtException", (error) => {
-      cleanup(1, error);
-    });
-    registerCleanupHandler("unhandledRejection", (reason) => {
-      cleanup(1, reason);
-    });
-    await devServer.start();
-    await new Promise(() => {});
-    return { exitCode: 0 };
-  } catch (error) {
-    logWriter?.close();
-    if (error instanceof Error) {
-      logger.error("Dev server failed:", error.message);
-      if (verbose) {
-        logger.error(error.stack);
-      }
-    }
-    return { exitCode: 1 };
-  }
-}
-export {
-  runDevCommand
-};