devflare 1.0.0-next.14 → 1.0.0-next.16

package/dist/{index-0kzg8wed.js → index-2x53aqjm.js}

@@ -2,23 +2,28 @@ import {
   getRemoteModeStatus,
   isRemoteModeActive
 } from "./index-d8bdkx2h.js";
+import {
+  discoverEntrypointsSync
+} from "./index-zt22fe2j.js";
+import {
+  canProceedWithTest
+} from "./index-7g8zyws4.js";
 import {
   transformWorkerEntrypoint
 } from "./index-wfbfz02q.js";
 import {
-  discoverEntrypointsSync,
   resolvePackageSpecifier
-} from "./index-2q3pmzrx.js";
+} from "./index-82f1z98k.js";
 import {
   __clearTestContext,
   __setTestContext
-} from "./index-vky23txa.js";
+} from "./index-m3fmw6mx.js";
 import {
   createRouteResolve,
   invokeFetchModule,
   matchFetchRoute,
   resolveFetchHandler
-} from "./index-8gtqgb3q.js";
+} from "./index-hjy8ctpc.js";
 import {
   createEmailEvent,
   createFetchEvent,
@@ -27,7 +32,7 @@ import {
   createTailEvent,
   runWithContext,
   runWithEventContext
-} from "./index-5yxg30va.js";
+} from "./index-cgbvmse6.js";
 import {
   discoverRoutes
 } from "./index-1p814k7s.js";
@@ -42,44 +47,47 @@ import {
 import {
   startMiniflare,
   startMiniflareFromConfig
-} from "./index-xxwbb2nt.js";
+} from "./index-ry131z23.js";
 import {
   BridgeClient,
   createEnvProxy,
   setBindingHints
-} from "./index-59df49vn.js";
+} from "./index-9ba1etyz.js";
 import {
   createLocalSendEmailBinding,
   wrapEnvSendEmailBindings
-} from "./index-fef08w43.js";
+} from "./index-h18pxvzs.js";
 import {
+  getLocalD1DatabaseIdentifier,
   loadConfig,
   normalizeDOBinding,
   resolveConfigPath
-} from "./index-wyf3s77s.js";
+} from "./index-6psz1h4c.js";
 import {
-  canProceedWithTest,
-  getApiToken,
   getEffectiveAccountId,
-  getPrimaryAccount,
+  getPrimaryAccount
+} from "./index-xk9djfjp.js";
+import {
+  getApiToken,
   isAuthenticated
-} from "./index-tfyxa77h.js";
+} from "./index-0w826dsr.js";
 import {
   __require
 } from "./index-37x76zdn.js";
 
 // src/test/simple-context.ts
-import { resolve as resolve2, dirname as dirname2, join as join7 } from "path";
-import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname4, join as join9, resolve as resolve2 } from "path";
 
-// src/test/remote-ai.ts
-function createRemoteAI(accountId) {
+// src/test/remote-cloudflare.ts
+function createRemoteCloudflareClient(accountId) {
   let resolvedAccountId = null;
   async function getAccountId() {
-    if (accountId)
+    if (accountId) {
       return accountId;
-    if (resolvedAccountId)
+    }
+    if (resolvedAccountId) {
       return resolvedAccountId;
+    }
     const primary = await getPrimaryAccount();
     if (!primary) {
       throw new Error("No Cloudflare account found. Run: bunx wrangler login");
@@ -95,28 +103,45 @@ function createRemoteAI(accountId) {
     }
     return token;
   }
+  async function jsonRequest(options) {
+    const [acctId, token] = await Promise.all([getAccountId(), getToken()]);
+    const response = await fetch(`https://api.cloudflare.com/client/v4/accounts/${acctId}${options.path}`, {
+      method: options.method,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": options.contentType ?? "application/json"
+      },
+      body: options.body
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`${options.serviceLabel} API error (${response.status}): ${errorText}`);
+    }
+    const result = await response.json();
+    if (!result.success) {
+      const message = result.errors?.[0]?.message || `Unknown ${options.serviceLabel} error`;
+      throw new Error(`${options.serviceLabel} API error: ${message}`);
+    }
+    return result.result;
+  }
+  return {
+    getAccountId,
+    getToken,
+    jsonRequest
+  };
+}
+
+// src/test/remote-ai.ts
+function createRemoteAI(accountId) {
+  const cloudflare = createRemoteCloudflareClient(accountId);
   const ai = {
     async run(model, inputs) {
-      const [acctId, token] = await Promise.all([getAccountId(), getToken()]);
-      const url = `https://api.cloudflare.com/client/v4/accounts/${acctId}/ai/run/${model}`;
-      const response = await fetch(url, {
+      return cloudflare.jsonRequest({
         method: "POST",
-        headers: {
-          Authorization: `Bearer ${token}`,
-          "Content-Type": "application/json"
-        },
+        path: `/ai/run/${model}`,
+        serviceLabel: "AI",
         body: JSON.stringify(inputs)
       });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`AI API error (${response.status}): ${errorText}`);
-      }
-      const result = await response.json();
-      if (!result.success) {
-        const message = result.errors?.[0]?.message || "Unknown AI error";
-        throw new Error(`AI API error: ${message}`);
-      }
-      return result.result;
     },
     gateway(_gatewayId) {
       console.warn("AI Gateway is not supported in remote test mode");
@@ -128,72 +153,25 @@ function createRemoteAI(accountId) {
 
 // src/test/remote-vectorize.ts
 function createRemoteVectorize(indexName, accountId) {
-  let resolvedAccountId = null;
-  async function getAccountId() {
-    if (accountId)
-      return accountId;
-    if (resolvedAccountId)
-      return resolvedAccountId;
-    const primary = await getPrimaryAccount();
-    if (!primary) {
-      throw new Error("No Cloudflare account found. Run: bunx wrangler login");
-    }
-    const { accountId: effectiveId } = await getEffectiveAccountId(primary.id);
-    resolvedAccountId = effectiveId;
-    return effectiveId;
-  }
-  async function getToken() {
-    const token = await getApiToken();
-    if (!token) {
-      throw new Error("Not authenticated. Run: bunx wrangler login");
-    }
-    return token;
-  }
+  const cloudflare = createRemoteCloudflareClient(accountId);
   async function apiRequest(method, endpoint, body) {
-    const [acctId, token] = await Promise.all([getAccountId(), getToken()]);
-    const url = `https://api.cloudflare.com/client/v4/accounts/${acctId}/vectorize/v2/indexes/${indexName}${endpoint}`;
-    const response = await fetch(url, {
+    return cloudflare.jsonRequest({
       method,
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
-      },
+      path: `/vectorize/v2/indexes/${indexName}${endpoint}`,
+      serviceLabel: "Vectorize",
       body: body ? JSON.stringify(body) : undefined
     });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Vectorize API error (${response.status}): ${errorText}`);
-    }
-    const result = await response.json();
-    if (!result.success) {
-      const message = result.errors?.[0]?.message || "Unknown Vectorize error";
-      throw new Error(`Vectorize API error: ${message}`);
-    }
-    return result.result;
   }
   async function ndjsonRequest(endpoint, vectors) {
-    const [acctId, token] = await Promise.all([getAccountId(), getToken()]);
-    const url = `https://api.cloudflare.com/client/v4/accounts/${acctId}/vectorize/v2/indexes/${indexName}${endpoint}`;
     const ndjson = vectors.map((v) => JSON.stringify(v)).join(`
 `);
-    const response = await fetch(url, {
+    return cloudflare.jsonRequest({
       method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/x-ndjson"
-      },
+      path: `/vectorize/v2/indexes/${indexName}${endpoint}`,
+      serviceLabel: "Vectorize",
+      contentType: "application/x-ndjson",
       body: ndjson
     });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Vectorize API error (${response.status}): ${errorText}`);
-    }
-    const result = await response.json();
-    if (!result.success) {
-      const message = result.errors?.[0]?.message || "Unknown Vectorize error";
-      throw new Error(`Vectorize API error: ${message}`);
-    }
-    return result.result;
   }
   const vectorize = {
     async describe() {
@@ -610,75 +588,755 @@ export default {
   }
 }
 
-// src/test/queue.ts
-import { join as join2 } from "path";
-var queueHandlerPath = null;
-var configDir = null;
-var testEnvGetter = null;
-function configureQueue(options) {
-  queueHandlerPath = options.handlerPath;
-  configDir = options.configDir;
-  testEnvGetter = options.getEnv;
+// src/test/simple-context-durable-objects.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { readFile } from "fs/promises";
+import { dirname as dirname3, join as join3 } from "path";
+
+// src/test/simple-context-gateway-script.ts
+function buildGatewayScript(bundledCode, wrappers) {
+  return `
+// Bundled transport + DO classes
+${bundledCode}
+
+// DO Wrappers with RPC
+${wrappers}
+
+// Transport encoding helper
+const __transportEncoders = typeof transport !== 'undefined' ? transport : {}
+
+function __encodeTransport(value) {
+	if (value === null || value === undefined) return value
+	
+	// Try each encoder
+	for (const [typeName, transporter] of Object.entries(__transportEncoders)) {
+		const encoded = transporter.encode(value)
+		if (encoded !== false && encoded !== undefined) {
+			return { __transport: typeName, value: encoded }
+		}
+	}
+	
+	// Recursively encode arrays and objects
+	if (Array.isArray(value)) {
+		return value.map(__encodeTransport)
+	}
+	if (typeof value === 'object') {
+		const result = {}
+		for (const [k, v] of Object.entries(value)) {
+			result[k] = __encodeTransport(v)
+		}
+		return result
+	}
+	
+	return value
 }
-function resetQueueState() {
-  queueHandlerPath = null;
-  configDir = null;
-  testEnvGetter = null;
+
+// Gateway with WebSocket RPC
+export default {
+	async fetch(request, env) {
+		if (request.headers.get('Upgrade') === 'websocket') {
+			const { 0: client, 1: server } = new WebSocketPair()
+			server.accept()
+			server.addEventListener('message', async (e) => {
+				try {
+					const m = JSON.parse(e.data)
+					if (m.t === 'rpc.call') {
+						const result = await executeRpc(env, m.method, m.params)
+						server.send(JSON.stringify({ t: 'rpc.ok', id: m.id, result }))
+					}
+				} catch (error) {
+					server.send(JSON.stringify({ t: 'rpc.err', id: 'unknown', error: { code: 'RPC_ERROR', message: error.message } }))
+				}
+			})
+			return new Response(null, { status: 101, webSocket: client })
+		}
+		return new Response('Gateway')
+	}
 }
-function createMessage(options) {
-  const id = options.id ?? crypto.randomUUID();
-  const timestamp = options.timestamp ?? new Date;
-  const attempts = options.attempts ?? 1;
-  let state = "pending";
-  return {
-    id,
-    timestamp,
-    body: options.body,
-    attempts,
-    ack() {
-      state = "acked";
-    },
-    retry(opts) {
-      state = "retried";
-    },
-    retryAll() {
-      state = "retried";
-    },
-    get _state() {
-      return state;
-    }
-  };
+
+async function executeRpc(env, method, params) {
+	const [bindingName, ...rest] = method.split('.')
+	const op = rest.join('.')
+	const binding = env[bindingName]
+	const RAW_EMAIL = 'EmailMessage::raw'
+	if (!binding) throw new Error('Binding not found: ' + bindingName)
+
+	// KV operations
+	if (op === 'get') return binding.get(params[0], params[1])
+	if (op === 'put') return binding.put(params[0], params[1], params[2])
+	if (op === 'delete') return binding.delete(params[0])
+	if (op === 'list') return binding.list(params[0])
+	if (op === 'getWithMetadata') return binding.getWithMetadata(params[0], params[1])
+
+	// R2 operations
+	if (op === 'r2.get') return binding.get(params[0], params[1])
+	if (op === 'r2.put') return binding.put(params[0], params[1], params[2])
+	if (op === 'r2.delete') return binding.delete(params[0])
+	if (op === 'r2.list') return binding.list(params[0])
+	if (op === 'head') return binding.head(params[0])
+
+	// D1 operations
+	if (op === 'exec') return binding.exec(params[0])
+	if (op === 'dump') return binding.dump()
+	if (op === 'batch') {
+		const stmts = params[0].map(s => {
+			const stmt = binding.prepare(s.sql)
+			return s.bindings?.length ? stmt.bind(...s.bindings) : stmt
+		})
+		return binding.batch(stmts)
+	}
+	if (op === 'prepare.run') return binding.prepare(params[0]).bind(...(params[1] || [])).run()
+	if (op === 'prepare.all') return binding.prepare(params[0]).bind(...(params[1] || [])).all()
+	if (op === 'prepare.first') return binding.prepare(params[0]).bind(...(params[1] || [])).first(params[2])
+	if (op === 'prepare.raw') return binding.prepare(params[0]).bind(...(params[1] || [])).raw({ columnNames: params[2] })
+
+	// Send email operations
+	if (op === 'email.send') {
+		return binding.send(__normalizeEmailMessage(params[0]))
+	}
+
+	// DO operations
+	if (op === 'idFromName') {
+		return { __type: 'DOId', hex: binding.idFromName(params[0]).toString() }
+	}
+	if (op === 'stub.rpc') {
+		const [, idSerialized, rpcMethod, rpcParams] = params
+		const stub = binding.get(binding.idFromString(idSerialized.hex))
+
+		if (typeof stub[rpcMethod] === 'function') {
+			let result = await stub[rpcMethod](...(rpcParams || []))
+			result = __encodeTransport(result)
+			return result
+		}
+
+		const response = await stub.fetch(new Request('http://do/_rpc', {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({ method: rpcMethod, params: rpcParams || [] })
+		}))
+
+		const payload = await response.json()
+		if (!response.ok || !payload?.ok) {
+			throw new Error(payload?.error?.message || ('DO RPC failed with status ' + response.status))
+		}
+
+		return payload.result
+	}
+
+	throw new Error('Unknown operation: ' + method)
 }
-function createMessageBatch(messages) {
-  return {
-    queue: "test-queue",
-    messages,
-    ackAll() {
-      for (const msg of messages) {
-        msg.ack();
-      }
-    },
-    retryAll() {
-      for (const msg of messages) {
-        msg.retry();
-      }
-    }
-  };
+
+function __createEmailMessageRaw(raw) {
+	if (typeof raw === 'string' || raw instanceof ReadableStream) {
+		return raw
+	}
+	if (raw instanceof Uint8Array || raw instanceof ArrayBuffer) {
+		return new Response(raw).body
+	}
+	throw new Error('Unsupported EmailMessage raw payload')
 }
-async function trigger(messages) {
-  if (!queueHandlerPath) {
-    throw new Error("Queue handler not configured. Make sure your devflare.config.ts has files.queue set, " + "and the file exists at the specified path (default: src/queue.ts)");
-  }
-  if (!configDir || !testEnvGetter) {
-    throw new Error("Queue helper not initialized. Call createTestContext() before using cf.queue.trigger()");
-  }
-  const absolutePath = join2(configDir, queueHandlerPath);
-  const handlerModule = await import(absolutePath);
-  const queueHandler = handlerModule.default ?? handlerModule.queue;
-  if (typeof queueHandler !== "function") {
+
+function __buildRawEmail(message) {
+	const lines = []
+	const messageId = '<' + Date.now() + '-' + Math.random().toString(36).slice(2) + '@devflare.dev>'
+
+	lines.push('From: ' + message.from)
+	lines.push('To: ' + (Array.isArray(message.to) ? message.to.join(', ') : message.to))
+	lines.push('Date: ' + new Date().toUTCString())
+	lines.push('Message-ID: ' + messageId)
+
+	if (message.subject) lines.push('Subject: ' + message.subject)
+	if (message.replyTo) lines.push('Reply-To: ' + String(message.replyTo))
+	if (message.cc) lines.push('Cc: ' + (Array.isArray(message.cc) ? message.cc.join(', ') : message.cc))
+	if (message.bcc) lines.push('Bcc: ' + (Array.isArray(message.bcc) ? message.bcc.join(', ') : message.bcc))
+
+	for (const [key, value] of Object.entries(message.headers || {})) {
+		lines.push(key + ': ' + value)
+	}
+
+	lines.push('MIME-Version: 1.0')
+	lines.push('Content-Type: ' + (message.html ? 'text/html' : 'text/plain') + '; charset=UTF-8')
+	lines.push('')
+	lines.push(String(message.html ?? message.text ?? '').replace(/\\r?\\n/g, '\\r\\n'))
+
+	return lines.join('\\r\\n')
+}
+
+function __normalizeEmailMessage(message) {
+	if (!message || typeof message !== 'object' || !('from' in message) || !('to' in message)) {
+		return message
+	}
+	if ('EmailMessage::raw' in message) {
+		return message
+	}
+	if ('raw' in message && message.raw !== undefined) {
+		return {
+			from: message.from,
+			to: message.to,
+			[RAW_EMAIL]: __createEmailMessageRaw(message.raw)
+		}
+	}
+	return {
+		from: message.from,
+		to: message.to,
+		[RAW_EMAIL]: __createEmailMessageRaw(__buildRawEmail(message))
+	}
+}
+`;
+}
+
+// src/test/simple-context-paths.ts
+import { existsSync as existsSync2 } from "fs";
+import { createServer } from "net";
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath } from "url";
+var DEFAULT_TRANSPORT_ENTRY_FILES = [
+  "src/transport.ts",
+  "src/transport.js",
+  "src/transport.mts",
+  "src/transport.mjs"
+];
+var CURRENT_PACKAGE_ROOT = findPackageRoot(dirname2(fileURLToPath(import.meta.url)));
+function getBunRuntime2() {
+  const g = globalThis;
+  if (typeof g.Bun === "object" && g.Bun !== null) {
+    return g.Bun;
+  }
+  return;
+}
+function getCallerDirectory() {
+  const stackCallerDirectory = getStackCallerDirectory();
+  if (stackCallerDirectory) {
+    return stackCallerDirectory;
+  }
+  return process.cwd();
+}
+function getStackCallerDirectory() {
+  const originalPrepare = Error.prepareStackTrace;
+  Error.prepareStackTrace = (_, stack) => stack;
+  try {
+    const err = new Error;
+    const stack = err.stack;
+    for (const site of stack ?? []) {
+      const filename = site.getFileName?.();
+      if (filename && !isInsideCurrentPackage(filename) && !filename.includes("simple-context") && !filename.includes("node_modules") && !filename.includes("[") && existsSync2(filename)) {
+        return dirname2(filename);
+      }
+    }
+  } finally {
+    Error.prepareStackTrace = originalPrepare;
+  }
+  return null;
+}
+function findPackageRoot(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    if (existsSync2(join2(currentDir, "package.json"))) {
+      return currentDir;
+    }
+    const parentDir = dirname2(currentDir);
+    if (parentDir === currentDir) {
+      return startDir;
+    }
+    currentDir = parentDir;
+  }
+}
+function isInsideCurrentPackage(filePath) {
+  const normalizedFilePath = filePath.replace(/\\/g, "/");
+  const normalizedPackageRoot = CURRENT_PACKAGE_ROOT.replace(/\\/g, "/");
+  return normalizedFilePath === normalizedPackageRoot || normalizedFilePath.startsWith(`${normalizedPackageRoot}/`);
+}
+async function findNearestConfig(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    const configPath = await resolveConfigPath(currentDir);
+    if (configPath) {
+      return configPath;
+    }
+    const parentDir = dirname2(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+async function getAvailablePort() {
+  return await new Promise((resolvePort, reject) => {
+    const server = createServer();
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        server.close(() => reject(new Error("Could not determine an available port")));
+        return;
+      }
+      const { port } = address;
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolvePort(port);
+      });
+    });
+  });
+}
+function resolveTransportFile(configDir, configuredPath) {
+  if (typeof configuredPath === "string") {
+    return configuredPath;
+  }
+  if (configuredPath === null) {
+    return null;
+  }
+  for (const defaultEntry of DEFAULT_TRANSPORT_ENTRY_FILES) {
+    if (existsSync2(join2(configDir, defaultEntry))) {
+      return defaultEntry;
+    }
+  }
+  return null;
+}
+
+// src/test/simple-context-durable-objects.ts
+function findExportedClasses(code) {
+  const classes = [];
+  const classPattern = /export\s+class\s+(\w+)/g;
+  let match;
+  while ((match = classPattern.exec(code)) !== null) {
+    classes.push(match[1]);
+  }
+  return classes;
+}
+function classSupportsNativeDurableObjectRpc(code, className) {
+  const nativeRpcPattern = new RegExp(`export\\s+class\\s+${className}\\s+extends\\s+DurableObject\\b`);
+  return nativeRpcPattern.test(code);
+}
+function toGeneratedIdentifier(value) {
+  const normalized = value.replace(/[^A-Za-z0-9_$]/g, "_");
+  return /^[A-Za-z_$]/.test(normalized) ? normalized : `_${normalized}`;
+}
+async function discoverLocalDurableObjectClasses(config, configDir) {
+  const classToFilePath = new Map;
+  const doPatternConfig = config.files?.durableObjects;
+  const doPattern = typeof doPatternConfig === "string" ? doPatternConfig : DEFAULT_DO_PATTERN;
+  if (doPatternConfig === false) {
+    return classToFilePath;
+  }
+  const doFiles = await findFiles(doPattern, { cwd: configDir });
+  for (const filePath of doFiles) {
+    try {
+      const code = await readFile(filePath, "utf-8");
+      const classNames = findExportedClasses(code);
+      for (const className of classNames) {
+        classToFilePath.set(className, {
+          filePath,
+          nativeRpc: classSupportsNativeDurableObjectRpc(code, className)
+        });
+      }
+    } catch {}
+  }
+  return classToFilePath;
+}
+async function resolveLocalDurableObjects(config, configDir) {
+  const doConfig = {};
+  const doInfos = [];
+  const classToFilePath = await discoverLocalDurableObjectClasses(config, configDir);
+  for (const [name, rawDoInfo] of Object.entries(config.bindings?.durableObjects ?? {})) {
+    const doInfo = normalizeDOBinding(rawDoInfo);
+    if (doInfo.__ref) {
+      continue;
+    }
+    let scriptPath;
+    let nativeRpc = false;
+    if (doInfo.scriptName) {
+      scriptPath = join3(configDir, "src", doInfo.scriptName);
+      try {
+        const code = await readFile(scriptPath, "utf-8");
+        nativeRpc = classSupportsNativeDurableObjectRpc(code, doInfo.className);
+      } catch {
+        nativeRpc = false;
+      }
+    } else {
+      const discoveredClass = classToFilePath.get(doInfo.className);
+      if (!discoveredClass) {
+        throw new Error(`Durable object ${name} (className: '${doInfo.className}') not found.
+` + `Either:
+` + `  1. Set files.durableObjects pattern in config (e.g., 'src/do.*.ts')
+` + `  2. Use explicit scriptName: { className: '${doInfo.className}', scriptName: 'do.file.ts' }`);
+      }
+      scriptPath = discoveredClass.filePath;
+      nativeRpc = discoveredClass.nativeRpc;
+    }
+    const runtimeClassName = nativeRpc ? doInfo.className : `__Devflare${toGeneratedIdentifier(name)}RpcWrapper`;
+    doConfig[name] = runtimeClassName;
+    doInfos.push({
+      name,
+      className: doInfo.className,
+      scriptPath,
+      nativeRpc,
+      runtimeClassName
+    });
+  }
+  return {
+    doConfig,
+    doInfos
+  };
+}
+function buildWrapperCode(doInfos) {
+  return doInfos.filter((info) => !info.nativeRpc).map((info) => `
+export class ${info.runtimeClassName} {
+	constructor(state, env) {
+		this.__instance = new ${info.className}(state, env)
+	}
+
+	async fetch(request) {
+		const url = new URL(request.url)
+		if (request.method !== 'POST' || url.pathname !== '/_rpc') {
+			return new Response('Not found', { status: 404 })
+		}
+
+		try {
+			const payload = await request.json()
+			const method = payload?.method
+			const params = Array.isArray(payload?.params) ? payload.params : []
+			const target = this.__instance?.[method]
+
+			if (typeof target !== 'function') {
+				return new Response(JSON.stringify({
+					ok: false,
+					error: { message: 'Method not found: ' + String(method) }
+				}), {
+					status: 404,
+					headers: { 'Content-Type': 'application/json' }
+				})
+			}
+
+			let result = await target.apply(this.__instance, params)
+			result = __encodeTransport(result)
+
+			return new Response(JSON.stringify({ ok: true, result }), {
+				headers: { 'Content-Type': 'application/json' }
+			})
+		} catch (error) {
+			return new Response(JSON.stringify({
+				ok: false,
+				error: { message: error instanceof Error ? error.message : String(error) }
+			}), {
+				status: 500,
+				headers: { 'Content-Type': 'application/json' }
+			})
+		}
+	}
+}`.trim()).join(`
+
+`);
+}
+async function bundleDurableObjectModules(configDir, doInfos, transportFile) {
+  const virtualImports = [];
+  const virtualExports = [];
+  if (transportFile) {
+    const transportPath = join3(configDir, transportFile);
+    virtualImports.push(`import { transport } from '${transportPath.replace(/\\/g, "/")}'`);
+    virtualExports.push("export { transport }");
+  }
+  for (const info of doInfos) {
+    virtualImports.push(`import { ${info.className} } from '${info.scriptPath.replace(/\\/g, "/")}'`);
+    virtualExports.push(`export { ${info.className} }`);
+  }
+  if (virtualImports.length === 0) {
+    return "";
+  }
+  const virtualEntry = [...virtualImports, "", ...virtualExports].join(`
+`);
+  const virtualPath = join3(configDir, ".devflare", "__test_entry.ts");
+  mkdirSync(dirname3(virtualPath), { recursive: true });
+  writeFileSync(virtualPath, virtualEntry);
+  const bun = getBunRuntime2();
+  if (!bun) {
+    throw new Error("Bun runtime is required for createTestContext with Durable Objects");
+  }
+  const result = await bun.build({
+    entrypoints: [virtualPath],
+    target: "browser",
+    format: "esm",
+    minify: false,
+    external: ["cloudflare:workers", "cloudflare:*"]
+  });
+  if (!result.success) {
+    throw new Error(`Failed to bundle test entry: ${result.logs.join(`
+`)}`);
+  }
+  return await result.outputs[0].text();
+}
+async function buildDurableObjectGateway(config, configDir, transportFile) {
+  if (!config.bindings?.durableObjects) {
+    return {
+      script: buildGatewayScript("", "")
+    };
+  }
+  const { doConfig, doInfos } = await resolveLocalDurableObjects(config, configDir);
+  const bundledCode = await bundleDurableObjectModules(configDir, doInfos, transportFile);
+  const wrapperCode = buildWrapperCode(doInfos);
+  return {
+    durableObjects: doConfig,
+    script: buildGatewayScript(bundledCode, wrapperCode)
+  };
+}
+
+// src/test/email.ts
+import { join as join4 } from "path";
+var miniflarePort = 8787;
+var emailListeners = [];
+var sentEmails = [];
+var emailHandlerPath = null;
+var configDir = null;
+var testEnvGetter = null;
+function configureEmail(options = {}) {
+  if (options.port) {
+    miniflarePort = options.port;
+  }
+  emailHandlerPath = options.handlerPath ?? emailHandlerPath;
+  configDir = options.configDir ?? configDir;
+  testEnvGetter = options.getEnv ?? testEnvGetter;
+}
+function buildRawEmail(options) {
+  if (options.raw) {
+    return options.raw;
+  }
+  const lines = [];
+  const messageId = `<${Date.now()}-${Math.random().toString(36).slice(2)}@devflare.dev>`;
+  const date = new Date().toUTCString();
+  lines.push(`From: ${options.from}`);
+  lines.push(`To: ${options.to}`);
+  lines.push(`Date: ${date}`);
+  lines.push(`Message-ID: ${messageId}`);
+  if (options.subject) {
+    lines.push(`Subject: ${options.subject}`);
+  }
+  if (options.headers) {
+    for (const [key, value] of Object.entries(options.headers)) {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  lines.push("MIME-Version: 1.0");
+  lines.push("Content-Type: text/plain; charset=UTF-8");
+  lines.push("");
+  lines.push(options.body ?? "");
+  return lines.join(`\r
+`);
+}
+function createEmailHeaders(rawEmail) {
+  const headers = new Headers;
+  const lines = rawEmail.split(/\r?\n/);
+  for (const line of lines) {
+    if (!line.trim()) {
+      break;
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex <= 0) {
+      continue;
+    }
+    headers.append(line.slice(0, colonIndex).trim(), line.slice(colonIndex + 1).trim());
+  }
+  return headers;
+}
+function createRawEmailStream(rawEmail) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(new TextEncoder().encode(rawEmail));
+      controller.close();
+    }
+  });
+}
+function resolveEmailHandler(module) {
+  if (typeof module.default === "function") {
+    return module.default;
+  }
+  if (module.default && typeof module.default.email === "function") {
+    return module.default.email.bind(module.default);
+  }
+  if (typeof module.email === "function") {
+    return module.email;
+  }
+  return null;
+}
+function getRecordedRawContent(raw) {
+  if (typeof raw === "string") {
+    return raw;
+  }
+  return;
+}
+async function send(options) {
+  const raw = buildRawEmail(options);
+  if (emailHandlerPath && configDir && testEnvGetter) {
+    const absolutePath = join4(configDir, emailHandlerPath);
+    const handlerModule = await import(absolutePath);
+    const emailHandler = resolveEmailHandler(handlerModule);
+    if (!emailHandler) {
+      throw new Error(`Email handler at "${emailHandlerPath}" must export a default function or named "email" export.
+NaN`);
+    }
+    const waitUntilPromises = [];
+    const ctx = {
+      waitUntil(promise) {
+        waitUntilPromises.push(promise);
+      },
+      passThroughOnException() {},
+      props: {}
+    };
+    const runtimeEnv = testEnvGetter();
+    const timestamp = new Date;
+    const message = {
+      from: options.from,
+      to: options.to,
+      headers: createEmailHeaders(raw),
+      raw: createRawEmailStream(raw),
+      rawSize: raw.length,
+      setReject(reason) {
+        throw new Error(`Email rejected: ${reason}`);
+      },
+      async forward(rcptTo) {
+        recordSentEmail({
+          type: "forward",
+          from: options.from,
+          to: rcptTo,
+          raw,
+          timestamp
+        });
+      },
+      async reply(message2) {
+        recordSentEmail({
+          type: "reply",
+          from: message2.from ?? options.to,
+          to: message2.to ?? options.from,
+          raw: getRecordedRawContent(message2.raw),
+          timestamp
+        });
+      }
+    };
+    const emailEvent = createEmailEvent(message, runtimeEnv, ctx);
+    await runWithEventContext(emailEvent, () => emailHandler(emailEvent));
+    await Promise.all(waitUntilPromises);
+    return new Response(JSON.stringify({ ok: true, from: options.from, to: options.to }), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  const url = new URL(`http://localhost:${miniflarePort}/cdn-cgi/handler/email`);
+  url.searchParams.set("from", options.from);
+  url.searchParams.set("to", options.to);
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers: {
+      "Content-Type": "text/plain"
+    },
+    body: raw
+  });
+  return response;
+}
+function onReceive(callback) {
+  emailListeners.push(callback);
+  return () => {
+    emailListeners = emailListeners.filter((cb) => cb !== callback);
+  };
+}
+function getSentEmails() {
+  return [...sentEmails];
+}
+function clearSentEmails() {
+  sentEmails = [];
+}
+function recordSentEmail(email) {
+  sentEmails.push(email);
+  for (const listener of emailListeners) {
+    try {
+      listener(email);
+    } catch (error) {
+      console.error("[devflare/test] Email listener error:", error);
+    }
+  }
+}
+function resetEmailState() {
+  miniflarePort = 8787;
+  emailHandlerPath = null;
+  configDir = null;
+  testEnvGetter = null;
+  emailListeners = [];
+  sentEmails = [];
+}
+var email = {
+  send,
+  onReceive,
+  getSentEmails,
+  clearSentEmails
+};
+
+// src/test/queue.ts
+import { join as join5 } from "path";
+var queueHandlerPath = null;
+var configDir2 = null;
+var testEnvGetter2 = null;
+function configureQueue(options) {
+  queueHandlerPath = options.handlerPath;
+  configDir2 = options.configDir;
+  testEnvGetter2 = options.getEnv;
+}
+function resetQueueState() {
+  queueHandlerPath = null;
+  configDir2 = null;
+  testEnvGetter2 = null;
+}
+function createMessage(options) {
+  const id = options.id ?? crypto.randomUUID();
+  const timestamp = options.timestamp ?? new Date;
+  const attempts = options.attempts ?? 1;
+  let state = "pending";
+  return {
+    id,
+    timestamp,
+    body: options.body,
+    attempts,
+    ack() {
+      state = "acked";
+    },
+    retry(opts) {
+      state = "retried";
+    },
+    retryAll() {
+      state = "retried";
+    },
+    get _state() {
+      return state;
+    }
+  };
+}
+function createMessageBatch(messages) {
+  return {
+    queue: "test-queue",
+    messages,
+    ackAll() {
+      for (const msg of messages) {
+        msg.ack();
+      }
+    },
+    retryAll() {
+      for (const msg of messages) {
+        msg.retry();
+      }
+    }
+  };
+}
+async function trigger(messages) {
+  if (!queueHandlerPath) {
+    throw new Error("Queue handler not configured. Make sure your devflare.config.ts has files.queue set, " + "and the file exists at the specified path (default: src/queue.ts)");
+  }
+  if (!configDir2 || !testEnvGetter2) {
+    throw new Error("Queue helper not initialized. Call createTestContext() before using cf.queue.trigger()");
+  }
+  const absolutePath = join5(configDir2, queueHandlerPath);
+  const handlerModule = await import(absolutePath);
+  const queueHandler = handlerModule.default ?? handlerModule.queue;
+  if (typeof queueHandler !== "function") {
     throw new Error(`Queue handler at "${queueHandlerPath}" must export a default function or named "queue" export.
-Expected: export async function queue(event) { ... }
-Legacy compatibility is still supported for queue(batch, env, ctx).`);
+NaN`);
   }
   const normalizedMessages = messages.map((msg) => {
     if (typeof msg === "object" && msg !== null && "body" in msg) {
@@ -696,9 +1354,9 @@ Legacy compatibility is still supported for queue(batch, env, ctx).`);
     passThroughOnException() {},
     props: {}
   };
-  const env = testEnvGetter();
+  const env = testEnvGetter2();
   const queueEvent = createQueueEvent(batch, env, ctx);
-  await runWithEventContext(queueEvent, () => queueHandler(queueEvent, env, ctx));
+  await runWithEventContext(queueEvent, () => queueHandler(queueEvent));
   await Promise.all(waitUntilPromises);
   const acked = [];
   const retried = [];
@@ -723,46 +1381,45 @@ Legacy compatibility is still supported for queue(batch, env, ctx).`);
     total: mockMessages.length
   };
 }
-async function send(message) {
+async function send2(message) {
   return trigger([message]);
 }
 var queue = {
   trigger,
-  send
+  send: send2
 };
 
 // src/test/scheduled.ts
-import { join as join3 } from "path";
+import { join as join6 } from "path";
 var scheduledHandlerPath = null;
-var configDir2 = null;
-var testEnvGetter2 = null;
+var configDir3 = null;
+var testEnvGetter3 = null;
 function configureScheduled(options) {
   scheduledHandlerPath = options.handlerPath;
-  configDir2 = options.configDir;
-  testEnvGetter2 = options.getEnv;
+  configDir3 = options.configDir;
+  testEnvGetter3 = options.getEnv;
 }
 function resetScheduledState() {
   scheduledHandlerPath = null;
-  configDir2 = null;
-  testEnvGetter2 = null;
+  configDir3 = null;
+  testEnvGetter3 = null;
 }
 async function trigger2(cronOrOptions) {
   if (!scheduledHandlerPath) {
     throw new Error("Scheduled handler not configured. Make sure your devflare.config.ts has files.scheduled set, " + "and the file exists at the specified path (default: src/scheduled.ts)");
   }
-  if (!configDir2 || !testEnvGetter2) {
+  if (!configDir3 || !testEnvGetter3) {
     throw new Error("Scheduled helper not initialized. Call createTestContext() before using cf.scheduled.trigger()");
   }
   const options = typeof cronOrOptions === "string" ? { cron: cronOrOptions } : cronOrOptions ?? {};
   const cron = options.cron ?? "* * * * *";
   const scheduledTime = options.scheduledTime instanceof Date ? options.scheduledTime.getTime() : options.scheduledTime ?? Date.now();
-  const absolutePath = join3(configDir2, scheduledHandlerPath);
+  const absolutePath = join6(configDir3, scheduledHandlerPath);
   const handlerModule = await import(absolutePath);
   const scheduledHandler = handlerModule.default ?? handlerModule.scheduled;
   if (typeof scheduledHandler !== "function") {
     throw new Error(`Scheduled handler at "${scheduledHandlerPath}" must export a default function or named "scheduled" export.
-Expected: export async function scheduled(event) { ... }
-Legacy compatibility is still supported for scheduled(controller, env, ctx).`);
+NaN`);
   }
   const controller = {
     scheduledTime,
@@ -777,10 +1434,10 @@ Legacy compatibility is still supported for scheduled(controller, env, ctx).`);
     passThroughOnException() {},
     props: {}
   };
-  const env = testEnvGetter2();
+  const env = testEnvGetter3();
   const scheduledEvent = createScheduledEvent(controller, env, ctx);
   try {
-    await runWithEventContext(scheduledEvent, () => scheduledHandler(scheduledEvent, env, ctx));
+    await runWithEventContext(scheduledEvent, () => scheduledHandler(scheduledEvent));
     await Promise.all(waitUntilPromises);
     return {
       success: true,
@@ -800,117 +1457,8 @@ var scheduled = {
   trigger: trigger2
 };
 
-// src/test/worker.ts
-import { join as join4 } from "path";
-var fetchHandlerPath = null;
-var configDir3 = null;
-var testEnvGetter3 = null;
-var fileRoutes = [];
-function configureWorker(options) {
-  fetchHandlerPath = options.handlerPath;
-  fileRoutes = options.routes ?? [];
-  configDir3 = options.configDir;
-  testEnvGetter3 = options.getEnv;
-}
-function resetWorkerState() {
-  fetchHandlerPath = null;
-  fileRoutes = [];
-  configDir3 = null;
-  testEnvGetter3 = null;
-}
-async function fetch2(request, options) {
-  if (!fetchHandlerPath && fileRoutes.length === 0) {
-    throw new Error("Fetch handler not configured. Make sure your devflare.config.ts has files.fetch set or a routes directory is available, " + "and that the corresponding files exist (defaults: src/fetch.ts and src/routes/**).");
-  }
-  if (!configDir3 || !testEnvGetter3) {
-    throw new Error("Worker helper not initialized. Call createTestContext() before using cf.worker.fetch()");
-  }
-  const workerConfigDir = configDir3;
-  const getEnv = testEnvGetter3;
-  let req;
-  if (typeof request === "string") {
-    const url = request.startsWith("http") ? request : `http://localhost${request.startsWith("/") ? "" : "/"}${request}`;
-    const headers = new Headers(options?.headers);
-    let body;
-    if (options?.body !== undefined) {
-      if (typeof options.body === "string") {
-        body = options.body;
-      } else {
-        body = JSON.stringify(options.body);
-        if (!headers.has("Content-Type")) {
-          headers.set("Content-Type", "application/json");
-        }
-      }
-    }
-    req = new Request(url, {
-      method: options?.method ?? "GET",
-      headers,
-      body
-    });
-  } else {
-    req = request;
-  }
-  const handlerModule = fetchHandlerPath ? await import(join4(workerConfigDir, fetchHandlerPath)) : {};
-  const routeModules = await Promise.all(fileRoutes.map(async (route) => {
-    return {
-      ...route,
-      module: await import(join4(workerConfigDir, route.filePath))
-    };
-  }));
-  const methodExports = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "ALL"];
-  const hasMethodHandler = methodExports.some((method) => {
-    return typeof handlerModule[method] === "function" || typeof handlerModule.default?.[method] === "function";
-  });
-  if (!resolveFetchHandler(handlerModule) && !hasMethodHandler && routeModules.length === 0) {
-    throw new Error(`Fetch handler at "${fetchHandlerPath}" must export one of:
-- request-wide "handle" middleware
-- named "fetch"
-- default fetch handler
-- HTTP method exports such as "GET" or "POST"
-Legacy compatibility is still supported for fetch(request, env, ctx).`);
-  }
-  const waitUntilPromises = [];
-  const ctx = {
-    waitUntil(promise) {
-      waitUntilPromises.push(promise);
-    },
-    passThroughOnException() {},
-    props: {}
-  };
-  const env = getEnv();
-  const initialRouteMatch = routeModules.length > 0 ? matchFetchRoute(routeModules, req) : null;
-  const fetchEvent = createFetchEvent(req, env, ctx, {
-    params: initialRouteMatch?.params ?? {}
-  });
-  const response = await runWithEventContext(fetchEvent, () => invokeFetchModule(handlerModule, fetchEvent, routeModules.length > 0 ? createRouteResolve(routeModules, fetchEvent) : undefined));
-  return response;
-}
-async function get(path, headers) {
-  return fetch2(path, { method: "GET", headers });
-}
-async function post(path, body, headers) {
-  return fetch2(path, { method: "POST", body, headers });
-}
-async function put(path, body, headers) {
-  return fetch2(path, { method: "PUT", body, headers });
-}
-async function del(path, headers) {
-  return fetch2(path, { method: "DELETE", headers });
-}
-async function patch(path, body, headers) {
-  return fetch2(path, { method: "PATCH", body, headers });
-}
-var worker = {
-  fetch: fetch2,
-  get,
-  post,
-  put,
-  delete: del,
-  patch
-};
-
 // src/test/tail.ts
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 var tailHandlerPath = null;
 var configDir4 = null;
 var testEnvGetter4 = null;
@@ -956,13 +1504,12 @@ async function trigger3(items) {
     }
     return createTraceItem(item);
   });
-  const absolutePath = join5(configDir4, tailHandlerPath);
+  const absolutePath = join7(configDir4, tailHandlerPath);
   const handlerModule = await import(absolutePath);
   const tailHandler = handlerModule.default ?? handlerModule.tail;
   if (typeof tailHandler !== "function") {
     throw new Error(`Tail handler at "${tailHandlerPath}" must export a default function or named "tail" export.
-Expected: export async function tail(event) { ... }
-Legacy compatibility is still supported for tail(events, env, ctx).`);
+NaN`);
   }
   const waitUntilPromises = [];
   const ctx = {
@@ -975,7 +1522,7 @@ Legacy compatibility is still supported for tail(events, env, ctx).`);
   const env = testEnvGetter4();
   const tailEvent = createTailEvent(traceItems, env, ctx);
   try {
-    await runWithEventContext(tailEvent, () => tailHandler(tailEvent, env, ctx));
+    await runWithEventContext(tailEvent, () => tailHandler(tailEvent));
     await Promise.all(waitUntilPromises);
     return {
       success: true,
@@ -986,282 +1533,204 @@ Legacy compatibility is still supported for tail(events, env, ctx).`);
       success: false,
       error: error instanceof Error ? error.message : String(error),
       itemCount: traceItems.length
-    };
-  }
-}
-function create(options = {}) {
-  return createTraceItem(options);
-}
-var tail = {
-  trigger: trigger3,
-  create
-};
-
-// src/test/email.ts
-import { join as join6 } from "path";
-var miniflarePort = 8787;
-var emailListeners = [];
-var sentEmails = [];
-var emailHandlerPath = null;
-var configDir5 = null;
-var testEnvGetter5 = null;
-function configureEmail(options = {}) {
-  if (options.port) {
-    miniflarePort = options.port;
-  }
-  emailHandlerPath = options.handlerPath ?? emailHandlerPath;
-  configDir5 = options.configDir ?? configDir5;
-  testEnvGetter5 = options.getEnv ?? testEnvGetter5;
-}
-function buildRawEmail(options) {
-  if (options.raw) {
-    return options.raw;
-  }
-  const lines = [];
-  const messageId = `<${Date.now()}-${Math.random().toString(36).slice(2)}@devflare.dev>`;
-  const date = new Date().toUTCString();
-  lines.push(`From: ${options.from}`);
-  lines.push(`To: ${options.to}`);
-  lines.push(`Date: ${date}`);
-  lines.push(`Message-ID: ${messageId}`);
-  if (options.subject) {
-    lines.push(`Subject: ${options.subject}`);
-  }
-  if (options.headers) {
-    for (const [key, value] of Object.entries(options.headers)) {
-      lines.push(`${key}: ${value}`);
-    }
-  }
-  lines.push("MIME-Version: 1.0");
-  lines.push("Content-Type: text/plain; charset=UTF-8");
-  lines.push("");
-  lines.push(options.body ?? "");
-  return lines.join(`\r
-`);
-}
-function createEmailHeaders(rawEmail) {
-  const headers = new Headers;
-  const lines = rawEmail.split(/\r?\n/);
-  for (const line of lines) {
-    if (!line.trim()) {
-      break;
-    }
-    const colonIndex = line.indexOf(":");
-    if (colonIndex <= 0) {
-      continue;
-    }
-    headers.append(line.slice(0, colonIndex).trim(), line.slice(colonIndex + 1).trim());
+    };
   }
-  return headers;
 }
-function createRawEmailStream(rawEmail) {
-  return new ReadableStream({
-    start(controller) {
-      controller.enqueue(new TextEncoder().encode(rawEmail));
-      controller.close();
-    }
-  });
+function create(options = {}) {
+  return createTraceItem(options);
 }
-function resolveEmailHandler(module) {
-  if (typeof module.default === "function") {
-    return module.default;
-  }
-  if (module.default && typeof module.default.email === "function") {
-    return module.default.email.bind(module.default);
-  }
-  if (typeof module.email === "function") {
-    return module.email;
-  }
-  return null;
+var tail = {
+  trigger: trigger3,
+  create
+};
+
+// src/test/worker.ts
+import { join as join8 } from "path";
+var fetchHandlerPath = null;
+var configDir5 = null;
+var testEnvGetter5 = null;
+var fileRoutes = [];
+function configureWorker(options) {
+  fetchHandlerPath = options.handlerPath;
+  fileRoutes = options.routes ?? [];
+  configDir5 = options.configDir;
+  testEnvGetter5 = options.getEnv;
 }
-function getRecordedRawContent(raw) {
-  if (typeof raw === "string") {
-    return raw;
-  }
-  return;
+function resetWorkerState() {
+  fetchHandlerPath = null;
+  fileRoutes = [];
+  configDir5 = null;
+  testEnvGetter5 = null;
 }
-async function send2(options) {
-  const raw = buildRawEmail(options);
-  if (emailHandlerPath && configDir5 && testEnvGetter5) {
-    const absolutePath = join6(configDir5, emailHandlerPath);
-    const handlerModule = await import(absolutePath);
-    const emailHandler = resolveEmailHandler(handlerModule);
-    if (!emailHandler) {
-      throw new Error(`Email handler at "${emailHandlerPath}" must export a default function or named "email" export.
-Expected: export async function email(message) { ... }
-Legacy compatibility is still supported for email(message, env, ctx).`);
-    }
-    const waitUntilPromises = [];
-    const ctx = {
-      waitUntil(promise) {
-        waitUntilPromises.push(promise);
-      },
-      passThroughOnException() {},
-      props: {}
-    };
-    const runtimeEnv = testEnvGetter5();
-    const timestamp = new Date;
-    const message = {
-      from: options.from,
-      to: options.to,
-      headers: createEmailHeaders(raw),
-      raw: createRawEmailStream(raw),
-      rawSize: raw.length,
-      setReject(reason) {
-        throw new Error(`Email rejected: ${reason}`);
-      },
-      async forward(rcptTo) {
-        recordSentEmail({
-          type: "forward",
-          from: options.from,
-          to: rcptTo,
-          raw,
-          timestamp
-        });
-      },
-      async reply(message2) {
-        recordSentEmail({
-          type: "reply",
-          from: message2.from ?? options.to,
-          to: message2.to ?? options.from,
-          raw: getRecordedRawContent(message2.raw),
-          timestamp
-        });
+async function fetch2(request, options) {
+  if (!fetchHandlerPath && fileRoutes.length === 0) {
+    throw new Error("Fetch handler not configured. Make sure your devflare.config.ts has files.fetch set or a routes directory is available, " + "and that the corresponding files exist (defaults: src/fetch.ts and src/routes/**).");
+  }
+  if (!configDir5 || !testEnvGetter5) {
+    throw new Error("Worker helper not initialized. Call createTestContext() before using cf.worker.fetch()");
+  }
+  const workerConfigDir = configDir5;
+  const getEnv = testEnvGetter5;
+  let req;
+  if (typeof request === "string") {
+    const url = request.startsWith("http") ? request : `http://localhost${request.startsWith("/") ? "" : "/"}${request}`;
+    const headers = new Headers(options?.headers);
+    let body;
+    if (options?.body !== undefined) {
+      if (typeof options.body === "string") {
+        body = options.body;
+      } else {
+        body = JSON.stringify(options.body);
+        if (!headers.has("Content-Type")) {
+          headers.set("Content-Type", "application/json");
+        }
       }
-    };
-    const emailEvent = createEmailEvent(message, runtimeEnv, ctx);
-    await runWithEventContext(emailEvent, () => emailHandler(emailEvent, runtimeEnv, ctx));
-    await Promise.all(waitUntilPromises);
-    return new Response(JSON.stringify({ ok: true, from: options.from, to: options.to }), {
-      headers: { "Content-Type": "application/json" }
+    }
+    req = new Request(url, {
+      method: options?.method ?? "GET",
+      headers,
+      body
     });
+  } else {
+    req = request;
   }
-  const url = new URL(`http://localhost:${miniflarePort}/cdn-cgi/handler/email`);
-  url.searchParams.set("from", options.from);
-  url.searchParams.set("to", options.to);
-  const response = await fetch(url.toString(), {
-    method: "POST",
-    headers: {
-      "Content-Type": "text/plain"
+  const handlerModule = fetchHandlerPath ? await import(join8(workerConfigDir, fetchHandlerPath)) : {};
+  const routeModules = await Promise.all(fileRoutes.map(async (route) => {
+    return {
+      ...route,
+      module: await import(join8(workerConfigDir, route.filePath))
+    };
+  }));
+  const methodExports = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "ALL"];
+  const hasMethodHandler = methodExports.some((method) => {
+    return typeof handlerModule[method] === "function" || typeof handlerModule.default?.[method] === "function";
+  });
+  if (!resolveFetchHandler(handlerModule) && !hasMethodHandler && routeModules.length === 0) {
+    throw new Error(`Fetch handler at "${fetchHandlerPath}" must export one of:
+- request-wide "handle" middleware
+- named "fetch"
+- default fetch handler
+- HTTP method exports such as "GET" or "POST"`);
+  }
+  const waitUntilPromises = [];
+  const ctx = {
+    waitUntil(promise) {
+      waitUntilPromises.push(promise);
     },
-    body: raw
+    passThroughOnException() {},
+    props: {}
+  };
+  const env = getEnv();
+  const initialRouteMatch = routeModules.length > 0 ? matchFetchRoute(routeModules, req) : null;
+  const fetchEvent = createFetchEvent(req, env, ctx, {
+    params: initialRouteMatch?.params ?? {}
   });
+  const response = await runWithEventContext(fetchEvent, () => invokeFetchModule(handlerModule, fetchEvent, routeModules.length > 0 ? createRouteResolve(routeModules, fetchEvent) : undefined));
   return response;
 }
-function onReceive(callback) {
-  emailListeners.push(callback);
-  return () => {
-    emailListeners = emailListeners.filter((cb) => cb !== callback);
-  };
+async function get(path, headers) {
+  return fetch2(path, { method: "GET", headers });
 }
-function getSentEmails() {
-  return [...sentEmails];
+async function post(path, body, headers) {
+  return fetch2(path, { method: "POST", body, headers });
 }
-function clearSentEmails() {
-  sentEmails = [];
+async function put(path, body, headers) {
+  return fetch2(path, { method: "PUT", body, headers });
 }
-function recordSentEmail(email) {
-  sentEmails.push(email);
-  for (const listener of emailListeners) {
-    try {
-      listener(email);
-    } catch (error) {
-      console.error("[devflare/test] Email listener error:", error);
-    }
-  }
+async function del(path, headers) {
+  return fetch2(path, { method: "DELETE", headers });
 }
-function resetEmailState() {
-  miniflarePort = 8787;
-  emailHandlerPath = null;
-  configDir5 = null;
-  testEnvGetter5 = null;
-  emailListeners = [];
-  sentEmails = [];
+async function patch(path, body, headers) {
+  return fetch2(path, { method: "PATCH", body, headers });
 }
-var email = {
-  send: send2,
-  onReceive,
-  getSentEmails,
-  clearSentEmails
+var worker = {
+  fetch: fetch2,
+  get,
+  post,
+  put,
+  delete: del,
+  patch
 };
 
 // src/test/simple-context.ts
-function findExportedClasses(code) {
-  const classes = [];
-  const classPattern = /export\s+class\s+(\w+)/g;
-  let match;
-  while ((match = classPattern.exec(code)) !== null) {
-    classes.push(match[1]);
-  }
-  return classes;
-}
-function getBunRuntime2() {
-  const g = globalThis;
-  if (typeof g.Bun === "object" && g.Bun !== null) {
-    return g.Bun;
-  }
-  return;
-}
 var globalClient = null;
 var globalMiniflare = null;
 var globalEnvProxy = null;
 var globalTransportDecode = null;
 var globalRemoteBindings = null;
 var globalMiniflareBindings = null;
-var DEFAULT_TRANSPORT_ENTRY_FILES = [
-  "src/transport.ts",
-  "src/transport.js",
-  "src/transport.mts",
-  "src/transport.mjs"
-];
-function getCallerDirectory() {
-  const bun = getBunRuntime2();
-  if (bun?.main) {
-    const mainPath = bun.main;
-    if (!mainPath.includes("[") && existsSync2(mainPath)) {
-      return dirname2(mainPath);
-    }
-  }
-  const originalPrepare = Error.prepareStackTrace;
-  Error.prepareStackTrace = (_, stack2) => stack2;
-  const err = new Error;
-  const stack = err.stack;
-  Error.prepareStackTrace = originalPrepare;
-  for (const site of stack) {
-    const filename = site.getFileName?.();
-    if (filename && !filename.includes("simple-context") && !filename.includes("node_modules") && !filename.includes("[") && existsSync2(filename)) {
-      return dirname2(filename);
-    }
+var TEST_CONTEXT_STARTUP_RETRY_ATTEMPTS = 3;
+var TEST_CONTEXT_STARTUP_RETRY_DELAY_MS = 75;
+var TEST_CONTEXT_BRIDGE_CONNECT_RETRY_ATTEMPTS = 8;
+var TEST_CONTEXT_BRIDGE_CONNECT_RETRY_DELAY_MS = 150;
+function isRetriableTestContextStartupError(error) {
+  if (!(error instanceof Error)) {
+    return false;
   }
-  return process.cwd();
+  const message = error.message.toLowerCase();
+  return message.includes("websocket connection failed") || message.includes("connection timeout: ws://") || message.includes("econnrefused") || message.includes("eaddrinuse") || message.includes("address already in use");
 }
-async function findNearestConfig(startDir) {
-  let currentDir = startDir;
-  while (true) {
-    const configPath = await resolveConfigPath(currentDir);
-    if (configPath) {
-      return configPath;
-    }
-    const parentDir = dirname2(currentDir);
-    if (parentDir === currentDir) {
-      return null;
+async function waitForTestContextStartupRetry() {
+  await new Promise((resolve3) => setTimeout(resolve3, TEST_CONTEXT_STARTUP_RETRY_DELAY_MS));
+}
+async function waitForBridgeClientRetry() {
+  await new Promise((resolve3) => setTimeout(resolve3, TEST_CONTEXT_BRIDGE_CONNECT_RETRY_DELAY_MS));
+}
+function shouldPreferBridgeBinding(hint) {
+  return hint === "do" || hint === "service";
+}
+async function connectBridgeClientWithRetry(url) {
+  let lastError;
+  for (let attempt = 1;attempt <= TEST_CONTEXT_BRIDGE_CONNECT_RETRY_ATTEMPTS; attempt++) {
+    const client = new BridgeClient({ url });
+    try {
+      await client.connect();
+      return client;
+    } catch (error) {
+      lastError = error;
+      client.disconnect();
+      if (attempt >= TEST_CONTEXT_BRIDGE_CONNECT_RETRY_ATTEMPTS || !isRetriableTestContextStartupError(error)) {
+        throw error;
+      }
+      await waitForBridgeClientRetry();
     }
-    currentDir = parentDir;
   }
+  throw lastError instanceof Error ? lastError : new Error("Bridge-backed test context could not connect to the WebSocket gateway.");
 }
-function resolveTransportFile(configDir6, configuredPath) {
-  if (typeof configuredPath === "string") {
-    return configuredPath;
-  }
-  if (configuredPath === null) {
-    return null;
-  }
-  for (const defaultEntry of DEFAULT_TRANSPORT_ENTRY_FILES) {
-    if (existsSync2(join7(configDir6, defaultEntry))) {
-      return defaultEntry;
+async function startBridgeBackedTestContext(mfConfig) {
+  const { Miniflare } = await import("miniflare");
+  for (let attempt = 1;attempt <= TEST_CONTEXT_STARTUP_RETRY_ATTEMPTS; attempt++) {
+    const port = await getAvailablePort();
+    let miniflare = null;
+    let client = null;
+    try {
+      miniflare = new Miniflare({
+        ...mfConfig,
+        port
+      });
+      await miniflare.ready;
+      const miniflareBindings = wrapEnvSendEmailBindings(await miniflare.getBindings());
+      client = await connectBridgeClientWithRetry(`ws://localhost:${port}`);
+      return {
+        port,
+        client,
+        miniflare,
+        miniflareBindings
+      };
+    } catch (error) {
+      client?.disconnect();
+      if (miniflare) {
+        try {
+          await miniflare.dispose();
+        } catch {}
+      }
+      if (attempt >= TEST_CONTEXT_STARTUP_RETRY_ATTEMPTS || !isRetriableTestContextStartupError(error)) {
+        throw error;
+      }
+      await waitForTestContextStartupRetry();
     }
   }
-  return null;
+  throw new Error("Bridge-backed test context startup exhausted all retry attempts.");
 }
 async function createTestContext(configPath) {
   const callerDir = getCallerDirectory();
@@ -1272,12 +1741,12 @@ async function createTestContext(configPath) {
     const found = await findNearestConfig(callerDir);
     if (!found) {
       throw new Error(`Could not find a devflare config file. Searched upward from: ${callerDir}
-` + `Expected one of: devflare.config.ts, devflare.config.mts, devflare.config.js, devflare.config.mjs
-` + `Either create a config file or provide an explicit path: createTestContext('./path/to/config.ts')`);
+Expected one of: devflare.config.ts, devflare.config.mts, devflare.config.js, devflare.config.mjs
+Either create a config file or provide an explicit path: createTestContext('./path/to/config.ts')`);
     }
     absolutePath = found;
   }
-  const configDir6 = dirname2(absolutePath);
+  const configDir6 = dirname4(absolutePath);
   const config = await loadConfig({
     cwd: configDir6,
     configFile: absolutePath.split(/[/\\]/).pop()
@@ -1306,28 +1775,34 @@ async function createTestContext(configPath) {
   }
   const hints = {};
   if (config.bindings?.kv) {
-    for (const name of Object.keys(config.bindings.kv))
+    for (const name of Object.keys(config.bindings.kv)) {
       hints[name] = "kv";
+    }
   }
   if (config.bindings?.r2) {
-    for (const name of Object.keys(config.bindings.r2))
+    for (const name of Object.keys(config.bindings.r2)) {
       hints[name] = "r2";
+    }
   }
   if (config.bindings?.d1) {
-    for (const name of Object.keys(config.bindings.d1))
+    for (const name of Object.keys(config.bindings.d1)) {
       hints[name] = "d1";
+    }
   }
   if (config.bindings?.durableObjects) {
-    for (const name of Object.keys(config.bindings.durableObjects))
+    for (const name of Object.keys(config.bindings.durableObjects)) {
       hints[name] = "do";
+    }
   }
   if (config.bindings?.services) {
-    for (const name of Object.keys(config.bindings.services))
+    for (const name of Object.keys(config.bindings.services)) {
       hints[name] = "service";
+    }
   }
   if (config.bindings?.sendEmail) {
-    for (const name of Object.keys(config.bindings.sendEmail))
+    for (const name of Object.keys(config.bindings.sendEmail)) {
       hints[name] = "sendEmail";
+    }
   }
   const needsMultiWorkerForServices = hasServiceBindings(config);
   const needsMultiWorkerForDOs = hasCrossWorkerDOs(config);
@@ -1340,18 +1815,21 @@ async function createTestContext(configPath) {
   if (needsMultiWorkerForDOs) {
     doBindingResolution = await resolveDOBindings(config, configDir6);
   }
-  const randomPort = 1e4 + Math.floor(Math.random() * 50000);
   const localWorkerBindings = config.vars ?? {};
   const mfConfig = {
-    modules: true,
-    port: randomPort
+    modules: true
   };
-  if (config.bindings?.kv)
+  if (config.bindings?.kv) {
     mfConfig.kvNamespaces = Object.keys(config.bindings.kv);
-  if (config.bindings?.r2)
+  }
+  if (config.bindings?.r2) {
     mfConfig.r2Buckets = Object.keys(config.bindings.r2);
-  if (config.bindings?.d1)
-    mfConfig.d1Databases = Object.keys(config.bindings.d1);
+  }
+  if (config.bindings?.d1) {
+    mfConfig.d1Databases = Object.fromEntries(Object.entries(config.bindings.d1).map(([bindingName, bindingConfig]) => {
+      return [bindingName, getLocalD1DatabaseIdentifier(bindingConfig)];
+    }));
+  }
   if (config.bindings?.queues?.producers) {
     const queueProducers = {};
     for (const [bindingName, queueName] of Object.entries(config.bindings.queues.producers)) {
@@ -1380,7 +1858,7 @@ async function createTestContext(configPath) {
   }
   const transportFile = resolveTransportFile(configDir6, config.files?.transport);
   if (transportFile) {
-    const transportPath = join7(configDir6, transportFile);
+    const transportPath = join9(configDir6, transportFile);
     const transportModule = await import(transportPath);
     if (!transportModule.transport) {
       console.warn(`[devflare] Warning: Transport file "${transportFile}" does not export a named "transport" object.
@@ -1394,86 +1872,10 @@ Transport encoding/decoding will be disabled.`);
       }
     }
   }
-  if (config.bindings?.durableObjects) {
-    const doConfig = {};
-    const doInfos = [];
-    const classToFilePath = new Map;
-    const doPatternConfig = config.files?.durableObjects;
-    const doPattern = typeof doPatternConfig === "string" ? doPatternConfig : DEFAULT_DO_PATTERN;
-    if (doPatternConfig !== false) {
-      const fs = await import("fs/promises");
-      const doFiles = await findFiles(doPattern, { cwd: configDir6 });
-      for (const filePath of doFiles) {
-        try {
-          const code = await fs.readFile(filePath, "utf-8");
-          const classNames = findExportedClasses(code);
-          for (const className of classNames) {
-            classToFilePath.set(className, filePath);
-          }
-        } catch {}
-      }
-    }
-    for (const [name, rawDoInfo] of Object.entries(config.bindings.durableObjects)) {
-      const doInfo = normalizeDOBinding(rawDoInfo);
-      if (doInfo.__ref) {
-        continue;
-      }
-      let scriptPath;
-      if (doInfo.scriptName) {
-        scriptPath = join7(configDir6, "src", doInfo.scriptName);
-      } else {
-        const discoveredPath = classToFilePath.get(doInfo.className);
-        if (!discoveredPath) {
-          throw new Error(`Durable object ${name} (className: '${doInfo.className}') not found.
-Either:
-  1. Set files.durableObjects pattern in config (e.g., 'src/do.*.ts')
-  2. Use explicit scriptName: { className: '${doInfo.className}', scriptName: 'do.file.ts' }`);
-        }
-        scriptPath = discoveredPath;
-      }
-      doConfig[name] = doInfo.className;
-      doInfos.push({ name, className: doInfo.className, scriptPath });
-    }
-    const virtualImports = [];
-    const virtualExports = [];
-    if (transportFile) {
-      const transportPath = join7(configDir6, transportFile);
-      virtualImports.push(`import { transport } from '${transportPath.replace(/\\/g, "/")}'`);
-      virtualExports.push("export { transport }");
-    }
-    for (const info of doInfos) {
-      virtualImports.push(`import { ${info.className} } from '${info.scriptPath.replace(/\\/g, "/")}'`);
-      virtualExports.push(`export { ${info.className} }`);
-    }
-    let bundledCode = "";
-    if (virtualImports.length > 0) {
-      const virtualEntry = [...virtualImports, "", ...virtualExports].join(`
-`);
-      const virtualPath = join7(configDir6, ".devflare", "__test_entry.ts");
-      const { writeFileSync, mkdirSync } = await import("fs");
-      mkdirSync(dirname2(virtualPath), { recursive: true });
-      writeFileSync(virtualPath, virtualEntry);
-      const bun = getBunRuntime2();
-      if (!bun) {
-        throw new Error("Bun runtime is required for createTestContext with Durable Objects");
-      }
-      const result = await bun.build({
-        entrypoints: [virtualPath],
-        target: "browser",
-        format: "esm",
-        minify: false,
-        external: ["cloudflare:workers", "cloudflare:*"]
-      });
-      if (!result.success) {
-        throw new Error(`Failed to bundle test entry: ${result.logs.join(`
-`)}`);
-      }
-      bundledCode = await result.outputs[0].text();
-    }
-    mfConfig.durableObjects = doConfig;
-    mfConfig.script = buildGatewayScript(bundledCode, "");
-  } else {
-    mfConfig.script = buildGatewayScript("", "");
+  const gateway = await buildDurableObjectGateway(config, configDir6, transportFile);
+  mfConfig.script = gateway.script;
+  if (gateway.durableObjects) {
+    mfConfig.durableObjects = gateway.durableObjects;
   }
   const hasMultiWorkerServices = serviceBindingResolution && serviceBindingResolution.workers.length > 0;
   const hasMultiWorkerDOs = doBindingResolution && doBindingResolution.workers.length > 0;
@@ -1502,14 +1904,14 @@ Either:
     for (const worker2 of additionalWorkers) {
       if (!workersByName.has(worker2.name)) {
         workersByName.set(worker2.name, worker2);
-      } else {
-        const existing = workersByName.get(worker2.name);
-        if (worker2.durableObjects) {
-          existing.durableObjects = {
-            ...existing.durableObjects || {},
-            ...worker2.durableObjects
-          };
-        }
+        continue;
+      }
+      const existing = workersByName.get(worker2.name);
+      if (worker2.durableObjects) {
+        existing.durableObjects = {
+          ...existing.durableObjects || {},
+          ...worker2.durableObjects
+        };
       }
     }
     const workers = [primaryWorker, ...workersByName.values()];
@@ -1521,10 +1923,23 @@ Either:
     delete mfConfig.durableObjects;
     mfConfig.workers = workers;
   }
-  const { Miniflare } = await import("miniflare");
-  globalMiniflare = new Miniflare(mfConfig);
-  await globalMiniflare.ready;
-  globalMiniflareBindings = wrapEnvSendEmailBindings(await globalMiniflare.getBindings());
+  let activePort;
+  if (hasMultiWorkerServices || hasMultiWorkerDOs) {
+    const { Miniflare } = await import("miniflare");
+    activePort = await getAvailablePort();
+    globalMiniflare = new Miniflare({
+      ...mfConfig,
+      port: activePort
+    });
+    await globalMiniflare.ready;
+    globalMiniflareBindings = wrapEnvSendEmailBindings(await globalMiniflare.getBindings());
+  } else {
+    const startedBridgeBackedTestContext = await startBridgeBackedTestContext(mfConfig);
+    activePort = startedBridgeBackedTestContext.port;
+    globalMiniflare = startedBridgeBackedTestContext.miniflare;
+    globalMiniflareBindings = startedBridgeBackedTestContext.miniflareBindings;
+    globalClient = startedBridgeBackedTestContext.client;
+  }
   const disposeContext = async () => {
     if (globalClient) {
       await globalClient.disconnect();
@@ -1577,11 +1992,13 @@ Either:
   const DEFAULT_EMAIL_PATH = "src/email.ts";
   const DEFAULT_TAIL_PATH = "src/tail.ts";
   const resolvePath = async (configValue, defaultPath) => {
-    if (typeof configValue === "string")
+    if (typeof configValue === "string") {
       return configValue;
-    if (configValue === false)
+    }
+    if (configValue === false) {
       return null;
-    const defaultAbsolute = join7(configDir6, defaultPath);
+    }
+    const defaultAbsolute = join9(configDir6, defaultPath);
     try {
       const fs = await import("fs/promises");
       await fs.access(defaultAbsolute);
@@ -1624,7 +2041,7 @@ Either:
     getEnv: getTestEnv
   });
   configureEmail({
-    port: randomPort,
+    port: activePort,
     handlerPath: resolvedEmailPath,
     configDir: configDir6,
     getEnv: getTestEnv
@@ -1648,29 +2065,31 @@ Either:
     __setTestContext(envAccessor2, disposeContext);
     return;
   }
-  globalClient = new BridgeClient({
-    url: `ws://localhost:${randomPort}`
-  });
-  await globalClient.connect();
+  const bridgeClient = globalClient;
+  if (!bridgeClient) {
+    throw new Error("Bridge-backed test context did not initialize a client.");
+  }
   setBindingHints(hints);
   globalEnvProxy = createEnvProxy({
-    client: globalClient,
+    client: bridgeClient,
     transformResult: (result) => decodeTransport(result)
   });
   const envAccessor = new Proxy({}, {
     get(_, prop) {
+      const hint = hints[prop];
+      const prefersBridgeBinding = shouldPreferBridgeBinding(hint);
       if (globalRemoteBindings && prop in globalRemoteBindings) {
         return globalRemoteBindings[prop];
       }
-      if (hints[prop] === "sendEmail" && globalEnvProxy && prop in globalEnvProxy) {
-        return globalEnvProxy[prop];
-      }
-      if (globalMiniflareBindings && prop in globalMiniflareBindings) {
+      if (!prefersBridgeBinding && globalMiniflareBindings && prop in globalMiniflareBindings) {
         return globalMiniflareBindings[prop];
       }
       if (globalEnvProxy) {
         return globalEnvProxy[prop];
       }
+      if (prefersBridgeBinding && globalMiniflareBindings && prop in globalMiniflareBindings) {
+        return globalMiniflareBindings[prop];
+      }
       return;
     },
     has(_, prop) {
@@ -1699,184 +2118,6 @@ function decodeTransport(value) {
   }
   return result;
 }
-function buildGatewayScript(bundledCode, wrappers) {
-  return `
-// Bundled transport + DO classes
-${bundledCode}
-
-// DO Wrappers with RPC
-${wrappers}
-
-// Transport encoding helper
-const __transportEncoders = typeof transport !== 'undefined' ? transport : {}
-
-function __encodeTransport(value) {
-	if (value === null || value === undefined) return value
-	
-	// Try each encoder
-	for (const [typeName, transporter] of Object.entries(__transportEncoders)) {
-		const encoded = transporter.encode(value)
-		if (encoded !== false && encoded !== undefined) {
-			return { __transport: typeName, value: encoded }
-		}
-	}
-	
-	// Recursively encode arrays and objects
-	if (Array.isArray(value)) {
-		return value.map(__encodeTransport)
-	}
-	if (typeof value === 'object') {
-		const result = {}
-		for (const [k, v] of Object.entries(value)) {
-			result[k] = __encodeTransport(v)
-		}
-		return result
-	}
-	
-	return value
-}
-
-// Gateway with WebSocket RPC
-export default {
-	async fetch(request, env) {
-		if (request.headers.get('Upgrade') === 'websocket') {
-			const { 0: client, 1: server } = new WebSocketPair()
-			server.accept()
-			server.addEventListener('message', async (e) => {
-				try {
-					const m = JSON.parse(e.data)
-					if (m.t === 'rpc.call') {
-						const result = await executeRpc(env, m.method, m.params)
-						server.send(JSON.stringify({ t: 'rpc.ok', id: m.id, result }))
-					}
-				} catch (error) {
-					server.send(JSON.stringify({ t: 'rpc.err', id: 'unknown', error: { code: 'RPC_ERROR', message: error.message } }))
-				}
-			})
-			return new Response(null, { status: 101, webSocket: client })
-		}
-		return new Response('Gateway')
-	}
-}
-
-async function executeRpc(env, method, params) {
-	const [bindingName, ...rest] = method.split('.')
-	const op = rest.join('.')
-	const binding = env[bindingName]
-	const RAW_EMAIL = 'EmailMessage::raw'
-	if (!binding) throw new Error('Binding not found: ' + bindingName)
-
-	// KV operations
-	if (op === 'get') return binding.get(params[0], params[1])
-	if (op === 'put') return binding.put(params[0], params[1], params[2])
-	if (op === 'delete') return binding.delete(params[0])
-	if (op === 'list') return binding.list(params[0])
-	if (op === 'getWithMetadata') return binding.getWithMetadata(params[0], params[1])
-
-	// R2 operations
-	if (op === 'r2.get') return binding.get(params[0], params[1])
-	if (op === 'r2.put') return binding.put(params[0], params[1], params[2])
-	if (op === 'r2.delete') return binding.delete(params[0])
-	if (op === 'r2.list') return binding.list(params[0])
-	if (op === 'head') return binding.head(params[0])
-
-	// D1 operations
-	if (op === 'exec') return binding.exec(params[0])
-	if (op === 'dump') return binding.dump()
-	if (op === 'batch') {
-		const stmts = params[0].map(s => {
-			const stmt = binding.prepare(s.sql)
-			return s.bindings?.length ? stmt.bind(...s.bindings) : stmt
-		})
-		return binding.batch(stmts)
-	}
-	if (op === 'prepare.run') return binding.prepare(params[0]).bind(...(params[1] || [])).run()
-	if (op === 'prepare.all') return binding.prepare(params[0]).bind(...(params[1] || [])).all()
-	if (op === 'prepare.first') return binding.prepare(params[0]).bind(...(params[1] || [])).first(params[2])
-	if (op === 'prepare.raw') return binding.prepare(params[0]).bind(...(params[1] || [])).raw({ columnNames: params[2] })
-
-	// Send email operations
-	if (op === 'email.send') {
-		return binding.send(__normalizeEmailMessage(params[0]))
-	}
-
-	// DO operations
-	if (op === 'idFromName') {
-		return { __type: 'DOId', hex: binding.idFromName(params[0]).toString() }
-	}
-	if (op === 'stub.rpc') {
-		const [, idSerialized, rpcMethod, rpcParams] = params
-		const stub = binding.get(binding.idFromString(idSerialized.hex))
-		
-		// Use native RPC: call method directly on stub
-		// This works for DOs extending DurableObject from cloudflare:workers
-		let result = await stub[rpcMethod](...(rpcParams || []))
-		// Apply transport encoding
-		result = __encodeTransport(result)
-		return result
-	}
-
-	throw new Error('Unknown operation: ' + method)
-}
-
-function __createEmailMessageRaw(raw) {
-	if (typeof raw === 'string' || raw instanceof ReadableStream) {
-		return raw
-	}
-	if (raw instanceof Uint8Array || raw instanceof ArrayBuffer) {
-		return new Response(raw).body
-	}
-	throw new Error('Unsupported EmailMessage raw payload')
-}
-
-function __buildRawEmail(message) {
-	const lines = []
-	const messageId = '<' + Date.now() + '-' + Math.random().toString(36).slice(2) + '@devflare.dev>'
-
-	lines.push('From: ' + message.from)
-	lines.push('To: ' + (Array.isArray(message.to) ? message.to.join(', ') : message.to))
-	lines.push('Date: ' + new Date().toUTCString())
-	lines.push('Message-ID: ' + messageId)
-
-	if (message.subject) lines.push('Subject: ' + message.subject)
-	if (message.replyTo) lines.push('Reply-To: ' + String(message.replyTo))
-	if (message.cc) lines.push('Cc: ' + (Array.isArray(message.cc) ? message.cc.join(', ') : message.cc))
-	if (message.bcc) lines.push('Bcc: ' + (Array.isArray(message.bcc) ? message.bcc.join(', ') : message.bcc))
-
-	for (const [key, value] of Object.entries(message.headers || {})) {
-		lines.push(key + ': ' + value)
-	}
-
-	lines.push('MIME-Version: 1.0')
-	lines.push('Content-Type: ' + (message.html ? 'text/html' : 'text/plain') + '; charset=UTF-8')
-	lines.push('')
-	lines.push(String(message.html ?? message.text ?? '').replace(/\\r?\\n/g, '\\r\\n'))
-
-	return lines.join('\\r\\n')
-}
-
-function __normalizeEmailMessage(message) {
-	if (!message || typeof message !== 'object' || !('from' in message) || !('to' in message)) {
-		return message
-	}
-	if ('EmailMessage::raw' in message) {
-		return message
-	}
-	if ('raw' in message && message.raw !== undefined) {
-		return {
-			from: message.from,
-			to: message.to,
-			[RAW_EMAIL]: __createEmailMessageRaw(message.raw)
-		}
-	}
-	return {
-		from: message.from,
-		to: message.to,
-		[RAW_EMAIL]: __createEmailMessageRaw(__buildRawEmail(message))
-	}
-}
-`;
-}
 // src/test/cf.ts
 var cf = {
   email,
@@ -1885,71 +2126,11 @@ var cf = {
   worker,
   tail
 };
-// src/test/multi-worker-context.ts
-async function createMultiWorkerContext(options) {
-  const { workers, primary } = options;
-  const primaryName = primary ?? workers[0]?.name;
-  if (!primaryName) {
-    throw new Error("At least one worker must be configured");
-  }
-  const { Miniflare } = await import("miniflare");
-  const mfWorkers = workers.map((worker2) => {
-    const serviceBindings = {};
-    if (worker2.serviceBindings) {
-      for (const [bindingName, target] of Object.entries(worker2.serviceBindings)) {
-        if (typeof target === "string") {
-          serviceBindings[bindingName] = { name: target };
-        } else {
-          serviceBindings[bindingName] = target;
-        }
-      }
-    }
-    return {
-      name: worker2.name,
-      modules: worker2.modules ?? true,
-      script: worker2.script,
-      compatibilityDate: worker2.compatibilityDate ?? "2025-01-01",
-      ...Object.keys(serviceBindings).length > 0 ? { serviceBindings } : {}
-    };
-  });
-  const mf = new Miniflare({
-    workers: mfWorkers
-  });
-  const env2 = await mf.getBindings();
-  const fetch3 = async (input, init) => {
-    const response = await mf.dispatchFetch(input, init);
-    return response;
-  };
-  const dispose = async () => {
-    await new Promise((r) => setTimeout(r, 50));
-    await mf.dispose();
-  };
-  return {
-    mf,
-    env: env2,
-    fetch: fetch3,
-    dispose
-  };
-}
-function createEntrypointScript(className, methods) {
-  const methodDefs = Object.entries(methods).map(([name, body]) => `	${name}${body}`).join(`
-
-`);
-  return `import { WorkerEntrypoint } from 'cloudflare:workers'
-
-export class ${className} extends WorkerEntrypoint {
-${methodDefs}
-}
-`;
-}
 // src/test/should-skip.ts
 var REMOTE_ONLY_SERVICES = new Set([
   "ai",
   "vectorize"
 ]);
-function isRemoteModeEnabled() {
-  return isRemoteModeActive();
-}
 var skipResults = new Map;
 var EXPECTED_ERROR_PATTERNS = [
   "ECONNREFUSED",
@@ -2465,4 +2646,4 @@ var testEnv = new Proxy({}, {
 function isKVNamespace(binding) {
   return typeof binding === "object" && binding !== null && "get" in binding && "put" in binding && "delete" in binding && "list" in binding;
 }
-export { clearBundleCache, hasServiceBindings, resolveServiceBindings, hasCrossWorkerDOs, resolveDOBindings, queue, scheduled, worker, tail, email, createTestContext, cf, createMultiWorkerContext, createEntrypointScript, isRemoteModeEnabled, shouldSkip, createMockTestContext, withTestContext, createMockKV, createMockD1, createMockR2, createMockQueue, createMockEnv, createBridgeTestContext, stopBridgeTestContext, getBridgeTestContext, testEnv };
+export { clearBundleCache, hasServiceBindings, resolveServiceBindings, hasCrossWorkerDOs, resolveDOBindings, email, queue, scheduled, tail, worker, createTestContext, cf, shouldSkip, createMockTestContext, withTestContext, createMockKV, createMockD1, createMockR2, createMockQueue, createMockEnv, createBridgeTestContext, stopBridgeTestContext, getBridgeTestContext, testEnv };