devflare 0.0.0 → 1.0.0-next.0

package/dist/dev-qnxet3j9.js

@@ -0,0 +1,2096 @@
+import {
+  findFiles
+} from "./index-rbht7m9r.js";
+import {
+  findDurableObjectClasses
+} from "./index-gz1gndna.js";
+import {
+  loadConfig
+} 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 { 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
+function getGatewayScript(wsRoutes = [], debug = false) {
+  const wsRoutesJson = JSON.stringify(wsRoutes);
+  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}
+
+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' } })
+		}
+
+		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 })
+		
+		// Parse headers from raw email for the Headers object
+		const headerLines = []
+		const lines = rawBody.split(/\\r?\\n/)
+		let bodyStart = 0
+		for (let i = 0; i < lines.length; i++) {
+			if (lines[i].trim() === '') {
+				bodyStart = i + 1
+				break
+			}
+			headerLines.push(lines[i])
+		}
+		
+		const headers = new Headers()
+		for (const line of headerLines) {
+			const colonIdx = line.indexOf(':')
+			if (colonIdx > 0) {
+				const key = line.slice(0, colonIdx).trim()
+				const value = line.slice(colonIdx + 1).trim()
+				headers.append(key, value)
+			}
+		}
+		
+		// Create ReadableStream from raw email
+		const rawStream = new ReadableStream({
+			start(controller) {
+				controller.enqueue(new TextEncoder().encode(rawBody))
+				controller.close()
+			}
+		})
+		
+		// Create ForwardableEmailMessage-like object
+		const emailMessage = {
+			from,
+			to,
+			headers,
+			raw: rawStream,
+			rawSize: rawBody.length,
+			
+			setReject(reason) {
+				log('Email rejected:', reason)
+			},
+			
+			async forward(rcptTo, extraHeaders) {
+				log('Email forwarded to:', rcptTo)
+				return Promise.resolve()
+			},
+			
+			async reply(message) {
+				log('Email reply sent to:', message.from)
+				return Promise.resolve()
+			}
+		}
+		
+		// Look for email handler in the worker module
+		// For now, we call via a special RPC method that DO workers can implement
+		// The email binding should be configured in the worker
+		
+		// Check if there's an EMAIL_HANDLER binding (special DO for email handling)
+		if (env.__emailHandler && typeof env.__emailHandler.email === 'function') {
+			await env.__emailHandler.email(emailMessage, env, ctx)
+		}
+		
+		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,
+    persist = true,
+    logger,
+    verbose = false,
+    debug = process.env.DEVFLARE_DEBUG === "true"
+  } = options;
+  let miniflare = null;
+  let doBundler = null;
+  let viteProcess = null;
+  let config = null;
+  let browserShim = null;
+  let browserShimPort = 8788;
+  function buildMiniflareConfig(doResult) {
+    if (!config)
+      throw new Error("Config not loaded");
+    const bindings = config.bindings ?? {};
+    const persistPath = resolve2(cwd, ".devflare/data");
+    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 gatewayWorker = {
+      name: "gateway",
+      modules: true,
+      script: getGatewayScript(config.wsRoutes, debug),
+      compatibilityDate: config.compatibilityDate,
+      compatibilityFlags: config.compatibilityFlags ?? [],
+      routes: ["*"],
+      kvNamespaces: bindings.kv ? bindings.kv : undefined,
+      r2Buckets: bindings.r2 ? bindings.r2 : undefined,
+      d1Databases: bindings.d1 ? bindings.d1 : undefined,
+      bindings: config.vars
+    };
+    if (!doResult || doResult.bundles.size === 0) {
+      return {
+        ...sharedOptions,
+        ...gatewayWorker
+      };
+    }
+    const workers = [];
+    const durableObjects = {};
+    const browserShimUrl = `http://127.0.0.1:${browserShimPort}`;
+    const browserBindingName = bindings.browser?.binding;
+    const browserWorkerName = "browser-binding";
+    for (const [bindingName, bundlePath] of doResult.bundles) {
+      const className = doResult.classes.get(bindingName);
+      if (!className)
+        continue;
+      const workerName = `do-${bindingName.toLowerCase()}`;
+      const baseFlags = config.compatibilityFlags ?? [];
+      const compatFlags = baseFlags.includes("nodejs_compat") ? baseFlags : [...baseFlags, "nodejs_compat"];
+      const workerConfig = {
+        name: workerName,
+        modules: true,
+        modulesRoot: cwd,
+        modulesRules: [
+          { type: "CommonJS", include: ["**/*.js", "**/*.cjs"] },
+          { type: "ESModule", include: ["**/*.mjs"] }
+        ],
+        scriptPath: bundlePath,
+        compatibilityDate: config.compatibilityDate,
+        compatibilityFlags: compatFlags,
+        durableObjects: {
+          [bindingName]: className
+        }
+      };
+      if (browserBindingName) {
+        workerConfig.serviceBindings = {
+          ...workerConfig.serviceBindings,
+          [browserBindingName]: browserWorkerName
+        };
+        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 (browserBindingName) {
+      const browserWorker = {
+        name: browserWorkerName,
+        modules: true,
+        script: getBrowserBindingScript(browserShimUrl, debug),
+        compatibilityDate: config.compatibilityDate,
+        compatibilityFlags: config.compatibilityFlags ?? []
+      };
+      workers.push(browserWorker);
+      logger?.info(`Browser binding worker configured: ${browserBindingName} → ${browserShimUrl}`);
+    }
+    gatewayWorker.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) {
+    if (!miniflare)
+      return;
+    const { Log, LogLevel } = await import("miniflare");
+    const mfConfig = buildMiniflareConfig(doResult);
+    mfConfig.log = new Log(LogLevel.DEBUG);
+    logger?.info("Reloading Miniflare with updated DOs...");
+    await miniflare.setOptions(mfConfig);
+    logger?.success("Miniflare reloaded");
+  }
+  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",
+      env: {
+        ...process.env,
+        DEVFLARE_DEV: "true",
+        DEVFLARE_BRIDGE_PORT: String(miniflarePort),
+        FORCE_COLOR: "1"
+      }
+    });
+    logger?.success(`Vite dev server started on http://localhost:${vitePort}`);
+  }
+  async function start() {
+    logger?.info("Starting unified dev server...");
+    config = await loadConfig({ cwd, configFile: configPath });
+    logger?.debug("Loaded config:", config.name);
+    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();
+      await doBundler.watch();
+    }
+    await startMiniflare(doResult);
+    await startVite();
+    await new Promise((r) => setTimeout(r, 1000));
+    await runD1Migrations();
+    const cleanup = async () => {
+      logger?.info("Shutting down...");
+      await stop();
+      process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  }
+  async function stop() {
+    if (doBundler) {
+      await doBundler.close();
+      doBundler = null;
+    }
+    if (miniflare) {
+      await miniflare.dispose();
+      miniflare = null;
+    }
+    if (viteProcess) {
+      viteProcess.kill("SIGTERM");
+      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 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("");
+    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");
+    logger.info("");
+    const devServer = createDevServer({
+      cwd,
+      configPath,
+      vitePort: port ? parseInt(port, 10) : 5173,
+      miniflarePort: 8787,
+      persist: persistEnabled,
+      logger: devLogger,
+      verbose,
+      debug: debugEnabled
+    });
+    const cleanup = async () => {
+      logger.info("");
+      logger.info("Shutting down...");
+      await devServer.stop();
+      logWriter?.close();
+      process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    await devServer.start();
+    await new Promise(() => {});
+    return { exitCode: 0 };
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error("Dev server failed:", error.message);
+      if (verbose) {
+        logger.error(error.stack);
+      }
+    }
+    logWriter?.close();
+    return { exitCode: 1 };
+  }
+}
+export {
+  runDevCommand
+};