devflare 1.0.0-next.2 → 1.0.0-next.20

package/dist/dev-kybq3mwr.js

@@ -0,0 +1,2489 @@
+import {
+  bundleWorkerEntry,
+  createDOBundler
+} from "./index-pkxf6h87.js";
+import {
+  detectViteProject,
+  resolveViteMode,
+  stopSpawnedProcessTree,
+  waitForViteReady
+} from "./index-gn5wy09x.js";
+import {
+  createCliTheme,
+  cyanBold,
+  dim,
+  logLine,
+  yellow
+} from "./index-stgn34cr.js";
+import"./index-3t6rypgc.js";
+import {
+  buildAiSearchInstancesConfig,
+  buildAiSearchNamespacesConfig,
+  buildArtifactsConfig,
+  buildDispatchNamespacesConfig,
+  buildHyperdrivesConfig,
+  buildImagesConfig,
+  buildMediaConfig,
+  buildMtlsCertificatesConfig,
+  buildPipelinesConfig,
+  buildQueueConsumers,
+  buildQueueProducers,
+  buildRateLimitsConfig,
+  buildSecretsStoreConfig,
+  buildSendEmailConfig,
+  buildVersionMetadataConfig,
+  buildWorkerLoadersConfig,
+  buildWorkflowsConfig
+} from "./index-9bjjqdfc.js";
+import {
+  DEFAULT_EMAIL_ENTRY_FILES,
+  DEFAULT_FETCH_ENTRY_FILES,
+  DEFAULT_QUEUE_ENTRY_FILES,
+  DEFAULT_SCHEDULED_ENTRY_FILES,
+  hasWorkerSurfacePaths,
+  prepareComposedWorkerEntrypoint,
+  resolveEffectiveViteProject,
+  resolveWorkerSurfacePaths,
+  writeGeneratedViteConfig
+} from "./index-mzmq3v0d.js";
+import {
+  discoverRoutes,
+  getRouteDirectoryCandidate
+} from "./index-3e7by9sy.js";
+import"./index-rbht7m9r.js";
+import"./index-65e7xx1a.js";
+import"./index-vhqww6tt.js";
+import {
+  GATEWAY_RUNTIME_JS
+} from "./index-97x94h0m.js";
+import {
+  clearLocalSendEmailBindings,
+  setLocalSendEmailBindings
+} from "./index-124e9t4t.js";
+import {
+  applyLocalDevVarsToConfig
+} from "./index-8052df4m.js";
+import {
+  getLocalD1DatabaseIdentifier,
+  getLocalKVNamespaceIdentifier,
+  getSingleBrowserBindingName,
+  loadConfig,
+  resolveConfigPath
+} from "./index-g5aq66bj.js";
+import"./index-1d4jg11n.js";
+import"./index-mg8vwqxf.js";
+import"./index-z40mjts9.js";
+import"./index-q8f4kawk.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/cli/commands/dev.ts
+import { createConsola } from "consola";
+import { relative, resolve as resolve7 } from "pathe";
+
+// src/dev-server/server.ts
+import { resolve as resolve6 } from "pathe";
+
+// 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/d1-migrations.ts
+import { createHash } from "node:crypto";
+import { resolve } from "pathe";
+var MIGRATION_RETRY_DELAYS_MS = [500, 1000, 1500, 2000];
+function collectMigrationStatements(sql) {
+  const cleanedSql = sql.split(`
+`).filter((line) => !line.trim().startsWith("--")).join(`
+`);
+  return cleanedSql.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+}
+function hashSql(sql) {
+  return createHash("sha256").update(sql).digest("hex");
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function waitForRetry(delayMs) {
+  await new Promise((resolvePromise) => setTimeout(resolvePromise, delayMs));
+}
+async function applyMigrationsToBinding(options) {
+  const { bindingName, statements, files, miniflarePort, logger } = options;
+  let lastError;
+  for (let attempt = 0;attempt <= MIGRATION_RETRY_DELAYS_MS.length; attempt++) {
+    if (attempt > 0) {
+      await waitForRetry(MIGRATION_RETRY_DELAYS_MS[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, files })
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`HTTP ${response.status}: ${text}`);
+      }
+      const result = await response.json();
+      if (result.success) {
+        if (Array.isArray(result.warnings)) {
+          for (const warning of result.warnings) {
+            console.warn(`[devflare] D1 migration file "${warning.filename}" for binding ${bindingName} has changed since it was applied; skipping re-apply to protect existing data.`);
+          }
+        }
+        const appliedCount = result.applied?.length ?? 0;
+        const skippedCount = result.skipped?.length ?? 0;
+        if (appliedCount > 0 || skippedCount > 0) {
+          logger?.success(`D1 migrations for ${bindingName}: ${appliedCount} applied, ${skippedCount} skipped`);
+        } else {
+          logger?.success(`D1 migrations applied to ${bindingName}`);
+        }
+        return;
+      }
+      throw new Error(result.error || "Unknown error");
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  logger?.warn(`Failed to apply migrations to ${bindingName}: ${getErrorMessage(lastError)}`);
+}
+async function runD1Migrations(options) {
+  const { cwd, config, miniflarePort, logger } = options;
+  if (!config?.bindings?.d1) {
+    return;
+  }
+  const { existsSync, readdirSync, readFileSync, statSync } = await import("node:fs");
+  const migrationsDir = resolve(cwd, "migrations");
+  if (!existsSync(migrationsDir)) {
+    logger?.debug("No migrations/ directory found, skipping D1 migrations");
+    return;
+  }
+  const sharedFiles = readdirSync(migrationsDir).filter((file) => file.endsWith(".sql")).sort();
+  let sharedFileEntries = null;
+  if (sharedFiles.length > 0) {
+    sharedFileEntries = [];
+    for (const file of sharedFiles) {
+      const sql = readFileSync(resolve(migrationsDir, file), "utf-8");
+      const fileStatements = collectMigrationStatements(sql);
+      sharedFileEntries.push({
+        filename: file,
+        sha256: hashSql(sql),
+        statements: fileStatements
+      });
+      logger?.debug(`Shared file ${file}: ${fileStatements.length} statement(s)`);
+    }
+  }
+  for (const [bindingName] of Object.entries(config.bindings.d1)) {
+    const perBindingDir = resolve(migrationsDir, bindingName);
+    const hasPerBindingDir = existsSync(perBindingDir) && statSync(perBindingDir).isDirectory();
+    let files = [];
+    let sourceLabel = "";
+    if (hasPerBindingDir) {
+      const perBindingFiles = readdirSync(perBindingDir).filter((file) => file.endsWith(".sql")).sort();
+      if (perBindingFiles.length === 0) {
+        logger?.debug(`No SQL migration files in migrations/${bindingName}/, skipping ${bindingName}`);
+        continue;
+      }
+      for (const file of perBindingFiles) {
+        const sql = readFileSync(resolve(perBindingDir, file), "utf-8");
+        const fileStatements = collectMigrationStatements(sql);
+        files.push({
+          filename: file,
+          sha256: hashSql(sql),
+          statements: fileStatements
+        });
+        logger?.debug(`File ${bindingName}/${file}: ${fileStatements.length} statement(s)`);
+      }
+      sourceLabel = `migrations/${bindingName}/`;
+    } else if (sharedFileEntries !== null) {
+      files = sharedFileEntries;
+      sourceLabel = "migrations/ [shared fallback]";
+    } else {
+      logger?.debug(`No migrations found for ${bindingName}, skipping`);
+      continue;
+    }
+    const statements = files.flatMap((file) => file.statements);
+    logger?.info(`Running ${files.length} D1 migration(s) for ${bindingName} (from ${sourceLabel})`);
+    if (statements.length === 0) {
+      logger?.debug(`No executable D1 migration statements for ${bindingName}`);
+      continue;
+    }
+    await applyMigrationsToBinding({
+      bindingName,
+      statements,
+      files,
+      miniflarePort,
+      logger
+    });
+  }
+}
+
+// src/dev-server/miniflare-log.ts
+var ANSI_ESCAPE_REGEX = /\u001B\[[0-9;]*m/g;
+var COMPATIBILITY_DATE_FALLBACK_REGEX = /^The latest compatibility date supported by the installed Cloudflare Workers Runtime is "([^"]+)", but you've requested "([^"]+)"\. Falling back to "([^"]+)"\.\.\.$/;
+function normalizeMiniflareMessage(message) {
+  return message.replace(ANSI_ESCAPE_REGEX, "").replace(/\s+/g, " ").trim();
+}
+function formatCompatibilityDateFallbackNotice(message) {
+  const normalizedMessage = normalizeMiniflareMessage(message);
+  const match = COMPATIBILITY_DATE_FALLBACK_REGEX.exec(normalizedMessage);
+  if (!match) {
+    return null;
+  }
+  const [, _supportedDate, requestedDate, fallbackDate] = match;
+  return `Using latest supported Cloudflare Workers Runtime compatibility date ${fallbackDate} (requested ${requestedDate})`;
+}
+function createCompatibilityAwareMiniflareLog(BaseLog, level, logger) {
+  const log = new BaseLog(level);
+  const originalWarn = log.warn.bind(log);
+  const originalInfo = log.info.bind(log);
+  log.warn = (message) => {
+    const notice = formatCompatibilityDateFallbackNotice(message);
+    if (!notice) {
+      originalWarn(message);
+      return;
+    }
+    if (logger) {
+      logger.info(notice);
+      return;
+    }
+    originalInfo(notice);
+  };
+  return log;
+}
+
+// src/dev-server/miniflare-dev-config.ts
+import { resolve as resolve4 } from "pathe";
+
+// 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/dev-server/gateway-script.ts
+function getGatewayScript(wsRoutes = [], debug = false, appServiceBindingName = null) {
+  const wsRoutesJson = JSON.stringify(wsRoutes);
+  const appServiceBindingJson = JSON.stringify(appServiceBindingName);
+  return `
+${GATEWAY_RUNTIME_JS}
+
+// Bridge Gateway Worker — Dev Server
+// Dev-server-specific overlay on top of the shared GATEWAY_RUNTIME_JS:
+// WS route DO forwarding, D1 migration, email ingest, app-worker fallthrough.
+
+const DEBUG = ${debug}
+const log = (...args) => DEBUG && console.log('[Gateway]', ...args)
+
+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'
+
+		if (isWebSocket) {
+			const matchedRoute = matchWsRoute(url.pathname)
+			if (matchedRoute) {
+				return handleDoWebSocket(request, env, url, matchedRoute)
+			}
+			return handleBridgeWebSocket(request, env, ctx)
+		}
+
+		if (url.pathname.startsWith('/_devflare/transfer/')) {
+			return handleHttpTransfer(request, env, url)
+		}
+
+		if (url.pathname === '/_devflare/migrate' && request.method === 'POST') {
+			return handleMigration(request, env)
+		}
+
+		if (url.pathname === '/cdn-cgi/handler/email' && request.method === 'POST') {
+			return handleEmailIncoming(request, env, ctx, url)
+		}
+
+		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 })
+	}
+}
+
+async function handleMigration(request, env) {
+	try {
+		const { bindingName, statements, files } = await request.json()
+		log('Migration request for binding:', bindingName, 'statements count:', statements?.length, 'files:', files?.length, 'bindings:', Object.keys(env))
+		const db = env[bindingName]
+		if (!db) {
+			return Response.json({ error: 'Binding not found: ' + bindingName }, { status: 404 })
+		}
+
+		// Ledger-aware path: when the client sends per-file metadata, we track
+		// applied migrations in a \`_devflare_migrations\` table and skip files
+		// whose filename+sha256 is already recorded. Files with a drifting hash
+		// are reported as warnings and skipped — we refuse to re-apply to avoid
+		// stomping on user data.
+		if (Array.isArray(files) && files.length > 0) {
+			try {
+				await db.prepare(
+					'CREATE TABLE IF NOT EXISTS _devflare_migrations (filename TEXT PRIMARY KEY, applied_at TEXT NOT NULL, sha256 TEXT NOT NULL)'
+				).run()
+			} catch (error) {
+				const msg = error?.message || String(error)
+				log('Failed to ensure migration ledger:', msg)
+				return Response.json({ error: 'Failed to ensure migration ledger: ' + msg }, { status: 500 })
+			}
+
+			let ledgerRows = []
+			try {
+				const ledger = await db.prepare('SELECT filename, sha256 FROM _devflare_migrations').all()
+				ledgerRows = ledger?.results || []
+			} catch (error) {
+				log('Failed to read migration ledger:', error?.message || String(error))
+			}
+			const ledgerByFilename = new Map()
+			for (const row of ledgerRows) {
+				ledgerByFilename.set(row.filename, row.sha256)
+			}
+
+			const applied = []
+			const skipped = []
+			const warnings = []
+			const results = []
+
+			for (const file of files) {
+				const existingHash = ledgerByFilename.get(file.filename)
+				if (existingHash === file.sha256) {
+					skipped.push(file.filename)
+					continue
+				}
+				if (existingHash && existingHash !== file.sha256) {
+					warnings.push({
+						filename: file.filename,
+						message: 'sha256 drifted since last apply; skipped'
+					})
+					skipped.push(file.filename)
+					continue
+				}
+
+				let fileFailed = false
+				for (const sql of file.statements || []) {
+					try {
+						log('Running migration SQL:', sql.slice(0, 80))
+						await db.prepare(sql).run()
+						results.push({ sql: sql.slice(0, 50), success: true })
+					} 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 })
+							fileFailed = true
+						}
+					}
+				}
+
+				if (!fileFailed) {
+					try {
+						await db.prepare(
+							'INSERT OR REPLACE INTO _devflare_migrations (filename, applied_at, sha256) VALUES (?, ?, ?)'
+						).bind(file.filename, new Date().toISOString(), file.sha256).run()
+						applied.push(file.filename)
+					} catch (error) {
+						log('Failed to record migration in ledger:', error?.message || String(error))
+					}
+				}
+			}
+
+			return Response.json({ success: true, results, applied, skipped, warnings })
+		}
+
+		// Legacy path: flat statement list, no ledger tracking.
+		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 })
+				}
+			}
+		}
+
+		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 })
+	}
+}
+
+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 })
+	}
+}
+
+function matchWsRoute(pathname) {
+	for (const route of WS_ROUTES) {
+		if (pathname === route.pattern || pathname.startsWith(route.pattern + '?')) {
+			return route
+		}
+	}
+	return null
+}
+
+async function handleDoWebSocket(request, env, url, route) {
+	try {
+		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 })
+		}
+
+		const idValue = url.searchParams.get(route.idParam) || 'default'
+		const doId = namespace.idFromName(idValue)
+		const stub = namespace.get(doId)
+
+		const forwardUrl = new URL(route.forwardPath, url.origin)
+		url.searchParams.forEach((v, k) => forwardUrl.searchParams.set(k, v))
+
+		log('Forwarding WebSocket to DO:', route.doNamespace, 'id:', idValue, 'path:', forwardUrl.pathname)
+
+		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 })
+	}
+}
+`;
+}
+
+// src/dev-server/miniflare-worker-config.ts
+import { resolve as resolve2 } from "pathe";
+var DEFAULT_MODULE_RULES = [
+  { type: "ESModule", include: ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.mjs"] },
+  { type: "CommonJS", include: ["**/*.js", "**/*.cjs"] },
+  { type: "ESModule", include: ["**/*.jsx"] }
+];
+function toMiniflareModuleRule(rule) {
+  return {
+    type: rule.type,
+    include: rule.globs,
+    ...rule.fallthrough !== undefined && { fallthrough: rule.fallthrough }
+  };
+}
+function buildServiceBindings(bindings, 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;
+}
+function makeMiniflareWorker(context, options) {
+  const {
+    cwd,
+    loadedConfig,
+    bindings,
+    sendEmailConfig,
+    rateLimitsConfig,
+    versionMetadataConfig,
+    workerLoadersConfig,
+    mtlsCertificatesConfig,
+    dispatchNamespacesConfig,
+    workflowsConfig,
+    pipelinesConfig,
+    hyperdrivesConfig,
+    imagesConfig,
+    mediaConfig,
+    artifactsConfig,
+    aiSearchNamespacesConfig,
+    aiSearchInstancesConfig,
+    secretsStoreConfig,
+    queueProducers
+  } = context;
+  const baseFlags = loadedConfig.compatibilityFlags ?? [];
+  const compatFlags = baseFlags.includes("nodejs_compat") ? baseFlags : [...baseFlags, "nodejs_compat"];
+  const workerBindings = loadedConfig.vars ?? {};
+  const workerConfig = {
+    name: options.name,
+    modules: true,
+    compatibilityDate: loadedConfig.compatibilityDate,
+    compatibilityFlags: compatFlags,
+    ...bindings.kv && {
+      kvNamespaces: Object.fromEntries(Object.entries(bindings.kv).map(([bindingName, bindingConfig]) => {
+        return [bindingName, getLocalKVNamespaceIdentifier(bindingConfig)];
+      }))
+    },
+    ...bindings.r2 && { r2Buckets: bindings.r2 },
+    ...bindings.d1 && {
+      d1Databases: Object.fromEntries(Object.entries(bindings.d1).map(([bindingName, bindingConfig]) => {
+        return [bindingName, getLocalD1DatabaseIdentifier(bindingConfig)];
+      }))
+    },
+    ...Object.keys(workerBindings).length > 0 && { bindings: workerBindings },
+    ...sendEmailConfig && { email: sendEmailConfig },
+    ...rateLimitsConfig && { ratelimits: rateLimitsConfig },
+    ...versionMetadataConfig && { versionMetadata: versionMetadataConfig },
+    ...workerLoadersConfig && { workerLoaders: workerLoadersConfig },
+    ...mtlsCertificatesConfig && { mtlsCertificates: mtlsCertificatesConfig },
+    ...dispatchNamespacesConfig && { dispatchNamespaces: dispatchNamespacesConfig },
+    ...workflowsConfig && { workflows: workflowsConfig },
+    ...pipelinesConfig && { pipelines: pipelinesConfig },
+    ...hyperdrivesConfig && { hyperdrives: hyperdrivesConfig },
+    ...imagesConfig && { images: imagesConfig },
+    ...mediaConfig && { media: mediaConfig },
+    ...artifactsConfig && { artifacts: artifactsConfig },
+    ...aiSearchNamespacesConfig && { aiSearchNamespaces: aiSearchNamespacesConfig },
+    ...aiSearchInstancesConfig && { aiSearchInstances: aiSearchInstancesConfig },
+    ...secretsStoreConfig && { secretsStoreSecrets: secretsStoreConfig },
+    ...queueProducers && { queueProducers },
+    ...options.queueConsumers && { queueConsumers: options.queueConsumers },
+    ...options.triggers && { triggers: options.triggers }
+  };
+  if (options.scriptPath) {
+    workerConfig.scriptPath = options.scriptPath;
+    workerConfig.modulesRoot = loadedConfig.baseDir ? resolve2(cwd, loadedConfig.baseDir) : cwd;
+    workerConfig.modulesRules = [
+      ...loadedConfig.rules?.map(toMiniflareModuleRule) ?? [],
+      ...DEFAULT_MODULE_RULES
+    ];
+  }
+  if (options.script) {
+    workerConfig.script = options.script;
+  }
+  if (options.durableObjects && Object.keys(options.durableObjects).length > 0) {
+    workerConfig.durableObjects = options.durableObjects;
+  }
+  if (options.serviceBindings && Object.keys(options.serviceBindings).length > 0) {
+    workerConfig.serviceBindings = options.serviceBindings;
+  }
+  return workerConfig;
+}
+
+// src/dev-server/worker-surface-paths.ts
+import { dirname, resolve as resolve3 } from "pathe";
+var DEFAULT_TRANSPORT_ENTRY_FILES = [
+  "src/transport.ts",
+  "src/transport.js",
+  "src/transport.mts",
+  "src/transport.mjs"
+];
+var resolveMainWorkerSurfacePaths = resolveWorkerSurfacePaths;
+function addWorkerWatchRoots(roots, cwd, configuredPath, defaultEntries) {
+  if (configuredPath === false || configuredPath === null) {
+    return;
+  }
+  if (typeof configuredPath === "string" && configuredPath) {
+    roots.add(dirname(resolve3(cwd, configuredPath)));
+    return;
+  }
+  for (const defaultEntry of defaultEntries) {
+    roots.add(dirname(resolve3(cwd, defaultEntry)));
+  }
+}
+function collectWorkerWatchRoots(cwd, config, mainWorkerSurfacePaths) {
+  const roots = new Set;
+  for (const surfacePath of Object.values(mainWorkerSurfacePaths)) {
+    if (surfacePath) {
+      roots.add(dirname(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);
+  addWorkerWatchRoots(roots, cwd, config.files?.transport, DEFAULT_TRANSPORT_ENTRY_FILES);
+  const routeDirectory = getRouteDirectoryCandidate(cwd, config);
+  if (routeDirectory) {
+    roots.add(routeDirectory.absoluteDir);
+  }
+  return [...roots];
+}
+
+// src/dev-server/miniflare-dev-config.ts
+var INTERNAL_APP_SERVICE_BINDING = "__DEVFLARE_APP";
+function buildMiniflareDevConfig(input) {
+  const {
+    config: loadedConfig,
+    cwd,
+    miniflarePort,
+    persist,
+    enableVite,
+    debug,
+    mainWorkerSurfacePaths,
+    mainWorkerRoutes,
+    mainWorkerScriptPath,
+    bundledMainWorkerScriptPath,
+    browserShimPort,
+    doResult,
+    logger
+  } = input;
+  const bindings = loadedConfig.bindings ?? {};
+  const persistPath = resolve4(cwd, ".devflare/data");
+  const appWorkerName = loadedConfig.name;
+  const shouldRunMainWorker = !enableVite && (hasWorkerSurfacePaths(mainWorkerSurfacePaths) || Boolean(mainWorkerRoutes?.routes.length));
+  const queueProducers = buildQueueProducers(bindings);
+  const queueConsumers = buildQueueConsumers(bindings);
+  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,
+    workflowsPersist: persist ? `${persistPath}/workflows` : undefined,
+    imagesPersist: persist ? `${persistPath}/images` : undefined
+  };
+  const createServiceBindings = (extraBindings = {}) => buildServiceBindings(bindings, extraBindings);
+  const sendEmailConfig = buildSendEmailConfig(bindings);
+  const rateLimitsConfig = buildRateLimitsConfig(bindings);
+  const versionMetadataConfig = buildVersionMetadataConfig(bindings);
+  const workerLoadersConfig = buildWorkerLoadersConfig(bindings);
+  const mtlsCertificatesConfig = buildMtlsCertificatesConfig(bindings);
+  const dispatchNamespacesConfig = buildDispatchNamespacesConfig(bindings);
+  const workflowsConfig = buildWorkflowsConfig(bindings);
+  const pipelinesConfig = buildPipelinesConfig(bindings);
+  const hyperdrivesConfig = buildHyperdrivesConfig(bindings);
+  const imagesConfig = buildImagesConfig(bindings);
+  const mediaConfig = buildMediaConfig(bindings);
+  const artifactsConfig = buildArtifactsConfig(bindings);
+  const aiSearchNamespacesConfig = buildAiSearchNamespacesConfig(bindings);
+  const aiSearchInstancesConfig = buildAiSearchInstancesConfig(bindings);
+  const secretsStoreConfig = buildSecretsStoreConfig(bindings);
+  const workerContext = {
+    cwd,
+    loadedConfig,
+    bindings,
+    sendEmailConfig,
+    rateLimitsConfig,
+    versionMetadataConfig,
+    workerLoadersConfig,
+    mtlsCertificatesConfig,
+    dispatchNamespacesConfig,
+    workflowsConfig,
+    pipelinesConfig,
+    hyperdrivesConfig,
+    imagesConfig,
+    mediaConfig,
+    artifactsConfig,
+    aiSearchNamespacesConfig,
+    aiSearchInstancesConfig,
+    secretsStoreConfig,
+    queueProducers
+  };
+  const createWorkerConfig = (options) => makeMiniflareWorker(workerContext, options);
+  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 = getSingleBrowserBindingName(bindings.browser);
+  const needsBrowserWorker = Boolean(browserBindingName && (hasDurableObjectBundles || shouldRunMainWorker));
+  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]
+  };
+}
+
+// src/dev-server/runtime-stdio.ts
+import { createInterface } from "node:readline";
+function writeStdout(logger, message) {
+  if (typeof logger?.log === "function") {
+    logger.log(message);
+    return;
+  }
+  if (typeof logger?.info === "function") {
+    logger.info(message);
+    return;
+  }
+  console.log(message);
+}
+function writeStderr(logger, message) {
+  if (typeof logger?.error === "function") {
+    logger.error(message);
+    return;
+  }
+  console.error(message);
+}
+function createRuntimeStdioForwarder(logger) {
+  return (stdout, stderr) => {
+    createInterface({ input: stdout }).on("line", (data) => {
+      writeStdout(logger, data);
+    });
+    createInterface({ input: stderr }).on("line", (data) => {
+      writeStderr(logger, data);
+    });
+  };
+}
+
+// src/dev-server/vite-process.ts
+import { spawn } from "node:child_process";
+async function startViteProcess(options) {
+  const {
+    cwd,
+    vitePort,
+    miniflarePort,
+    generatedViteConfigPath,
+    logger
+  } = options;
+  const args = ["vite", "dev", "--port", String(vitePort)];
+  if (generatedViteConfigPath) {
+    args.push("--config", generatedViteConfigPath);
+  }
+  const 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 viteProcess;
+  }
+  logger?.warn("Vite process started, but the final local URL could not be confirmed yet");
+  return viteProcess;
+}
+
+// src/dev-server/reload-queue.ts
+function createReloadQueue({ reload, logger }) {
+  let running = null;
+  let pending = null;
+  async function runOnce() {
+    try {
+      await reload();
+    } catch (error) {
+      logger?.error("[devflare dev] reload failed:", error);
+    }
+  }
+  function schedule() {
+    if (!running) {
+      running = runOnce().finally(() => {
+        running = null;
+      });
+      return running;
+    }
+    if (!pending) {
+      const runningSnapshot = running;
+      pending = runningSnapshot.then(() => {
+        pending = null;
+        running = runOnce().finally(() => {
+          running = null;
+        });
+        return running;
+      });
+    }
+    return pending;
+  }
+  async function drain() {
+    while (running || pending) {
+      if (pending) {
+        await pending;
+      } else if (running) {
+        await running;
+      }
+    }
+  }
+  return { schedule, drain };
+}
+
+// src/dev-server/worker-source-watcher.ts
+async function startWorkerSourceWatcher(options) {
+  const { watchTargets, resolvedWorkerConfigPath, logger, onConfigChange, onWorkerChange } = options;
+  if (watchTargets.length === 0) {
+    return null;
+  }
+  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 flushPendingReload = async () => {
+    if (!pendingReloadPath) {
+      return;
+    }
+    const nextPath = pendingReloadPath;
+    pendingReloadPath = null;
+    await triggerReload(nextPath);
+  };
+  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 onConfigChange();
+        return;
+      }
+      logger?.info(`Worker source changed: ${filePath}`);
+      await onWorkerChange();
+    } catch (error) {
+      logger?.error("Worker source reload failed:", error);
+    } finally {
+      reloadInProgress = false;
+      await flushPendingReload();
+    }
+  };
+  const scheduleReload = (filePath) => {
+    if (reloadTimeout) {
+      clearTimeout(reloadTimeout);
+    }
+    reloadTimeout = setTimeout(() => {
+      reloadTimeout = null;
+      triggerReload(filePath);
+    }, 150);
+  };
+  const watcher = 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);
+  };
+  watcher.on("change", onFileEvent);
+  watcher.on("add", onFileEvent);
+  watcher.on("unlink", onFileEvent);
+  watcher.on("error", (error) => {
+    logger?.error("Worker source watcher error:", error);
+  });
+  await new Promise((resolvePromise, rejectPromise) => {
+    const handleReady = () => {
+      watcher.off("error", handleInitialError);
+      logger?.info(`Worker source watcher ready (${watchTargets.length} target(s))`);
+      resolvePromise();
+    };
+    const handleInitialError = (error) => {
+      watcher.off("ready", handleReady);
+      rejectPromise(error instanceof Error ? error : new Error(String(error)));
+    };
+    watcher.once("ready", handleReady);
+    watcher.once("error", handleInitialError);
+  });
+  return watcher;
+}
+async function applyWatcherTargetDiff(watcher, currentTargets, nextTargets) {
+  const nextSet = new Set(nextTargets);
+  const targetsToRemove = currentTargets.filter((t) => !nextSet.has(t));
+  const targetsToAdd = nextTargets.filter((t) => !currentTargets.includes(t));
+  if (targetsToRemove.length > 0) {
+    await watcher.unwatch(targetsToRemove);
+  }
+  if (targetsToAdd.length > 0) {
+    watcher.add(targetsToAdd);
+  }
+  return nextTargets;
+}
+
+// src/dev-server/server-startup-helpers.ts
+import { resolve as resolve5 } from "pathe";
+
+// 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 cachedExecutablePath = null;
+var DEFAULT_CHROME_FLAGS = [
+  "--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"
+];
+var NO_SANDBOX_FLAGS = [
+  "--no-sandbox",
+  "--disable-setuid-sandbox"
+];
+function resolveChromeFlags(options = {}) {
+  const flags = [...DEFAULT_CHROME_FLAGS];
+  if (options.allowNoSandbox) {
+    flags.unshift(...NO_SANDBOX_FLAGS);
+  }
+  return flags;
+}
+function createDownloadProgressLogger(logger, label = "Chrome") {
+  const state = {
+    started: false,
+    completed: false,
+    progress: { bytesReceived: 0, totalBytes: 0 }
+  };
+  return {
+    onProgress(downloadedBytes, totalBytes) {
+      if (state.completed)
+        return;
+      state.progress.bytesReceived = downloadedBytes;
+      state.progress.totalBytes = totalBytes;
+      if (!state.started) {
+        state.started = true;
+        logger?.info(`[BrowserShim] Downloading ${label}...`);
+      }
+      if (totalBytes > 0 && downloadedBytes >= totalBytes) {
+        state.completed = true;
+        logger?.info(`[BrowserShim] ${label} download complete`);
+      }
+    },
+    finalize() {
+      if (!state.started || state.completed)
+        return;
+      state.completed = true;
+      logger?.info(`[BrowserShim] ${label} download complete`);
+    },
+    get progress() {
+      return state.progress;
+    },
+    get started() {
+      return state.started;
+    },
+    get completed() {
+      return state.completed;
+    }
+  };
+}
+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 progressLogger = createDownloadProgressLogger(logger, "Chrome");
+  const installedBrowser = await install({
+    browser: BrowserType.CHROMEHEADLESSSHELL,
+    buildId,
+    cacheDir,
+    downloadProgressCallback: (downloadedBytes, totalBytes) => {
+      progressLogger.onProgress(downloadedBytes, totalBytes);
+    }
+  });
+  progressLogger.finalize();
+  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"),
+    allowNoSandbox = false
+  } = options;
+  const chromeLaunchArgs = resolveChromeFlags({ allowNoSandbox });
+  if (allowNoSandbox) {
+    logger?.warn("[BrowserShim] Launching Chrome with --no-sandbox (allowNoSandbox=true). " + "Only use this in trusted CI/rootless environments.");
+  }
+  let server = null;
+  let executablePath = null;
+  const sessions = new Map;
+  const history = [];
+  let WebSocketServerClass = null;
+  let WebSocketClass = null;
+  const maxRequestBodyBytes = 1024 * 1024;
+  function getRequestOrigin(req) {
+    const origin = req.headers.origin;
+    if (typeof origin === "string") {
+      return origin;
+    }
+    if (Array.isArray(origin) && origin[0]) {
+      return origin[0];
+    }
+    return null;
+  }
+  function isLoopbackOrigin(origin) {
+    try {
+      const url = new URL(origin);
+      return url.hostname === "127.0.0.1" || url.hostname === "localhost" || url.hostname === "::1" || url.hostname === "[::1]";
+    } catch {
+      return false;
+    }
+  }
+  function applyCorsHeaders(req, res) {
+    const origin = getRequestOrigin(req);
+    if (!origin) {
+      return true;
+    }
+    if (!isLoopbackOrigin(origin)) {
+      res.writeHead(403, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Forbidden origin" }));
+      return false;
+    }
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    res.setHeader("Vary", "Origin");
+    return true;
+  }
+  async function acquireSession(acquireOptions) {
+    if (!executablePath) {
+      throw new Error("Chrome not initialized");
+    }
+    const browser = await puppeteerCore.launch({
+      executablePath,
+      headless: true,
+      protocolTimeout: 120000,
+      args: chromeLaunchArgs
+    });
+    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 : ""}`);
+    if (!applyCorsHeaders(req, res)) {
+      return;
+    }
+    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((resolve5, reject) => {
+      const chunks = [];
+      let totalBytes = 0;
+      req.on("data", (chunk) => {
+        totalBytes += chunk.length;
+        if (totalBytes > maxRequestBodyBytes) {
+          req.destroy();
+          reject(new Error(`Request body exceeds ${maxRequestBodyBytes} bytes`));
+          return;
+        }
+        chunks.push(chunk);
+      });
+      req.on("end", () => resolve5(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 origin = getRequestOrigin(request);
+        if (origin && !isLoopbackOrigin(origin)) {
+          socket.write(`HTTP/1.1 403 Forbidden\r
+\r
+`);
+          socket.destroy();
+          return;
+        }
+        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((resolve5, reject) => {
+      server.on("error", reject);
+      server.listen(port, host, () => {
+        resolve5();
+      });
+    });
+    logger?.success(`Browser shim server ready on http://${host}:${port}`);
+  }
+  async function stop() {
+    for (const sessionId of Array.from(sessions.keys())) {
+      await closeSession(sessionId, 3, "ServerShutdown");
+    }
+    if (server) {
+      await new Promise((resolve5) => {
+        server.close(() => resolve5());
+      });
+      server = null;
+    }
+    logger?.info("Browser shim server stopped");
+  }
+  function getUrl() {
+    return `http://${host}:${port}`;
+  }
+  return {
+    start,
+    stop,
+    getUrl
+  };
+}
+// src/dev-server/server-startup-helpers.ts
+function logWorkerHandlerDetection(logger, enableVite, hasSurface, mainWorkerSurfacePaths, mainWorkerRoutes) {
+  if (enableVite)
+    return;
+  if (hasSurface) {
+    const detectedWorkerHandlers = Object.entries(mainWorkerSurfacePaths).filter(([, surfacePath]) => !!surfacePath).map(([surfaceName, surfacePath]) => `${surfaceName}=${surfacePath}`);
+    const detectedRouteHandlers = mainWorkerRoutes?.routes.map((route) => `route=${route.filePath}`) ?? [];
+    logger?.info(`Worker handlers detected: ${[...detectedWorkerHandlers, ...detectedRouteHandlers].join(", ")}`);
+  } else {
+    logger?.warn("No local worker handler entry was found for worker-only mode");
+  }
+}
+function logRemoteBindingRequirements(logger, remoteCheck) {
+  if (!remoteCheck.hasRemoteBindings)
+    return;
+  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("");
+  }
+}
+function formatErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function resolveWorkerConfigWatchPath(cwd, configPath) {
+  if (configPath) {
+    const explicitPath = resolve5(cwd, configPath);
+    const fs = await import("node:fs/promises");
+    try {
+      await fs.access(explicitPath);
+      return explicitPath;
+    } catch {}
+  }
+  return await resolveConfigPath(cwd) ?? null;
+}
+function logMiniflareConfigDiagnostics(logger, mfConfig) {
+  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)}`);
+    }
+  }
+}
+async function logMiniflareBindingDiagnostics(logger, miniflare, mfConfig) {
+  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 (error) {
+            logger?.debug(`Skipping binding diagnostics for ${w.name}: ${formatErrorMessage(error)}`);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    logger?.debug(`Skipping Miniflare binding diagnostics: ${formatErrorMessage(error)}`);
+  }
+}
+async function maybeStartBrowserShim(config, options) {
+  const browserBinding = getSingleBrowserBindingName(config.bindings?.browser);
+  if (!browserBinding)
+    return null;
+  options.logger?.info(`Starting Browser Rendering shim (binding: ${browserBinding})...`);
+  const shim = createBrowserShim({
+    port: options.browserShimPort,
+    host: "127.0.0.1",
+    logger: options.logger,
+    verbose: options.verbose
+  });
+  await shim.start();
+  return shim;
+}
+async function maybeStartDOBundler(config, options) {
+  const doPattern = config.files?.durableObjects;
+  if (typeof doPattern !== "string" || !doPattern) {
+    return { bundler: null, result: null };
+  }
+  const outDir = resolve5(options.cwd, ".devflare/do-bundles");
+  const bundler = createDOBundler({
+    cwd: options.cwd,
+    pattern: doPattern,
+    outDir,
+    rolldownOptions: config.rolldown?.options,
+    sourcemap: config.rolldown?.sourcemap,
+    minify: config.rolldown?.minify,
+    logger: options.logger,
+    onRebuild: options.onRebuild
+  });
+  const result = await bundler.build();
+  await bundler.watch();
+  return { bundler, result };
+}
+async function resolveViteIntegration(options) {
+  if (!options.enableViteRequested) {
+    return { enableVite: false, generatedViteConfigPath: null };
+  }
+  const viteMode = await resolveViteMode(options.cwd, { requested: true });
+  if (!viteMode.enableVite) {
+    options.logger?.info("Vite disabled: no vite config found for this package");
+    return { enableVite: false, generatedViteConfigPath: null };
+  }
+  const generatedViteConfigPath = await writeGeneratedViteConfig({
+    cwd: options.cwd,
+    configPath: options.configPath,
+    localConfigPath: viteMode.viteConfigPath,
+    bridgePort: options.miniflarePort
+  });
+  options.logger?.debug(`Generated Vite config → ${generatedViteConfigPath}`);
+  return { enableVite: true, generatedViteConfigPath };
+}
+
+// src/dev-server/dev-server-state.ts
+function createDevServerState(initial) {
+  return {
+    enableVite: initial.enableVite,
+    miniflare: null,
+    doBundler: null,
+    workerSourceWatcher: null,
+    workerWatchTargets: [],
+    viteProcess: null,
+    config: null,
+    browserShim: null,
+    browserShimPort: initial.browserShimPort ?? 8788,
+    mainWorkerSurfacePaths: {
+      fetch: null,
+      queue: null,
+      scheduled: null,
+      email: null,
+      tail: null
+    },
+    resolvedWorkerConfigPath: null,
+    mainWorkerScriptPath: null,
+    bundledMainWorkerScriptPath: null,
+    currentDoResult: null,
+    mainWorkerRoutes: null,
+    generatedViteConfigPath: null
+  };
+}
+async function disposeDevServerState(state) {
+  if (state.doBundler) {
+    await state.doBundler.close();
+    state.doBundler = null;
+  }
+  if (state.workerSourceWatcher) {
+    await state.workerSourceWatcher.close();
+    state.workerSourceWatcher = null;
+  }
+  if (state.miniflare) {
+    await state.miniflare.dispose();
+    state.miniflare = null;
+  }
+  if (state.viteProcess) {
+    await stopSpawnedProcessTree(state.viteProcess);
+    state.viteProcess = null;
+  }
+  if (state.browserShim) {
+    await state.browserShim.stop();
+    state.browserShim = null;
+  }
+  clearLocalSendEmailBindings();
+}
+
+// src/dev-server/server.ts
+function createDevServer(options) {
+  const {
+    cwd,
+    configPath,
+    vitePort = 5173,
+    miniflarePort = 8787,
+    enableVite: enableViteRequested = true,
+    persist = true,
+    logger,
+    verbose = false,
+    debug = process.env.DEVFLARE_DEBUG === "true"
+  } = options;
+  const state = createDevServerState({ enableVite: enableViteRequested });
+  const reloadQueue = createReloadQueue({
+    reload: async () => {
+      if (!state.miniflare)
+        return;
+      const { Log, LogLevel } = await import("miniflare");
+      const mfConfig = buildMiniflareConfig(state.currentDoResult);
+      mfConfig.log = createCompatibilityAwareMiniflareLog(Log, LogLevel.DEBUG, logger);
+      mfConfig.handleRuntimeStdio = createRuntimeStdioForwarder(logger);
+      logger?.info("Reloading Miniflare...");
+      await state.miniflare.setOptions(mfConfig);
+      logger?.success("Miniflare reloaded");
+    },
+    logger
+  });
+  async function bundleMainWorker() {
+    if (!state.mainWorkerScriptPath || !state.config) {
+      state.bundledMainWorkerScriptPath = null;
+      return;
+    }
+    state.bundledMainWorkerScriptPath = await bundleWorkerEntry({
+      cwd,
+      inputFile: state.mainWorkerScriptPath,
+      outFile: resolve6(cwd, ".devflare", "worker-entrypoints", "main.js"),
+      rolldownOptions: state.config.rolldown?.options,
+      sourcemap: state.config.rolldown?.sourcemap,
+      minify: state.config.rolldown?.minify,
+      logger
+    });
+    logger?.debug(`Bundled main worker → ${state.bundledMainWorkerScriptPath}`);
+  }
+  function buildMiniflareConfig(doResult) {
+    if (!state.config)
+      throw new Error("Config not loaded");
+    return buildMiniflareDevConfig({
+      config: state.config,
+      cwd,
+      miniflarePort,
+      persist,
+      enableVite: state.enableVite,
+      debug,
+      mainWorkerSurfacePaths: state.mainWorkerSurfacePaths,
+      mainWorkerRoutes: state.mainWorkerRoutes,
+      mainWorkerScriptPath: state.mainWorkerScriptPath,
+      bundledMainWorkerScriptPath: state.bundledMainWorkerScriptPath,
+      browserShimPort: state.browserShimPort,
+      doResult,
+      logger
+    });
+  }
+  async function startMiniflare(doResult) {
+    const { Miniflare, Log, LogLevel } = await import("miniflare");
+    const mfConfig = buildMiniflareConfig(doResult);
+    mfConfig.log = createCompatibilityAwareMiniflareLog(Log, LogLevel.DEBUG, logger);
+    mfConfig.handleRuntimeStdio = createRuntimeStdioForwarder(logger);
+    const shouldLogMiniflareDiagnostics = verbose || debug;
+    if (shouldLogMiniflareDiagnostics) {
+      logMiniflareConfigDiagnostics(logger, mfConfig);
+    }
+    state.miniflare = new Miniflare(mfConfig);
+    await state.miniflare.ready;
+    logger?.success(`Miniflare ready on http://localhost:${miniflarePort}`);
+    if (shouldLogMiniflareDiagnostics) {
+      await logMiniflareBindingDiagnostics(logger, state.miniflare, mfConfig);
+    }
+  }
+  async function reloadMiniflare(doResult) {
+    state.currentDoResult = doResult;
+    await reloadQueue.schedule();
+  }
+  async function refreshWorkerOnlySurfaceState() {
+    if (!state.config) {
+      return;
+    }
+    state.mainWorkerSurfacePaths = await resolveMainWorkerSurfacePaths(cwd, state.config);
+    state.mainWorkerRoutes = await discoverRoutes(cwd, state.config);
+    const composedMainEntry = await prepareComposedWorkerEntrypoint(cwd, state.config, undefined, {
+      devInternalEmail: true
+    });
+    state.mainWorkerScriptPath = composedMainEntry ? composedMainEntry : null;
+    if (state.mainWorkerScriptPath) {
+      await bundleMainWorker();
+    } else {
+      state.bundledMainWorkerScriptPath = null;
+    }
+    await syncWorkerWatchTargets();
+  }
+  function getWorkerWatchTargets() {
+    if (state.enableVite || !state.config) {
+      return [];
+    }
+    const targets = collectWorkerWatchRoots(cwd, state.config, state.mainWorkerSurfacePaths);
+    if (state.resolvedWorkerConfigPath) {
+      targets.push(state.resolvedWorkerConfigPath);
+    }
+    return [...new Set(targets)];
+  }
+  async function syncWorkerWatchTargets() {
+    if (!state.workerSourceWatcher) {
+      return;
+    }
+    state.workerWatchTargets = await applyWatcherTargetDiff(state.workerSourceWatcher, state.workerWatchTargets, getWorkerWatchTargets());
+  }
+  async function reloadWorkerOnlyConfig() {
+    await loadRuntimeConfig();
+    if (!state.config) {
+      return;
+    }
+    setLocalSendEmailBindings(state.config.bindings?.sendEmail ?? {});
+    await refreshWorkerOnlySurfaceState();
+    await reloadMiniflare(state.currentDoResult);
+  }
+  async function loadRuntimeConfig() {
+    const loadedConfig = await loadConfig({ cwd, configFile: configPath });
+    state.resolvedWorkerConfigPath = await resolveWorkerConfigWatchPath(cwd, configPath);
+    state.config = await applyLocalDevVarsToConfig(loadedConfig, {
+      cwd,
+      configPath: state.resolvedWorkerConfigPath ?? undefined
+    });
+  }
+  async function startWorkerSourceWatcher2() {
+    if (state.enableVite || !state.config) {
+      return;
+    }
+    const watchTargets = getWorkerWatchTargets();
+    if (watchTargets.length === 0) {
+      return;
+    }
+    state.workerWatchTargets = watchTargets;
+    state.workerSourceWatcher = await startWorkerSourceWatcher({
+      watchTargets,
+      resolvedWorkerConfigPath: state.resolvedWorkerConfigPath,
+      logger,
+      onConfigChange: reloadWorkerOnlyConfig,
+      onWorkerChange: async () => {
+        await refreshWorkerOnlySurfaceState();
+        await reloadMiniflare(state.currentDoResult);
+      }
+    });
+  }
+  async function start() {
+    logger?.info("Starting unified dev server...");
+    await loadRuntimeConfig();
+    if (!state.config) {
+      throw new Error("Config not loaded");
+    }
+    setLocalSendEmailBindings(state.config.bindings?.sendEmail ?? {});
+    logger?.debug("Loaded config:", state.config.name);
+    const viteIntegration = await resolveViteIntegration({
+      cwd,
+      configPath,
+      miniflarePort,
+      enableViteRequested: state.enableVite,
+      logger
+    });
+    state.enableVite = viteIntegration.enableVite;
+    state.generatedViteConfigPath = viteIntegration.generatedViteConfigPath;
+    await refreshWorkerOnlySurfaceState();
+    if (!state.enableVite && (hasWorkerSurfacePaths(state.mainWorkerSurfacePaths) || Boolean(state.mainWorkerRoutes?.routes.length))) {
+      logWorkerHandlerDetection(logger, state.enableVite, true, state.mainWorkerSurfacePaths, state.mainWorkerRoutes);
+    } else if (!state.enableVite) {
+      logWorkerHandlerDetection(logger, state.enableVite, false, state.mainWorkerSurfacePaths, state.mainWorkerRoutes);
+    }
+    const remoteCheck = await checkRemoteBindingRequirements(state.config);
+    logRemoteBindingRequirements(logger, remoteCheck);
+    state.browserShim = await maybeStartBrowserShim(state.config, { browserShimPort: state.browserShimPort, logger, verbose });
+    const doInit = await maybeStartDOBundler(state.config, {
+      cwd,
+      logger,
+      onRebuild: async (result) => {
+        await reloadMiniflare(result);
+      }
+    });
+    state.doBundler = doInit.bundler;
+    const doResult = doInit.result;
+    state.currentDoResult = doResult;
+    await startMiniflare(doResult);
+    await startWorkerSourceWatcher2();
+    if (state.enableVite) {
+      state.viteProcess = await startViteProcess({
+        cwd,
+        vitePort,
+        miniflarePort,
+        generatedViteConfigPath: state.generatedViteConfigPath,
+        logger
+      });
+    } else {
+      logger?.info("Vite startup skipped (no effective Vite config found for this package)");
+    }
+    await new Promise((r) => setTimeout(r, 1000));
+    await runD1Migrations({ cwd, config: state.config, miniflarePort, logger });
+  }
+  async function stop() {
+    await disposeDevServerState(state);
+  }
+  function getMiniflare() {
+    return state.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 = resolve7(cwd, ".log");
+  } else {
+    const now = new Date;
+    const timestamp = now.toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
+    logPath = resolve7(cwd, `.log-${timestamp}`);
+  }
+  const fileStream = fs.createWriteStream(logPath, { flags: "w" });
+  const ansiRegex = /\x1b\[[0-9;]*m/g;
+  return {
+    path: logPath,
+    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 theme = createCliTheme(parsed.options);
+  const config = await loadConfig({ cwd, configFile: configPath });
+  const viteProject = resolveEffectiveViteProject(await detectViteProject(cwd), config);
+  const logWriter = await createLogWriter(cwd, {
+    log: logEnabled,
+    logTemp: logTempEnabled
+  });
+  if (logWriter) {
+    const logFile = relative(cwd, logWriter.path) || ".log";
+    logLine(logger, `${dim("logging", theme)} ${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.log, wrapLog(devLogger.log.bind(devLogger)));
+    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 {
+    logLine(logger);
+    if (viteProject.shouldStartVite) {
+      logLine(logger, `${cyanBold("dev", theme)} ${dim("Unified Dev Server", theme)}`);
+      logLine(logger, "   ├─ Vite: Full HMR for frontend");
+      logLine(logger, "   ├─ Miniflare: All Cloudflare bindings");
+      logLine(logger, "   ├─ Rolldown: Worker + DO bundling with watch");
+      logLine(logger, "   └─ Bridge: WebSocket RPC connection");
+    } else {
+      logLine(logger, `${cyanBold("dev", theme)} ${dim("Worker Dev Server", theme)}`);
+      logLine(logger, "   ├─ Miniflare: All Cloudflare bindings");
+      logLine(logger, "   ├─ Rolldown: Worker + DO bundling with watch");
+      logLine(logger, "   └─ Vite: Disabled (no effective Vite config found)");
+      if (viteProject.wantsViteIntegration) {
+        logger.warn("Vite-related settings were detected, but no effective Vite config was available");
+        logger.warn("Skipping Vite startup and running in worker-only mode");
+      }
+    }
+    logLine(logger);
+    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);
+      }
+      logLine(logger);
+      logLine(logger, `${yellow("dev", theme)} ${dim("Shutting down…", theme)}`);
+      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
+};