devflare 1.0.0-next.39 → 1.0.0-next.40

package/dist/dev-x8zr249a.js

@@ -1,3569 +0,0 @@
-import {
-  buildLocalSecretWrappedBindingConfig
-} from "./index-kcp7y951.js";
-import {
-  bundleWorkerEntry,
-  createDOBundler
-} from "./index-5hy7jmv3.js";
-import {
-  detectViteProject,
-  resolveViteMode,
-  stopSpawnedProcessTree,
-  waitForViteReady
-} from "./index-zdd0d9qa.js";
-import {
-  clearLocalSendEmailBindings,
-  setLocalSendEmailBindings
-} from "./index-n4xkaymm.js";
-import {
-  createCliTheme,
-  cyanBold,
-  dim,
-  logLine,
-  yellow
-} from "./index-maw0jjnn.js";
-import"./index-3t6rypgc.js";
-import {
-  DEFAULT_EMAIL_ENTRY_FILES,
-  DEFAULT_FETCH_ENTRY_FILES,
-  DEFAULT_QUEUE_ENTRY_FILES,
-  DEFAULT_SCHEDULED_ENTRY_FILES,
-  buildAiSearchInstancesConfig,
-  buildAiSearchNamespacesConfig,
-  buildArtifactsConfig,
-  buildDispatchNamespacesConfig,
-  buildHyperdrivesConfig,
-  buildImagesConfig,
-  buildMediaConfig,
-  buildMtlsCertificatesConfig,
-  buildPipelinesConfig,
-  buildQueueConsumers,
-  buildQueueProducers,
-  buildRateLimitsConfig,
-  buildSecretsStoreConfig,
-  buildSendEmailConfig,
-  buildVersionMetadataConfig,
-  buildWorkerLoadersConfig,
-  buildWorkflowsConfig,
-  discoverRoutes,
-  getRouteDirectoryCandidate,
-  hasWorkerSurfacePaths,
-  prepareComposedWorkerEntrypoint,
-  resolveEffectiveViteProject,
-  resolveServiceBindings,
-  resolveWorkerSurfacePaths,
-  writeGeneratedViteConfig
-} from "./index-cv4cvrxe.js";
-import"./index-3cpzsr47.js";
-import {
-  DEFAULT_WORKFLOW_PATTERN,
-  findFiles
-} from "./index-5dkjffqz.js";
-import {
-  applyLocalDevVarsToConfig
-} from "./index-mek9msfv.js";
-import {
-  EnvVarResolutionError,
-  getDevflareDotenvPaths,
-  getLocalD1DatabaseIdentifier,
-  getLocalKVNamespaceIdentifier,
-  getSingleBrowserBindingName,
-  loadConfig,
-  normalizeWorkflowBinding,
-  resolveConfigEnvVars,
-  resolveConfigPath
-} from "./index-x8s9rwfh.js";
-import"./index-h7r11y4a.js";
-import"./index-04wh9bxx.js";
-import"./index-7m557715.js";
-import"./index-4mmpccrb.js";
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/cli/commands/dev.ts
-import { createConsola } from "consola";
-import { relative as relative2, resolve as resolve8 } from "pathe";
-
-// src/dev-server/server.ts
-import { dirname as dirname3, resolve as resolve7 } 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/workflows/local-workflow-entrypoints.ts
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { join, relative, resolve } from "pathe";
-function findExportedClasses(code) {
-  const classes = [];
-  const classPattern = /export\s+class\s+(\w+)/g;
-  let match = classPattern.exec(code);
-  while (match !== null) {
-    classes.push(match[1]);
-    match = classPattern.exec(code);
-  }
-  return classes;
-}
-function toImportSpecifier(fromDir, filePath) {
-  const relativePath = relative(fromDir, filePath).replace(/\\/g, "/");
-  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-}
-async function discoverWorkflowClasses(config, configDir) {
-  const classToFilePath = new Map;
-  const workflowPatternConfig = config.files?.workflows;
-  const workflowPattern = typeof workflowPatternConfig === "string" ? workflowPatternConfig : DEFAULT_WORKFLOW_PATTERN;
-  if (workflowPatternConfig === false) {
-    return classToFilePath;
-  }
-  const files = await findFiles(workflowPattern, { cwd: configDir });
-  for (const filePath of files) {
-    try {
-      const code = await readFile(filePath, "utf-8");
-      for (const className of findExportedClasses(code)) {
-        classToFilePath.set(className, filePath);
-      }
-    } catch {}
-  }
-  return classToFilePath;
-}
-async function resolveLocalWorkflowEntrypoints(config, configDir) {
-  const workflows = config.bindings?.workflows;
-  if (!workflows || Object.keys(workflows).length === 0) {
-    return [];
-  }
-  const classToFilePath = await discoverWorkflowClasses(config, configDir);
-  const entrypoints = [];
-  for (const [bindingName, binding] of Object.entries(workflows)) {
-    const normalized = normalizeWorkflowBinding(binding);
-    if (normalized.scriptName) {
-      continue;
-    }
-    const scriptPath = classToFilePath.get(normalized.className);
-    if (!scriptPath) {
-      throw new Error(`Workflow binding ${bindingName} (className: '${normalized.className}') not found.
-` + `Either set files.workflows to match the workflow source file, or set scriptName when the workflow lives in another worker.`);
-    }
-    entrypoints.push({
-      bindingName,
-      className: normalized.className,
-      scriptPath
-    });
-  }
-  return entrypoints;
-}
-function buildWorkflowVirtualEntry(entrypoints, entryDir) {
-  const imports = entrypoints.map((entrypoint, index) => {
-    const importName = `__DevflareWorkflow${index}`;
-    const importPath = toImportSpecifier(entryDir, entrypoint.scriptPath);
-    return {
-      importName,
-      className: entrypoint.className,
-      line: `import { ${entrypoint.className} as ${importName} } from '${importPath}'`
-    };
-  });
-  const exports = imports.map((entrypoint) => {
-    return `export { ${entrypoint.importName} as ${entrypoint.className} }`;
-  });
-  return [...imports.map((entrypoint) => entrypoint.line), "", ...exports].join(`
-`);
-}
-async function bundleWorkflowEntrypointScript(config, configDir, options = {}) {
-  const entrypoints = await resolveLocalWorkflowEntrypoints(config, configDir);
-  if (entrypoints.length === 0) {
-    return "";
-  }
-  const entryDir = resolve(configDir, ".devflare", "workflow-entrypoints");
-  const entryPath = join(entryDir, "__entry.ts");
-  const outFile = join(entryDir, "index.js");
-  await mkdir(entryDir, { recursive: true });
-  await writeFile(entryPath, buildWorkflowVirtualEntry(entrypoints, entryDir));
-  await bundleWorkerEntry({
-    cwd: configDir,
-    inputFile: entryPath,
-    outFile,
-    rolldownOptions: config.rolldown?.options,
-    sourcemap: config.rolldown?.sourcemap,
-    minify: config.rolldown?.minify,
-    logger: options.logger
-  });
-  return await readFile(outFile, "utf-8");
-}
-
-// src/dev-server/d1-migrations.ts
-import { createHash } from "node:crypto";
-import { resolve as resolve2 } 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 = resolve2(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(resolve2(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 = resolve2(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(resolve2(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 "([^"]+)"\.\.\.$/;
-var MINIFLARE_LOG_LEVEL_FALLBACKS = {
-  WARN: 2,
-  DEBUG: 4
-};
-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 resolveMiniflareLogLevel(logLevel, levelName) {
-  return logLevel?.[levelName] ?? MINIFLARE_LOG_LEVEL_FALLBACKS[levelName];
-}
-function createMiniflareLog(BaseLog, logLevel, levelName, logger) {
-  if (!BaseLog) {
-    return;
-  }
-  return createCompatibilityAwareMiniflareLog(BaseLog, resolveMiniflareLogLevel(logLevel, levelName), logger);
-}
-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/shims/local-media-bindings.ts
-var LOCAL_MEDIA_BINDING_SCRIPT = `
-import { RpcTarget, WorkerEntrypoint } from 'cloudflare:workers'
-
-function emptyStream() {
-	return new ReadableStream({
-		start(controller) {
-			controller.close()
-		}
-	})
-}
-
-function normalizeContentType(value, fallback) {
-	if (typeof value !== 'string' || value.length === 0) return fallback
-	if (value.includes('/')) return value
-	if (value === 'jpg') return 'image/jpeg'
-	if (value === 'jpeg') return 'image/jpeg'
-	if (value === 'png') return 'image/png'
-	if (value === 'webp') return 'image/webp'
-	if (value === 'avif') return 'image/avif'
-	if (value === 'mp4') return 'video/mp4'
-	return value
-}
-
-async function readBytes(stream) {
-	return await new Response(stream || emptyStream()).arrayBuffer()
-}
-
-function streamFromBytes(bytes) {
-	return new Response(bytes.slice(0)).body || emptyStream()
-}
-
-function createBodyReader(bytes) {
-	return function takeBody() {
-		return streamFromBytes(bytes)
-	}
-}
-
-class LocalImageResult extends RpcTarget {
-	constructor(takeBody, contentType) {
-		super()
-		this.takeBody = takeBody
-		this.contentTypeValue = contentType
-	}
-
-	response() {
-		return new Response(this.takeBody(), {
-			headers: { 'Content-Type': this.contentTypeValue }
-		})
-	}
-
-	contentType() {
-		return this.contentTypeValue
-	}
-
-	image() {
-		return this.takeBody()
-	}
-}
-
-class LocalImageTransformer extends RpcTarget {
-	constructor(bytes) {
-		super()
-		this.takeBody = createBodyReader(bytes)
-	}
-
-	transform() {
-		return this
-	}
-
-	draw() {
-		return this
-	}
-
-	async output(options = {}) {
-		return new LocalImageResult(
-			this.takeBody,
-			normalizeContentType(options.format, 'image/png')
-		)
-	}
-}
-
-function createHostedImagesBinding() {
-	const unsupported = () => {
-		throw new Error('Devflare local Images hosted API is not implemented. Use the transform/info APIs locally, or connect to Cloudflare for hosted image storage.')
-	}
-	return {
-		image() {
-			return {
-				details: unsupported,
-				bytes: unsupported,
-				update: unsupported,
-				delete: unsupported
-			}
-		},
-		upload: unsupported,
-		list: unsupported
-	}
-}
-
-export class LocalImagesBinding extends WorkerEntrypoint {
-	async info(stream) {
-		const bytes = await readBytes(stream)
-		return {
-			format: 'image/png',
-			fileSize: bytes.byteLength,
-			width: 1,
-			height: 1
-		}
-	}
-
-	async input(stream) {
-		return new LocalImageTransformer(await readBytes(stream))
-	}
-
-	get hosted() {
-		return createHostedImagesBinding()
-	}
-}
-
-class LocalMediaResult extends RpcTarget {
-	constructor(takeBody, contentType) {
-		super()
-		this.takeBody = takeBody
-		this.contentTypeValue = contentType
-	}
-
-	async media() {
-		return this.takeBody()
-	}
-
-	async response() {
-		return new Response(this.takeBody(), {
-			headers: { 'Content-Type': this.contentTypeValue }
-		})
-	}
-
-	async contentType() {
-		return this.contentTypeValue
-	}
-}
-
-class LocalMediaTransformationGenerator extends RpcTarget {
-	constructor(takeBody) {
-		super()
-		this.takeBody = takeBody
-	}
-
-	output(options = {}) {
-		return new LocalMediaResult(
-			this.takeBody,
-			normalizeContentType(options.format, 'video/mp4')
-		)
-	}
-}
-
-class LocalMediaTransformer extends RpcTarget {
-	constructor(bytes) {
-		super()
-		this.takeBody = createBodyReader(bytes)
-	}
-
-	transform() {
-		return new LocalMediaTransformationGenerator(this.takeBody)
-	}
-
-	output(options = {}) {
-		return new LocalMediaResult(
-			this.takeBody,
-			normalizeContentType(options.format, 'video/mp4')
-		)
-	}
-}
-
-export class LocalMediaBinding extends WorkerEntrypoint {
-	async input(stream) {
-		return new LocalMediaTransformer(await readBytes(stream))
-	}
-}
-
-export default {
-	fetch() {
-		return new Response('Devflare local Images/Media binding')
-	}
-}
-`;
-function toLocalShimWorkerName(kind, bindingName, index) {
-  const slug = bindingName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || kind;
-  return `devflare-local-${kind}-${index}-${slug}`;
-}
-function getEntrypoint(kind) {
-  return kind === "images" ? "LocalImagesBinding" : "LocalMediaBinding";
-}
-function buildLocalBindingShimServiceConfig(config) {
-  const entries = [
-    ...Object.keys(config.bindings?.images ?? {}).map((bindingName) => ({
-      bindingName,
-      kind: "images"
-    })),
-    ...Object.keys(config.bindings?.media ?? {}).map((bindingName) => ({
-      bindingName,
-      kind: "media"
-    }))
-  ];
-  return {
-    localBindingNames: entries.map((entry) => entry.bindingName),
-    serviceBindings: Object.fromEntries(entries.map((entry, index) => {
-      const workerName = toLocalShimWorkerName(entry.kind, entry.bindingName, index);
-      return [
-        entry.bindingName,
-        {
-          name: workerName,
-          entrypoint: getEntrypoint(entry.kind)
-        }
-      ];
-    })),
-    workers: entries.map((entry, index) => ({
-      name: toLocalShimWorkerName(entry.kind, entry.bindingName, index),
-      modules: true,
-      script: LOCAL_MEDIA_BINDING_SCRIPT,
-      compatibilityDate: config.compatibilityDate ?? "2025-01-01",
-      ...config.compatibilityFlags && { compatibilityFlags: config.compatibilityFlags }
-    }))
-  };
-}
-
-// src/bridge/gateway-runtime.ts
-var GATEWAY_RUNTIME_JS = `
-const RAW_EMAIL = 'EmailMessage::raw'
-
-// Inline body cap for proxied DO/service-fetch responses. Matches
-// HTTP_TRANSFER_THRESHOLD in wire.ts (512 KB). A larger body would exceed
-// workerd's ~1 MB WebSocket message limit once base64-encoded into the rpc.ok
-// frame, so it is rejected with a clear error rather than silently truncated.
-const HTTP_TRANSFER_THRESHOLD = 512 * 1024
-
-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
-}
-
-// Binary WsData frame codec (10-byte header: kind:u8, id:u32 LE, seq:u32 LE,
-// flags:u8 + payload). MUST match wire.ts encodeBinaryFrame/decodeBinaryFrame so
-// the bridge client and this gateway agree on the WS-data wire format
-// (BinaryKind.WsData = 2, BinaryFlags.TEXT = 2).
-function encodeWsDataFrame(wid, flags, payload) {
-	const frame = new Uint8Array(10 + payload.byteLength)
-	const view = new DataView(frame.buffer)
-	view.setUint8(0, 2)
-	view.setUint32(1, wid, true)
-	view.setUint32(5, 0, true)
-	view.setUint8(9, flags)
-	frame.set(payload, 10)
-	return frame
-}
-
-function decodeWsDataFrame(buffer) {
-	const bytes = new Uint8Array(buffer)
-	if (bytes.byteLength < 10) return null
-	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
-	return {
-		kind: view.getUint8(0),
-		id: view.getUint32(1, true),
-		flags: view.getUint8(9),
-		payload: bytes.subarray(10)
-	}
-}
-
-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,
-		delimitedPrefixes: result.delimitedPrefixes
-	}
-}
-
-async function serializeResponse(response) {
-	let body = null
-	if (response.body) {
-		const bytes = await response.arrayBuffer()
-		if (bytes.byteLength > HTTP_TRANSFER_THRESHOLD) {
-			throw new Error(
-				'[devflare][bridge] Response body (' + bytes.byteLength + ' bytes) exceeds the '
-				+ HTTP_TRANSFER_THRESHOLD + '-byte inline limit. DO and service-binding fetch responses '
-				+ 'are delivered inline over the bridge WebSocket and cannot be streamed locally; keep '
-				+ 'proxied response bodies under the limit (large R2 objects are exempt — read them through '
-				+ 'the R2 binding, which uses the HTTP transfer side-channel).'
-			)
-		}
-		if (bytes.byteLength > 0) {
-			body = { type: 'bytes', data: arrayBufferToBase64(bytes) }
-		}
-	}
-	return {
-		status: response.status,
-		statusText: response.statusText,
-		headers: [...response.headers.entries()],
-		body
-	}
-}
-
-function deserializeRequest(serializedReq) {
-	return new Request(serializedReq.url, {
-		method: serializedReq.method,
-		headers: serializedReq.headers,
-		body: serializedReq.body?.type === 'bytes'
-			? base64ToArrayBuffer(serializedReq.body.data)
-			: undefined,
-		redirect: serializedReq.redirect
-	})
-}
-
-function createEmailMessageRaw(raw) {
-	if (typeof raw === 'string' || raw instanceof ReadableStream) {
-		return raw
-	}
-	if (raw instanceof ArrayBuffer || raw instanceof Uint8Array) {
-		return new Response(raw).body
-	}
-	throw new Error('Unsupported EmailMessage raw payload')
-}
-
-function isDurableObjectNamespace(binding) {
-	return !!binding
-		&& typeof binding.idFromName === 'function'
-		&& typeof binding.idFromString === 'function'
-		&& typeof binding.newUniqueId === 'function'
-}
-
-/**
- * Resolve a (possibly jurisdiction-scoped) DurableObjectNamespace.
- * Forwards the jurisdiction faithfully when the binding supports it
- * (real Cloudflare), and degrades to the plain binding otherwise
- * (miniflare/workerd local emulation, which does not pin jurisdictions).
- */
-function resolveDoNamespace(binding, jurisdiction) {
-	if (jurisdiction && typeof binding.jurisdiction === 'function') {
-		return binding.jurisdiction(jurisdiction)
-	}
-	return binding
-}
-
-/**
- * Execute an RPC method against the gateway's bindings.
- *
- * Method format: "binding.operation". Operations must be namespaced by
- * binding kind (e.g. "kv.get", "r2.head", "d1.stmt.first", "do.fetch",
- * "service.fetch", "queue.send", "email.send", "ai.run"). Bare verbs and the legacy
- * "stmt.*" / "stub.*" sub-prefixes were removed in B3-final and now throw.
- * Method vocabulary must stay in sync with the canonical server in
- * src/bridge/server.ts.
- */
-async function executeRpcMethod(method, params, env, _ctx) {
-	const parts = method.split('.')
-	if (parts.length < 2) throw new Error('Invalid method format: ' + method)
-
-	const bindingName = parts[0]
-	const operation = parts.slice(1).join('.')
-	const binding = env[bindingName]
-
-	if (!binding) throw new Error('Binding not found: ' + bindingName)
-
-	const isNamespaced =
-		operation.indexOf('kv.') === 0 ||
-		operation.indexOf('r2.') === 0 ||
-		operation.indexOf('d1.') === 0 ||
-		operation.indexOf('do.') === 0 ||
-		operation.indexOf('service.') === 0 ||
-		operation.indexOf('queue.') === 0 ||
-		operation.indexOf('email.') === 0 ||
-		operation.indexOf('ai.') === 0 ||
-		operation.indexOf('workflow.') === 0 ||
-		operation.indexOf('var.') === 0
-	if (!isNamespaced) {
-		throw new Error(createUnsupportedBridgeOperationErrorMessage(bindingName, operation))
-	}
-
-	// KV
-	if (operation === 'kv.get') return binding.get(params[0], params[1])
-	if (operation === 'kv.put') return binding.put(params[0], params[1], params[2])
-	if (operation === 'kv.delete') return binding.delete(params[0])
-	if (operation === 'kv.list') return binding.list(params[0])
-	if (operation === 'kv.getWithMetadata') return binding.getWithMetadata(params[0], params[1])
-
-	// DO get (returns DOStub reference)
-	if (operation === 'do.get') {
-		return { __type: 'DOStub', binding: bindingName, id: params[0] }
-	}
-
-	// R2
-	if (operation === 'r2.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') {
-		let value = params[1]
-		if (value && typeof value === 'object') {
-			if (value.__type === 'ArrayBuffer' || 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
-	if (operation === 'd1.exec') return binding.exec(params[0])
-	if (operation === 'd1.batch') {
-		const statements = params[0].map((s) => binding.prepare(s.sql).bind(...(s.bindings || [])))
-		return binding.batch(statements)
-	}
-	if (operation.indexOf('d1.stmt.') === 0) {
-		const mode = operation.split('.')[2]
-		const [sql, ...rest] = params
-		let bindings = rest
-		let extraParam
-		if (mode === 'first' || mode === 'raw') {
-			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') {
-			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)
-		throw new Error('Unknown stmt mode: ' + mode)
-	}
-
-	// Durable Objects
-	if (operation === 'do.idFromName') {
-		const ns = resolveDoNamespace(binding, params[1])
-		const id = ns.idFromName(params[0])
-		return { __type: 'DOId', hex: id.toString() }
-	}
-	if (operation === 'do.idFromString') {
-		const id = binding.idFromString(params[0])
-		return { __type: 'DOId', hex: id.toString() }
-	}
-	if (operation === 'do.newUniqueId') {
-		const ns = resolveDoNamespace(binding, params[1])
-		const id = ns.newUniqueId(params[0])
-		return { __type: 'DOId', hex: id.toString() }
-	}
-	if (operation === 'do.fetch') {
-		const [, serializedId, serializedReq] = params
-		const id = binding.idFromString(serializedId.hex)
-		const stub = binding.get(id)
-		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
-		}))
-		return serializeResponse(response)
-	}
-	if (operation === 'do.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
-	}
-
-	// Service Bindings
-	if (operation === 'service.fetch') {
-		if (!binding || typeof binding.fetch !== 'function') {
-			throw new Error('Service binding ' + bindingName + ' does not support fetch()')
-		}
-		const response = await binding.fetch(deserializeRequest(params[0]))
-		return serializeResponse(response)
-	}
-	if (operation === 'service.rpc') {
-		const methodName = params[0]
-		if (typeof methodName !== 'string') {
-			throw new Error('Service binding ' + bindingName + ' RPC method name must be a string')
-		}
-		const args = Array.isArray(params[1]) ? params[1] : []
-		const method = binding && binding[methodName]
-		if (typeof method !== 'function') {
-			throw new Error('Service binding ' + bindingName + ' does not support ' + methodName + '()')
-		}
-		return method.apply(binding, args)
-	}
-
-	// Queues
-	if (operation === 'queue.send') return binding.send(params[0], params[1])
-	if (operation === 'queue.sendBatch') return binding.sendBatch(params[0], params[1])
-
-	// Send Email
-	if (operation === 'email.send') {
-		if (binding && typeof binding.send === 'function') {
-			const message = params[0]
-			if (message && typeof message === 'object' && 'from' in message && 'to' in message && 'raw' in message) {
-				return binding.send({
-					from: message.from,
-					to: message.to,
-					[RAW_EMAIL]: createEmailMessageRaw(message.raw)
-				})
-			}
-			return binding.send(message)
-		}
-		return { ok: true, simulated: true }
-	}
-
-	// Workflows
-	if (operation === 'workflow.create') {
-		return serializeWorkflowInstance(await binding.create(params[0]))
-	}
-	if (operation === 'workflow.get') {
-		return serializeWorkflowInstance(await binding.get(params[0]))
-	}
-	if (operation === 'workflow.status') {
-		return (await binding.get(params[0])).status()
-	}
-	if (operation === 'workflow.pause') {
-		return (await binding.get(params[0])).pause()
-	}
-	if (operation === 'workflow.resume') {
-		return (await binding.get(params[0])).resume()
-	}
-	if (operation === 'workflow.terminate') {
-		return (await binding.get(params[0])).terminate()
-	}
-	if (operation === 'workflow.restart') {
-		return (await binding.get(params[0])).restart()
-	}
-	if (operation === 'workflow.sendEvent') {
-		return (await binding.get(params[0])).sendEvent(params[1])
-	}
-
-	// AI / generic run()
-	if (operation === 'ai.run') {
-		if (typeof binding.run !== 'function') {
-			throw new Error('Binding ' + bindingName + ' does not support run(): ' + method)
-		}
-		return binding.run(params[0], params[1])
-	}
-
-	throw new Error('Unknown operation: ' + method)
-}
-
-function createUnsupportedBridgeOperationErrorMessage(bindingName, operation) {
-	const base = "[devflare][bridge] Unsupported bridge operation '" + operation + "' for binding '" + bindingName + "'."
-	if (operation === 'fetch') {
-		return base + ' Devflare could not dispatch fetch() for this binding through the local bridge. '
-			+ 'Expected Cloudflare API: env.' + bindingName + '.fetch(request). '
-			+ 'If this came from SvelteKit platform.env, make sure the binding is declared as a service binding; '
-			+ 'this is a Devflare local bridge issue when service bindings fall back to a bare fetch operation.'
-	}
-	if (operation === 'toString') {
-		return base + ' A platform.env value was coerced to a string through the bridge. '
-			+ 'For SvelteKit local dev, declared vars should be plain string values and missing env names should read as undefined.'
-	}
-	return base + ' Bare verbs and the legacy stmt.*/stub.* sub-prefixes are not supported; '
-		+ 'use the namespaced form (e.g. kv.get, r2.put, d1.stmt.first, do.fetch, service.fetch).'
-}
-
-function serializeWorkflowInstance(instance) {
-	return {
-		__type: 'WorkflowInstance',
-		id: instance.id
-	}
-}
-
-// ---------------------------------------------------------------------------
-// WebSocket bridge (shared with src/bridge/server.ts in shape)
-// ---------------------------------------------------------------------------
-// NOTE: wsProxies is intentionally created per handleBridgeWebSocket call so
-// state never leaks across connections or across gateway-script regenerations.
-
-async function handleBridgeRpcCall(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 || String(error)
-			}
-		}))
-	}
-}
-
-async function handleBridgeWsOpen(msg, ws, env, wsProxies) {
-	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 payload = isText
-				? new TextEncoder().encode(event.data)
-				: new Uint8Array(event.data)
-			const flags = isText ? 2 : 0
-			ws.send(encodeWsDataFrame(msg.wid, flags, payload))
-		})
-
-		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 handleBridgeWsClose(msg, wsProxies) {
-	const proxy = wsProxies.get(msg.wid)
-	if (proxy) {
-		proxy.doWs.close(msg.code, msg.reason)
-		wsProxies.delete(msg.wid)
-	}
-}
-
-// Relay an inbound binary WsData frame (client -> DO). Mirrors server.ts
-// handleBinaryMessage: decode the frame, look up the proxy by ws id, and forward
-// the payload to the DO socket honoring the TEXT flag.
-function handleBridgeBinaryMessage(buffer, wsProxies) {
-	const frame = decodeWsDataFrame(buffer)
-	if (!frame || frame.kind !== 2) return
-	const proxy = wsProxies.get(frame.id)
-	if (!proxy) return
-	if ((frame.flags & 2) !== 0) {
-		proxy.doWs.send(new TextDecoder().decode(frame.payload))
-	} else {
-		proxy.doWs.send(frame.payload)
-	}
-}
-
-async function handleBridgeJsonMessage(data, ws, env, ctx, wsProxies) {
-	const msg = JSON.parse(data)
-	switch (msg.t) {
-		case 'hello':
-			// v2 handshake — acknowledge with welcome echoing the negotiated
-			// capability intersection. The gateway advertises only what it
-			// implements end-to-end: 'ws-relay' (binary WsData relay to/from DO
-			// sockets) and 'http-transfer' (the R2 transfer HTTP side-channel).
-			// 'streams' is intentionally NOT advertised — large DO/service-fetch
-			// responses are inlined, not streamed, in this gateway.
-			ws.send(JSON.stringify({
-				t: 'welcome',
-				protocolVersion: 2,
-				capabilities: ['ws-relay', 'http-transfer']
-					.filter((c) => Array.isArray(msg.capabilities) && msg.capabilities.includes(c))
-					.sort()
-			}))
-			break
-		case 'rpc.call':
-			await handleBridgeRpcCall(msg, ws, env, ctx)
-			break
-		case 'ws.open':
-			await handleBridgeWsOpen(msg, ws, env, wsProxies)
-			break
-		case 'ws.close':
-			handleBridgeWsClose(msg, wsProxies)
-			break
-	}
-}
-
-function handleBridgeWebSocket(request, env, ctx) {
-	const { 0: client, 1: server } = new WebSocketPair()
-	server.accept()
-
-	// Per-connection state: recreated for every bridge client so reloads and
-	// concurrent clients never share WS proxy entries.
-	const wsProxies = new Map()
-
-	server.addEventListener('message', async (event) => {
-		try {
-			if (typeof event.data === 'string') {
-				await handleBridgeJsonMessage(event.data, server, env, ctx, wsProxies)
-			} else {
-				handleBridgeBinaryMessage(event.data, wsProxies)
-			}
-		} catch (error) {
-			console.error('[Gateway] Error:', error)
-		}
-	})
-
-	server.addEventListener('close', () => {
-		for (const proxy of wsProxies.values()) {
-			// Best-effort cleanup: the DO-side WS may already be closed or in an
-			// invalid state; any throw here would abort sibling closes. Surface
-			// the swallowed error when DEVFLARE_DEBUG_BRIDGE is enabled.
-			try { proxy.doWs.close() } catch (error) {
-				if (globalThis.DEVFLARE_DEBUG_BRIDGE) {
-					console.warn('[devflare:bridge] proxy.doWs.close() failed', error)
-				}
-			}
-		}
-		wsProxies.clear()
-	})
-
-	return new Response(null, { status: 101, webSocket: client })
-}
-
-// ---------------------------------------------------------------------------
-// HTTP transfer for R2 bodies (shared with src/bridge/server.ts in shape)
-// ---------------------------------------------------------------------------
-
-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(serializeR2Object(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 })
-}
-`;
-
-// src/bridge/miniflare.ts
-function isIgnorableMiniflareDisposeError(error) {
-  if (!(error instanceof Error)) {
-    return false;
-  }
-  const details = error;
-  return details.code === "EBADF" && details.syscall === "kill";
-}
-
-// 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,
-    serviceBindingResolution: null,
-    browserShim: null,
-    browserShimPort: initial.browserShimPort ?? 8788,
-    mainWorkerSurfacePaths: {
-      fetch: null,
-      queue: null,
-      scheduled: null,
-      email: null,
-      tail: null
-    },
-    resolvedWorkerConfigPath: null,
-    mainWorkerScriptPath: null,
-    bundledMainWorkerScriptPath: null,
-    workflowEntrypointScript: "",
-    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) {
-    try {
-      await state.miniflare.dispose();
-    } catch (error) {
-      if (!isIgnorableMiniflareDisposeError(error)) {
-        throw error;
-      }
-    }
-    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/miniflare-dev-config.ts
-import { resolve as resolve5 } 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 resolve3 } 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,
-    localSecretWrappedBindingConfig,
-    queueProducers
-  } = context;
-  const baseFlags = loadedConfig.compatibilityFlags ?? [];
-  const compatFlags = baseFlags.includes("nodejs_compat") ? baseFlags : [...baseFlags, "nodejs_compat"];
-  const workerBindings = loadedConfig.vars ?? {};
-  const localWrappedBindings = {
-    ...localSecretWrappedBindingConfig?.wrappedBindings ?? {}
-  };
-  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 },
-    ...Object.keys(localWrappedBindings).length > 0 && { wrappedBindings: localWrappedBindings },
-    ...queueProducers && { queueProducers },
-    ...options.queueConsumers && { queueConsumers: options.queueConsumers },
-    ...options.triggers && { triggers: options.triggers }
-  };
-  if (options.scriptPath) {
-    workerConfig.scriptPath = options.scriptPath;
-    workerConfig.modulesRoot = loadedConfig.baseDir ? resolve3(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 as dirname2, resolve as resolve4 } 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(dirname2(resolve4(cwd, configuredPath)));
-    return;
-  }
-  for (const defaultEntry of defaultEntries) {
-    roots.add(dirname2(resolve4(cwd, defaultEntry)));
-  }
-}
-function collectWorkerWatchRoots(cwd, config, mainWorkerSurfacePaths) {
-  const roots = new Set;
-  for (const surfacePath of Object.values(mainWorkerSurfacePaths)) {
-    if (surfacePath) {
-      roots.add(dirname2(surfacePath));
-    }
-  }
-  addWorkerWatchRoots(roots, cwd, config.files?.fetch, DEFAULT_FETCH_ENTRY_FILES);
-  addWorkerWatchRoots(roots, cwd, config.files?.queue, DEFAULT_QUEUE_ENTRY_FILES);
-  addWorkerWatchRoots(roots, cwd, config.files?.scheduled, DEFAULT_SCHEDULED_ENTRY_FILES);
-  addWorkerWatchRoots(roots, cwd, config.files?.email, DEFAULT_EMAIL_ENTRY_FILES);
-  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,
-    miniflareHost = "127.0.0.1",
-    persist,
-    enableVite,
-    debug,
-    mainWorkerSurfacePaths,
-    mainWorkerRoutes,
-    mainWorkerScriptPath,
-    bundledMainWorkerScriptPath,
-    workflowEntrypointScript,
-    browserShimPort,
-    doResult,
-    serviceBindingResolution,
-    logger
-  } = input;
-  const bindings = loadedConfig.bindings ?? {};
-  const persistPath = resolve5(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: miniflareHost,
-    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 localBindingShimServiceConfig = buildLocalBindingShimServiceConfig(loadedConfig);
-  const createServiceBindings = (extraBindings = {}) => buildServiceBindings(bindings, {
-    ...serviceBindingResolution?.primaryServiceBindings ?? {},
-    ...localBindingShimServiceConfig.serviceBindings,
-    ...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 = bindings.images ? undefined : buildImagesConfig(bindings);
-  const mediaConfig = bindings.media ? undefined : buildMediaConfig(bindings);
-  const artifactsConfig = buildArtifactsConfig(bindings);
-  const aiSearchNamespacesConfig = buildAiSearchNamespacesConfig(bindings);
-  const aiSearchInstancesConfig = buildAiSearchInstancesConfig(bindings);
-  const localSecretWrappedBindingConfig = buildLocalSecretWrappedBindingConfig(loadedConfig, cwd);
-  const localSecretBindingNames = new Set(localSecretWrappedBindingConfig.localBindingNames);
-  const secretsStoreConfig = buildSecretsStoreConfig(bindings, loadedConfig.secretsStoreId, localSecretBindingNames);
-  const workerContext = {
-    cwd,
-    loadedConfig,
-    bindings,
-    sendEmailConfig,
-    rateLimitsConfig,
-    versionMetadataConfig,
-    workerLoadersConfig,
-    mtlsCertificatesConfig,
-    dispatchNamespacesConfig,
-    workflowsConfig,
-    pipelinesConfig,
-    hyperdrivesConfig,
-    imagesConfig,
-    mediaConfig,
-    artifactsConfig,
-    aiSearchNamespacesConfig,
-    aiSearchInstancesConfig,
-    secretsStoreConfig,
-    localSecretWrappedBindingConfig,
-    queueProducers
-  };
-  const createWorkerConfig = (options) => makeMiniflareWorker(workerContext, options);
-  const gatewayWorker = createWorkerConfig({
-    name: "gateway",
-    script: [
-      workflowEntrypointScript,
-      getGatewayScript(loadedConfig.wsRoutes, debug, shouldRunMainWorker ? INTERNAL_APP_SERVICE_BINDING : null)
-    ].filter(Boolean).join(`
-
-`),
-    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,
-      ...serviceBindingResolution?.workers ?? [],
-      ...localSecretWrappedBindingConfig.workers,
-      ...localBindingShimServiceConfig.workers
-    ]
-  };
-}
-
-// 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/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/server-startup-helpers.ts
-import { resolve as resolve6 } from "pathe";
-
-// src/browser-shim/server.ts
-import { existsSync } from "node:fs";
-import {
-  createServer
-} from "node:http";
-import { homedir } from "node:os";
-import { join as join2 } from "node:path";
-import {
-  Browser as BrowserType,
-  detectBrowserPlatform,
-  install,
-  resolveBuildId
-} from "@puppeteer/browsers";
-import puppeteerCore from "puppeteer-core";
-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 = join2(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 = Number.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((resolve6, 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", () => resolve6(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((resolve6, reject) => {
-      server.on("error", reject);
-      server.listen(port, host, () => {
-        resolve6();
-      });
-    });
-    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((resolve6) => {
-        server.close(() => resolve6());
-      });
-      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 = resolve6(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 = resolve6(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/vite-process.ts
-import { spawn } from "node:child_process";
-async function startViteProcess(options) {
-  const { cwd, configPath, 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),
-      ...configPath ? { DEVFLARE_CONFIG_PATH: configPath } : {},
-      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/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.ts
-function createDevServer(options) {
-  const {
-    cwd,
-    configPath,
-    vitePort = 5173,
-    miniflarePort = 8787,
-    miniflareHost = "127.0.0.1",
-    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);
-      const log = createMiniflareLog(Log, LogLevel, "DEBUG", logger);
-      if (log) {
-        mfConfig.log = log;
-      }
-      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: resolve7(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,
-      miniflareHost,
-      persist,
-      enableVite: state.enableVite,
-      debug,
-      mainWorkerSurfacePaths: state.mainWorkerSurfacePaths,
-      mainWorkerRoutes: state.mainWorkerRoutes,
-      mainWorkerScriptPath: state.mainWorkerScriptPath,
-      bundledMainWorkerScriptPath: state.bundledMainWorkerScriptPath,
-      workflowEntrypointScript: state.workflowEntrypointScript,
-      browserShimPort: state.browserShimPort,
-      doResult,
-      serviceBindingResolution: state.serviceBindingResolution,
-      logger
-    });
-  }
-  async function bundleWorkflowEntrypoints() {
-    if (!state.config) {
-      state.workflowEntrypointScript = "";
-      return;
-    }
-    state.workflowEntrypointScript = await bundleWorkflowEntrypointScript(state.config, cwd, {
-      logger
-    });
-  }
-  async function startMiniflare(doResult) {
-    const { Miniflare, Log, LogLevel } = await import("miniflare");
-    const mfConfig = buildMiniflareConfig(doResult);
-    const log = createMiniflareLog(Log, LogLevel, "DEBUG", logger);
-    if (log) {
-      mfConfig.log = log;
-    }
-    mfConfig.handleRuntimeStdio = createRuntimeStdioForwarder(logger);
-    const shouldLogMiniflareDiagnostics = verbose || debug;
-    if (shouldLogMiniflareDiagnostics) {
-      logMiniflareConfigDiagnostics(logger, mfConfig);
-    }
-    state.miniflare = new Miniflare(mfConfig);
-    await state.miniflare.ready;
-    const displayHost = miniflareHost === "0.0.0.0" || miniflareHost === "::" ? "localhost" : miniflareHost;
-    logger?.success(`Miniflare ready on http://${displayHost}:${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 loadRuntimeConfigWhenEnvReady();
-    if (!state.config) {
-      return;
-    }
-    setLocalSendEmailBindings(state.config.bindings?.sendEmail ?? {});
-    await bundleWorkflowEntrypoints();
-    await refreshWorkerOnlySurfaceState();
-    await reloadMiniflare(state.currentDoResult);
-  }
-  async function loadRuntimeConfig() {
-    state.resolvedWorkerConfigPath = await resolveWorkerConfigWatchPath(cwd, configPath);
-    const loadedConfig = await loadConfig({ cwd, configFile: configPath });
-    const envResolvedConfig = await resolveConfigEnvVars(loadedConfig, {
-      cwd,
-      configPath: state.resolvedWorkerConfigPath ?? configPath,
-      mode: "dev"
-    });
-    state.config = await applyLocalDevVarsToConfig(envResolvedConfig, {
-      cwd,
-      configPath: state.resolvedWorkerConfigPath ?? undefined
-    });
-    state.serviceBindingResolution = state.config.bindings?.services ? await resolveServiceBindings(state.config, state.resolvedWorkerConfigPath ? dirname3(state.resolvedWorkerConfigPath) : cwd) : null;
-  }
-  async function waitForDotenvChange() {
-    const configWatchPath = state.resolvedWorkerConfigPath ?? await resolveWorkerConfigWatchPath(cwd, configPath);
-    const startDir = configWatchPath ? dirname3(configWatchPath) : cwd;
-    const watchPaths = getDevflareDotenvPaths(startDir);
-    const { watch } = await import("chokidar");
-    await new Promise((resolveWait, rejectWait) => {
-      const watcher = watch(watchPaths, {
-        ignoreInitial: true,
-        awaitWriteFinish: {
-          stabilityThreshold: 100,
-          pollInterval: 25
-        }
-      });
-      const finish = () => {
-        watcher.close().then(resolveWait, rejectWait);
-      };
-      watcher.on("add", finish);
-      watcher.on("change", finish);
-      watcher.on("unlink", finish);
-      watcher.on("error", rejectWait);
-    });
-  }
-  async function loadRuntimeConfigWhenEnvReady() {
-    while (true) {
-      try {
-        await loadRuntimeConfig();
-        return;
-      } catch (error) {
-        if (!(error instanceof EnvVarResolutionError)) {
-          throw error;
-        }
-        logger?.warn(error.message);
-        logger?.info("Devflare dev is waiting for .env or .env.dev to change before starting.");
-        await waitForDotenvChange();
-      }
-    }
-  }
-  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 loadRuntimeConfigWhenEnvReady();
-    if (!state.config) {
-      throw new Error("Config not loaded");
-    }
-    setLocalSendEmailBindings(state.config.bindings?.sendEmail ?? {});
-    logger?.debug("Loaded config:", state.config.name);
-    await bundleWorkflowEntrypoints();
-    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,
-        configPath,
-        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
-function readStringOption(value) {
-  return typeof value === "string" ? value : undefined;
-}
-function parsePort(value, source) {
-  const port = Number(value);
-  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
-    throw new Error(`${source} must be an integer between 1 and 65535`);
-  }
-  return port;
-}
-function resolveSinglePort(runtimePort, bridgePort, source) {
-  if (runtimePort && bridgePort && runtimePort !== bridgePort) {
-    throw new Error(`Conflicting Devflare runtime ports: ${source} runtime port is ${runtimePort}, but bridge port is ${bridgePort}. Use one value for both.`);
-  }
-  const value = runtimePort ?? bridgePort;
-  return value ? parsePort(value, source) : undefined;
-}
-function resolveDevRuntimePort(options, env = process.env, configPort) {
-  return resolveSinglePort(readStringOption(options["runtime-port"]), readStringOption(options["bridge-port"]), "CLI") ?? resolveSinglePort(env.DEVFLARE_RUNTIME_PORT, env.DEVFLARE_BRIDGE_PORT, "environment") ?? configPort ?? 8787;
-}
-function resolveDevRuntimeHost(options, env = process.env, configHost) {
-  const envHost = env.DEVFLARE_RUNTIME_HOST?.trim();
-  return readStringOption(options["runtime-host"]) ?? (envHost ? envHost : undefined) ?? configHost ?? "127.0.0.1";
-}
-async function createLogWriter(cwd, options) {
-  if (!options.log && !options.logTemp) {
-    return null;
-  }
-  const fs = await import("node:fs");
-  let logPath;
-  if (options.logTemp) {
-    logPath = resolve8(cwd, ".log");
-  } else {
-    const now = new Date;
-    const timestamp = now.toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
-    logPath = resolve8(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 });
-  let miniflarePort;
-  let miniflareHost;
-  try {
-    miniflarePort = resolveDevRuntimePort(parsed.options, process.env, config.server?.port);
-    miniflareHost = resolveDevRuntimeHost(parsed.options, process.env, config.server?.host);
-  } catch (error) {
-    logger.error(error instanceof Error ? error.message : String(error));
-    return { exitCode: 1 };
-  }
-  const viteProject = resolveEffectiveViteProject(await detectViteProject(cwd), config);
-  const logWriter = await createLogWriter(cwd, {
-    log: logEnabled,
-    logTemp: logTempEnabled
-  });
-  if (logWriter) {
-    const logFile = relative2(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 ? Number.parseInt(port, 10) : 5173,
-      miniflarePort,
-      miniflareHost,
-      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,
-  resolveDevRuntimePort,
-  resolveDevRuntimeHost
-};