devflare 1.0.0-next.16 → 1.0.0-next.18

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

@@ -1,220 +1,82 @@
 import {
   getRemoteModeStatus,
   isRemoteModeActive
-} from "./index-d8bdkx2h.js";
+} from "../index-d8bdkx2h.js";
 import {
   discoverEntrypointsSync
-} from "./index-zt22fe2j.js";
+} from "../index-zt22fe2j.js";
+import {
+  resolvePackageSpecifier
+} from "../index-t4fhcx1n.js";
 import {
   canProceedWithTest
-} from "./index-7g8zyws4.js";
+} from "../index-15fpa5tx.js";
 import {
   transformWorkerEntrypoint
-} from "./index-wfbfz02q.js";
-import {
-  resolvePackageSpecifier
-} from "./index-82f1z98k.js";
-import {
-  __clearTestContext,
-  __setTestContext
-} from "./index-m3fmw6mx.js";
+} from "../index-7k278fgz.js";
 import {
   createRouteResolve,
   invokeFetchModule,
   matchFetchRoute,
   resolveFetchHandler
-} from "./index-hjy8ctpc.js";
+} from "../index-tt4fsv91.js";
 import {
+  __clearTestContext,
+  __setTestContext,
   createEmailEvent,
   createFetchEvent,
   createQueueEvent,
   createScheduledEvent,
   createTailEvent,
+  env,
   runWithContext,
   runWithEventContext
-} from "./index-cgbvmse6.js";
+} from "../index-esjrgt3y.js";
+import"../index-a855bdsx.js";
 import {
   discoverRoutes
-} from "./index-1p814k7s.js";
+} from "../index-3e7by9sy.js";
 import {
   DEFAULT_DO_PATTERN,
   findFiles,
   findFilesSync
-} from "./index-rbht7m9r.js";
+} from "../index-rbht7m9r.js";
+import"../index-65e7xx1a.js";
 import {
   findDurableObjectClasses
-} from "./index-9wt9x09k.js";
+} from "../index-vhqww6tt.js";
 import {
-  startMiniflare,
-  startMiniflareFromConfig
-} from "./index-ry131z23.js";
+  extractBindingHints
+} from "../index-xskax7r3.js";
 import {
   BridgeClient,
   createEnvProxy,
   setBindingHints
-} from "./index-9ba1etyz.js";
+} from "../index-a75ejnvt.js";
 import {
   createLocalSendEmailBinding,
   wrapEnvSendEmailBindings
-} from "./index-h18pxvzs.js";
+} from "../index-124e9t4t.js";
+import"../index-kawa49m8.js";
 import {
   getLocalD1DatabaseIdentifier,
   loadConfig,
   normalizeDOBinding,
   resolveConfigPath
-} from "./index-6psz1h4c.js";
+} from "../index-5vzcszr2.js";
 import {
   getEffectiveAccountId,
   getPrimaryAccount
-} from "./index-xk9djfjp.js";
+} from "../index-1d4jg11n.js";
 import {
   getApiToken,
   isAuthenticated
-} from "./index-0w826dsr.js";
+} from "../index-mg8vwqxf.js";
+import"../index-c0whkev9.js";
+import"../index-q8f4kawk.js";
 import {
   __require
-} from "./index-37x76zdn.js";
-
-// src/test/simple-context.ts
-import { dirname as dirname4, join as join9, resolve as resolve2 } from "path";
-
-// src/test/remote-cloudflare.ts
-function createRemoteCloudflareClient(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;
-  }
-  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) {
-      return cloudflare.jsonRequest({
-        method: "POST",
-        path: `/ai/run/${model}`,
-        serviceLabel: "AI",
-        body: JSON.stringify(inputs)
-      });
-    },
-    gateway(_gatewayId) {
-      console.warn("AI Gateway is not supported in remote test mode");
-      return ai;
-    }
-  };
-  return ai;
-}
-
-// src/test/remote-vectorize.ts
-function createRemoteVectorize(indexName, accountId) {
-  const cloudflare = createRemoteCloudflareClient(accountId);
-  async function apiRequest(method, endpoint, body) {
-    return cloudflare.jsonRequest({
-      method,
-      path: `/vectorize/v2/indexes/${indexName}${endpoint}`,
-      serviceLabel: "Vectorize",
-      body: body ? JSON.stringify(body) : undefined
-    });
-  }
-  async function ndjsonRequest(endpoint, vectors) {
-    const ndjson = vectors.map((v) => JSON.stringify(v)).join(`
-`);
-    return cloudflare.jsonRequest({
-      method: "POST",
-      path: `/vectorize/v2/indexes/${indexName}${endpoint}`,
-      serviceLabel: "Vectorize",
-      contentType: "application/x-ndjson",
-      body: ndjson
-    });
-  }
-  const vectorize = {
-    async describe() {
-      return apiRequest("GET", "");
-    },
-    async query(vector, options) {
-      const vectorArray = Array.isArray(vector) ? vector : Array.from(vector);
-      return apiRequest("POST", "/query", {
-        vector: vectorArray,
-        topK: options?.topK ?? 10,
-        returnValues: options?.returnValues ?? false,
-        returnMetadata: options?.returnMetadata ?? "none",
-        namespace: options?.namespace,
-        filter: options?.filter
-      });
-    },
-    async insert(vectors) {
-      const result = await ndjsonRequest("/insert", vectors);
-      return {
-        count: result.count,
-        ids: result.ids || vectors.map((v) => v.id)
-      };
-    },
-    async upsert(vectors) {
-      const result = await ndjsonRequest("/upsert", vectors);
-      return {
-        count: result.count,
-        ids: result.ids || vectors.map((v) => v.id)
-      };
-    },
-    async deleteByIds(ids) {
-      const result = await apiRequest("POST", "/delete-by-ids", { ids });
-      return {
-        count: result.count,
-        ids
-      };
-    },
-    async getByIds(ids) {
-      return apiRequest("POST", "/get-by-ids", { ids });
-    }
-  };
-  return vectorize;
-}
+} from "../index-37x76zdn.js";
 
 // src/test/resolve-service-bindings.ts
 import { dirname, join, resolve } from "path";
@@ -656,11 +518,30 @@ export default {
 
 async function executeRpc(env, method, params) {
 	const [bindingName, ...rest] = method.split('.')
-	const op = rest.join('.')
+	let op = rest.join('.')
 	const binding = env[bindingName]
 	const RAW_EMAIL = 'EmailMessage::raw'
 	if (!binding) throw new Error('Binding not found: ' + bindingName)
 
+	// Normalize namespaced op names (kv.*, r2.*, d1.*, do.*, queue.*, ai.*, var.*)
+	// down to the legacy verbs this dispatcher historically used. The bridge
+	// proxy always emits namespaced forms (see src/bridge/proxy.ts and B3 in
+	// REMAINING.md); this keeps the dispatcher backwards-compatible while the
+	// rest of the codebase converges on the namespaced convention.
+	if (op.indexOf('kv.') === 0) op = op.slice(3)
+	else if (op.indexOf('do.') === 0) {
+		const tail = op.slice(3)
+		if (tail === 'fetch') op = 'stub.fetch'
+		else if (tail === 'rpc') op = 'stub.rpc'
+		else op = tail
+	}
+	else if (op.indexOf('queue.') === 0) op = op.slice(6)
+	else if (op.indexOf('ai.') === 0) op = op.slice(3)
+	else if (op.indexOf('var.') === 0) op = op.slice(4)
+	else if (op.indexOf('d1.stmt.') === 0) op = 'prepare.' + op.slice('d1.stmt.'.length)
+	else if (op.indexOf('d1.') === 0) op = op.slice(3)
+	// r2.* and email.* keep their existing prefixes
+
 	// KV operations
 	if (op === 'get') return binding.get(params[0], params[1])
 	if (op === 'put') return binding.put(params[0], params[1], params[2])
@@ -673,7 +554,7 @@ async function executeRpc(env, method, params) {
 	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])
+	if (op === 'r2.head' || op === 'head') return binding.head(params[0])
 
 	// D1 operations
 	if (op === 'exec') return binding.exec(params[0])
@@ -947,7 +828,7 @@ async function resolveLocalDurableObjects(config, configDir) {
     }
     let scriptPath;
     let nativeRpc = false;
-    if (doInfo.scriptName) {
+    if (doInfo.kind === "cross-worker" && doInfo.scriptName) {
       scriptPath = join3(configDir, "src", doInfo.scriptName);
       try {
         const code = await readFile(scriptPath, "utf-8");
@@ -1082,80 +963,245 @@ async function buildDurableObjectGateway(config, configDir, transportFile) {
   };
 }
 
-// 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}`);
+// src/test/remote-cloudflare.ts
+function createRemoteCloudflareClient(accountId) {
+  let resolvedAccountId = null;
+  async function getAccountId() {
+    if (accountId) {
+      return accountId;
     }
-  }
-  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;
+    if (resolvedAccountId) {
+      return resolvedAccountId;
     }
-    const colonIndex = line.indexOf(":");
-    if (colonIndex <= 0) {
-      continue;
+    const primary = await getPrimaryAccount();
+    if (!primary) {
+      throw new Error("No Cloudflare account found. Run: bunx wrangler login");
     }
-    headers.append(line.slice(0, colonIndex).trim(), line.slice(colonIndex + 1).trim());
+    const { accountId: effectiveId } = await getEffectiveAccountId(primary.id);
+    resolvedAccountId = effectiveId;
+    return effectiveId;
   }
-  return headers;
-}
-function createRawEmailStream(rawEmail) {
-  return new ReadableStream({
-    start(controller) {
-      controller.enqueue(new TextEncoder().encode(rawEmail));
-      controller.close();
+  async function getToken() {
+    const token = await getApiToken();
+    if (!token) {
+      throw new Error("Not authenticated. Run: bunx wrangler login");
     }
-  });
-}
-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);
+    return token;
   }
-  if (typeof module.email === "function") {
-    return module.email;
+  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) {
+      return cloudflare.jsonRequest({
+        method: "POST",
+        path: `/ai/run/${model}`,
+        serviceLabel: "AI",
+        body: JSON.stringify(inputs)
+      });
+    },
+    gateway(_gatewayId) {
+      console.warn("AI Gateway is not supported in remote test mode");
+      return ai;
+    }
+  };
+  return ai;
+}
+
+// src/test/remote-vectorize.ts
+function createRemoteVectorize(indexName, accountId) {
+  const cloudflare = createRemoteCloudflareClient(accountId);
+  async function apiRequest(method, endpoint, body) {
+    return cloudflare.jsonRequest({
+      method,
+      path: `/vectorize/v2/indexes/${indexName}${endpoint}`,
+      serviceLabel: "Vectorize",
+      body: body ? JSON.stringify(body) : undefined
+    });
+  }
+  async function ndjsonRequest(endpoint, vectors) {
+    const ndjson = vectors.map((v) => JSON.stringify(v)).join(`
+`);
+    return cloudflare.jsonRequest({
+      method: "POST",
+      path: `/vectorize/v2/indexes/${indexName}${endpoint}`,
+      serviceLabel: "Vectorize",
+      contentType: "application/x-ndjson",
+      body: ndjson
+    });
+  }
+  const vectorize = {
+    async describe() {
+      return apiRequest("GET", "");
+    },
+    async query(vector, options) {
+      const vectorArray = Array.isArray(vector) ? vector : Array.from(vector);
+      return apiRequest("POST", "/query", {
+        vector: vectorArray,
+        topK: options?.topK ?? 10,
+        returnValues: options?.returnValues ?? false,
+        returnMetadata: options?.returnMetadata ?? "none",
+        namespace: options?.namespace,
+        filter: options?.filter
+      });
+    },
+    async insert(vectors) {
+      const result = await ndjsonRequest("/insert", vectors);
+      return {
+        count: result.count,
+        ids: result.ids || vectors.map((v) => v.id)
+      };
+    },
+    async upsert(vectors) {
+      const result = await ndjsonRequest("/upsert", vectors);
+      return {
+        count: result.count,
+        ids: result.ids || vectors.map((v) => v.id)
+      };
+    },
+    async deleteByIds(ids) {
+      const result = await apiRequest("POST", "/delete-by-ids", { ids });
+      return {
+        count: result.count,
+        ids
+      };
+    },
+    async getByIds(ids) {
+      return apiRequest("POST", "/get-by-ids", { ids });
+    }
+  };
+  return vectorize;
+}
+
+// src/test/simple-context-bindings.ts
+function buildRemoteAndStaticBindings(config) {
+  const remoteBindings = {};
+  if (isRemoteModeActive()) {
+    if (config.bindings?.ai) {
+      const aiBindingName = config.bindings.ai.binding || "AI";
+      remoteBindings[aiBindingName] = createRemoteAI(config.accountId);
+    }
+    if (config.bindings?.vectorize) {
+      for (const [name, vectorConfig] of Object.entries(config.bindings.vectorize)) {
+        remoteBindings[name] = createRemoteVectorize(vectorConfig.indexName, config.accountId);
+      }
+    }
+  }
+  if (config.vars) {
+    for (const [key, value] of Object.entries(config.vars)) {
+      remoteBindings[key] = value;
+    }
+  }
+  if (config.bindings?.sendEmail) {
+    for (const [name, binding] of Object.entries(config.bindings.sendEmail)) {
+      remoteBindings[name] = createLocalSendEmailBinding(binding);
+    }
+  }
+  return remoteBindings;
+}
+
+// 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;
 }
@@ -1354,8 +1400,8 @@ NaN`);
     passThroughOnException() {},
     props: {}
   };
-  const env = testEnvGetter2();
-  const queueEvent = createQueueEvent(batch, env, ctx);
+  const env2 = testEnvGetter2();
+  const queueEvent = createQueueEvent(batch, env2, ctx);
   await runWithEventContext(queueEvent, () => queueHandler(queueEvent));
   await Promise.all(waitUntilPromises);
   const acked = [];
@@ -1434,8 +1480,8 @@ NaN`);
     passThroughOnException() {},
     props: {}
   };
-  const env = testEnvGetter3();
-  const scheduledEvent = createScheduledEvent(controller, env, ctx);
+  const env2 = testEnvGetter3();
+  const scheduledEvent = createScheduledEvent(controller, env2, ctx);
   try {
     await runWithEventContext(scheduledEvent, () => scheduledHandler(scheduledEvent));
     await Promise.all(waitUntilPromises);
@@ -1519,8 +1565,8 @@ NaN`);
     passThroughOnException() {},
     props: {}
   };
-  const env = testEnvGetter4();
-  const tailEvent = createTailEvent(traceItems, env, ctx);
+  const env2 = testEnvGetter4();
+  const tailEvent = createTailEvent(traceItems, env2, ctx);
   try {
     await runWithEventContext(tailEvent, () => tailHandler(tailEvent));
     await Promise.all(waitUntilPromises);
@@ -1620,9 +1666,9 @@ async function fetch2(request, options) {
     passThroughOnException() {},
     props: {}
   };
-  const env = getEnv();
+  const env2 = getEnv();
   const initialRouteMatch = routeModules.length > 0 ? matchFetchRoute(routeModules, req) : null;
-  const fetchEvent = createFetchEvent(req, env, ctx, {
+  const fetchEvent = createFetchEvent(req, env2, ctx, {
     params: initialRouteMatch?.params ?? {}
   });
   const response = await runWithEventContext(fetchEvent, () => invokeFetchModule(handlerModule, fetchEvent, routeModules.length > 0 ? createRouteResolve(routeModules, fetchEvent) : undefined));
@@ -1652,56 +1698,203 @@ var worker = {
   patch
 };
 
-// src/test/simple-context.ts
-var globalClient = null;
-var globalMiniflare = null;
-var globalEnvProxy = null;
-var globalTransportDecode = null;
-var globalRemoteBindings = null;
-var globalMiniflareBindings = null;
-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;
-  }
-  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 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";
+// src/test/simple-context-env.ts
+function configureSurfaceHandlers(input) {
+  const { handlerPaths, configDir: configDir6, activePort, getEnv } = input;
+  configureQueue({
+    handlerPath: handlerPaths.queue,
+    configDir: configDir6,
+    getEnv
+  });
+  configureScheduled({
+    handlerPath: handlerPaths.scheduled,
+    configDir: configDir6,
+    getEnv
+  });
+  configureWorker({
+    handlerPath: handlerPaths.fetch,
+    routes: handlerPaths.routes?.routes.map((route) => ({
+      filePath: route.filePath,
+      routePath: route.routePath,
+      segments: route.segments
+    })) ?? [],
+    configDir: configDir6,
+    getEnv
+  });
+  configureTail({
+    handlerPath: handlerPaths.tail,
+    configDir: configDir6,
+    getEnv
+  });
+  configureEmail({
+    port: activePort,
+    handlerPath: handlerPaths.email,
+    configDir: configDir6,
+    getEnv
+  });
 }
-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;
+function createBridgeEnvAccessor(state, hints, shouldPreferBridgeBinding) {
+  return new Proxy({}, {
+    get(_, prop) {
+      const hint = hints[prop];
+      const prefersBridgeBinding = shouldPreferBridgeBinding(hint);
+      if (state.remoteBindings && prop in state.remoteBindings) {
+        return state.remoteBindings[prop];
       }
-      await waitForBridgeClientRetry();
+      if (!prefersBridgeBinding && state.miniflareBindings && prop in state.miniflareBindings) {
+        return state.miniflareBindings[prop];
+      }
+      if (state.envProxy) {
+        return state.envProxy[prop];
+      }
+      if (prefersBridgeBinding && state.miniflareBindings && prop in state.miniflareBindings) {
+        return state.miniflareBindings[prop];
+      }
+      return;
+    },
+    has(_, prop) {
+      return Boolean(state.remoteBindings && prop in state.remoteBindings || state.miniflareBindings && prop in state.miniflareBindings || state.envProxy !== null);
     }
-  }
-  throw lastError instanceof Error ? lastError : new Error("Bridge-backed test context could not connect to the WebSocket gateway.");
+  });
 }
-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;
+function createMultiWorkerEnvAccessor(state) {
+  return new Proxy({}, {
+    get(_, prop) {
+      if (state.remoteBindings && prop in state.remoteBindings) {
+        return state.remoteBindings[prop];
+      }
+      if (state.miniflareBindings && prop in state.miniflareBindings) {
+        return state.miniflareBindings[prop];
+      }
+      return;
+    },
+    has(_, prop) {
+      return Boolean(state.remoteBindings && prop in state.remoteBindings || state.miniflareBindings && prop in state.miniflareBindings);
+    }
+  });
+}
+
+// src/test/simple-context-handlers.ts
+import { join as join9 } from "path";
+var DEFAULT_FETCH_PATH = "src/fetch.ts";
+var DEFAULT_QUEUE_PATH = "src/queue.ts";
+var DEFAULT_SCHEDULED_PATH = "src/scheduled.ts";
+var DEFAULT_EMAIL_PATH = "src/email.ts";
+var DEFAULT_TAIL_PATH = "src/tail.ts";
+async function resolveHandlerPath(configDir6, configValue, defaultPath) {
+  if (typeof configValue === "string") {
+    return configValue;
+  }
+  if (configValue === false) {
+    return null;
+  }
+  const defaultAbsolute = join9(configDir6, defaultPath);
+  try {
+    const fs = await import("fs/promises");
+    await fs.access(defaultAbsolute);
+    return defaultPath;
+  } catch {
+    return null;
+  }
+}
+async function resolveHandlerPaths(configDir6, config) {
+  const [fetch3, queue2, scheduled2, email2, tail2, routes] = await Promise.all([
+    resolveHandlerPath(configDir6, config.files?.fetch, DEFAULT_FETCH_PATH),
+    resolveHandlerPath(configDir6, config.files?.queue, DEFAULT_QUEUE_PATH),
+    resolveHandlerPath(configDir6, config.files?.scheduled, DEFAULT_SCHEDULED_PATH),
+    resolveHandlerPath(configDir6, config.files?.email, DEFAULT_EMAIL_PATH),
+    resolveHandlerPath(configDir6, undefined, DEFAULT_TAIL_PATH),
+    discoverRoutes(configDir6, config)
+  ]);
+  return { fetch: fetch3, queue: queue2, scheduled: scheduled2, email: email2, tail: tail2, routes };
+}
+
+// src/test/simple-context-lifecycle.ts
+import { dirname as dirname4, resolve as resolve2 } from "path";
+async function resolveTestContextConfig(configPath, callerDir = getCallerDirectory()) {
+  let absolutePath;
+  if (configPath) {
+    absolutePath = resolve2(callerDir, configPath);
+  } else {
+    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')`);
+    }
+    absolutePath = found;
+  }
+  const configDir6 = dirname4(absolutePath);
+  const config = await loadConfig({
+    cwd: configDir6,
+    configFile: absolutePath.split(/[/\\]/).pop()
+  });
+  return { absolutePath, configDir: configDir6, config };
+}
+function createDisposeContext(state) {
+  return async () => {
+    if (state.client) {
+      await state.client.disconnect();
+      state.client = null;
+    }
+    if (state.miniflare) {
+      await state.miniflare.dispose();
+      state.miniflare = null;
+    }
+    state.envProxy = null;
+    state.transportDecode = null;
+    state.remoteBindings = null;
+    state.miniflareBindings = null;
+    resetQueueState();
+    resetScheduledState();
+    resetWorkerState();
+    resetTailState();
+    resetEmailState();
+    __clearTestContext();
+  };
+}
+
+// src/test/simple-context-startup.ts
+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;
+  }
+  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 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));
+}
+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();
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error("Bridge-backed test context could not connect to the WebSocket gateway.");
+}
+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({
@@ -1732,89 +1925,118 @@ async function startBridgeBackedTestContext(mfConfig) {
   }
   throw new Error("Bridge-backed test context startup exhausted all retry attempts.");
 }
-async function createTestContext(configPath) {
-  const callerDir = getCallerDirectory();
-  let absolutePath;
-  if (configPath) {
-    absolutePath = resolve2(callerDir, configPath);
-  } else {
-    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')`);
-    }
-    absolutePath = found;
+
+// src/test/simple-context-runtime.ts
+async function bootTestRuntime(mfConfig, usesMultiWorker) {
+  if (usesMultiWorker) {
+    const { Miniflare } = await import("miniflare");
+    const activePort = await getAvailablePort();
+    const miniflare = new Miniflare({
+      ...mfConfig,
+      port: activePort
+    });
+    await miniflare.ready;
+    const miniflareBindings = wrapEnvSendEmailBindings(await miniflare.getBindings());
+    return { activePort, miniflare, miniflareBindings, client: null };
   }
-  const configDir6 = dirname4(absolutePath);
-  const config = await loadConfig({
-    cwd: configDir6,
-    configFile: absolutePath.split(/[/\\]/).pop()
-  });
-  globalRemoteBindings = {};
-  if (isRemoteModeActive()) {
-    if (config.bindings?.ai) {
-      const aiBindingName = config.bindings.ai.binding || "AI";
-      globalRemoteBindings[aiBindingName] = createRemoteAI(config.accountId);
-    }
-    if (config.bindings?.vectorize) {
-      for (const [name, vectorConfig] of Object.entries(config.bindings.vectorize)) {
-        globalRemoteBindings[name] = createRemoteVectorize(vectorConfig.indexName, config.accountId);
-      }
-    }
+  const started = await startBridgeBackedTestContext(mfConfig);
+  return {
+    activePort: started.port,
+    miniflare: started.miniflare,
+    miniflareBindings: started.miniflareBindings,
+    client: started.client
+  };
+}
+
+// src/test/simple-context-transport.ts
+import { join as join10 } from "path";
+async function loadTransportDecoders(configDir6, transportFile) {
+  const transportPath = join10(configDir6, transportFile);
+  const transportModule = await import(transportPath);
+  if (!transportModule.transport) {
+    console.warn(`[devflare] Warning: Transport file "${transportFile}" does not export a named "transport" object.
+Expected: export const transport = { ... }
+Transport encoding/decoding will be disabled.`);
+    return null;
   }
-  if (config.vars) {
-    for (const [key, value] of Object.entries(config.vars)) {
-      globalRemoteBindings[key] = value;
-    }
+  const decoders = new Map;
+  for (const [typeName, transporter] of Object.entries(transportModule.transport)) {
+    const t = transporter;
+    decoders.set(typeName, t.decode);
   }
-  if (config.bindings?.sendEmail) {
-    for (const [name, binding] of Object.entries(config.bindings.sendEmail)) {
-      globalRemoteBindings[name] = createLocalSendEmailBinding(binding);
-    }
+  return decoders;
+}
+function decodeTransportValue(decoders, value) {
+  if (!decoders || value === null || typeof value !== "object") {
+    return value;
   }
-  const hints = {};
-  if (config.bindings?.kv) {
-    for (const name of Object.keys(config.bindings.kv)) {
-      hints[name] = "kv";
+  if ("__transport" in value) {
+    const encoded = value;
+    const decoder = decoders.get(encoded.__transport);
+    if (decoder) {
+      return decoder(encoded.value);
     }
   }
-  if (config.bindings?.r2) {
-    for (const name of Object.keys(config.bindings.r2)) {
-      hints[name] = "r2";
-    }
+  if (Array.isArray(value)) {
+    return value.map((item) => decodeTransportValue(decoders, item));
   }
-  if (config.bindings?.d1) {
-    for (const name of Object.keys(config.bindings.d1)) {
-      hints[name] = "d1";
-    }
+  const result = {};
+  for (const [k, v] of Object.entries(value)) {
+    result[k] = decodeTransportValue(decoders, v);
   }
-  if (config.bindings?.durableObjects) {
-    for (const name of Object.keys(config.bindings.durableObjects)) {
-      hints[name] = "do";
+  return result;
+}
+
+// src/test/simple-context-multi-worker.ts
+function applyMultiWorkerConfig(mfConfig, config, serviceBindingResolution, doBindingResolution) {
+  const primaryDurableObjects = {
+    ...mfConfig.durableObjects || {},
+    ...doBindingResolution?.crossWorkerDOBindings || {}
+  };
+  const primaryWorker = {
+    name: config.name ?? "primary",
+    modules: true,
+    script: mfConfig.script,
+    compatibilityDate: config.compatibilityDate ?? "2025-01-01",
+    ...mfConfig.kvNamespaces && { kvNamespaces: mfConfig.kvNamespaces },
+    ...mfConfig.r2Buckets && { r2Buckets: mfConfig.r2Buckets },
+    ...mfConfig.d1Databases && { d1Databases: mfConfig.d1Databases },
+    ...mfConfig.email && { email: mfConfig.email },
+    ...Object.keys(primaryDurableObjects).length > 0 && { durableObjects: primaryDurableObjects },
+    ...serviceBindingResolution?.primaryServiceBindings && {
+      serviceBindings: serviceBindingResolution.primaryServiceBindings
     }
-  }
-  if (config.bindings?.services) {
-    for (const name of Object.keys(config.bindings.services)) {
-      hints[name] = "service";
+  };
+  const additionalWorkers = [
+    ...serviceBindingResolution?.workers || [],
+    ...doBindingResolution?.workers || []
+  ];
+  const workersByName = new Map;
+  for (const worker2 of additionalWorkers) {
+    if (!workersByName.has(worker2.name)) {
+      workersByName.set(worker2.name, worker2);
+      continue;
     }
-  }
-  if (config.bindings?.sendEmail) {
-    for (const name of Object.keys(config.bindings.sendEmail)) {
-      hints[name] = "sendEmail";
+    const existing = workersByName.get(worker2.name);
+    if (worker2.durableObjects) {
+      existing.durableObjects = {
+        ...existing.durableObjects || {},
+        ...worker2.durableObjects
+      };
     }
   }
-  const needsMultiWorkerForServices = hasServiceBindings(config);
-  const needsMultiWorkerForDOs = hasCrossWorkerDOs(config);
-  const needsMultiWorker = needsMultiWorkerForServices || needsMultiWorkerForDOs;
-  let serviceBindingResolution = null;
-  let doBindingResolution = null;
-  if (needsMultiWorkerForServices) {
-    serviceBindingResolution = await resolveServiceBindings(config, configDir6);
-  }
-  if (needsMultiWorkerForDOs) {
-    doBindingResolution = await resolveDOBindings(config, configDir6);
-  }
+  const workers = [primaryWorker, ...workersByName.values()];
+  delete mfConfig.script;
+  delete mfConfig.modules;
+  delete mfConfig.kvNamespaces;
+  delete mfConfig.r2Buckets;
+  delete mfConfig.d1Databases;
+  delete mfConfig.durableObjects;
+  mfConfig.workers = workers;
+}
+
+// src/test/simple-context-mfconfig.ts
+function buildInlineBridgeMfConfig(config) {
   const localWorkerBindings = config.vars ?? {};
   const mfConfig = {
     modules: true
@@ -1856,21 +2078,44 @@ Either create a config file or provide an explicit path: createTestContext('./pa
       }))
     };
   }
+  return mfConfig;
+}
+
+// src/test/simple-context.ts
+function createTestContextState() {
+  return {
+    client: null,
+    miniflare: null,
+    envProxy: null,
+    transportDecode: null,
+    remoteBindings: null,
+    miniflareBindings: null
+  };
+}
+function shouldPreferBridgeBinding(hint) {
+  return hint === "do" || hint === "service";
+}
+async function createTestContext(configPath) {
+  const state = createTestContextState();
+  const { configDir: configDir6, config } = await resolveTestContextConfig(configPath);
+  state.remoteBindings = buildRemoteAndStaticBindings(config);
+  const hints = extractBindingHints(config);
+  const decodeTransport = (value) => decodeTransportValue(state.transportDecode, value);
+  const needsMultiWorkerForServices = hasServiceBindings(config);
+  const needsMultiWorkerForDOs = hasCrossWorkerDOs(config);
+  const needsMultiWorker = needsMultiWorkerForServices || needsMultiWorkerForDOs;
+  let serviceBindingResolution = null;
+  let doBindingResolution = null;
+  if (needsMultiWorkerForServices) {
+    serviceBindingResolution = await resolveServiceBindings(config, configDir6);
+  }
+  if (needsMultiWorkerForDOs) {
+    doBindingResolution = await resolveDOBindings(config, configDir6);
+  }
+  const mfConfig = buildInlineBridgeMfConfig(config);
   const transportFile = resolveTransportFile(configDir6, config.files?.transport);
   if (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.
-Expected: export const transport = { ... }
-Transport encoding/decoding will be disabled.`);
-    } else {
-      globalTransportDecode = new Map;
-      for (const [typeName, transporter] of Object.entries(transportModule.transport)) {
-        const t = transporter;
-        globalTransportDecode.set(typeName, t.decode);
-      }
-    }
+    state.transportDecode = await loadTransportDecoders(configDir6, transportFile);
   }
   const gateway = await buildDurableObjectGateway(config, configDir6, transportFile);
   mfConfig.script = gateway.script;
@@ -1880,243 +2125,59 @@ Transport encoding/decoding will be disabled.`);
   const hasMultiWorkerServices = serviceBindingResolution && serviceBindingResolution.workers.length > 0;
   const hasMultiWorkerDOs = doBindingResolution && doBindingResolution.workers.length > 0;
   if (hasMultiWorkerServices || hasMultiWorkerDOs) {
-    const primaryDurableObjects = {
-      ...mfConfig.durableObjects || {},
-      ...doBindingResolution?.crossWorkerDOBindings || {}
-    };
-    const primaryWorker = {
-      name: config.name ?? "primary",
-      modules: true,
-      script: mfConfig.script,
-      compatibilityDate: config.compatibilityDate ?? "2025-01-01",
-      ...mfConfig.kvNamespaces && { kvNamespaces: mfConfig.kvNamespaces },
-      ...mfConfig.r2Buckets && { r2Buckets: mfConfig.r2Buckets },
-      ...mfConfig.d1Databases && { d1Databases: mfConfig.d1Databases },
-      ...mfConfig.email && { email: mfConfig.email },
-      ...Object.keys(primaryDurableObjects).length > 0 && { durableObjects: primaryDurableObjects },
-      ...serviceBindingResolution?.primaryServiceBindings && { serviceBindings: serviceBindingResolution.primaryServiceBindings }
-    };
-    const additionalWorkers = [
-      ...serviceBindingResolution?.workers || [],
-      ...doBindingResolution?.workers || []
-    ];
-    const workersByName = new Map;
-    for (const worker2 of additionalWorkers) {
-      if (!workersByName.has(worker2.name)) {
-        workersByName.set(worker2.name, worker2);
-        continue;
-      }
-      const existing = workersByName.get(worker2.name);
-      if (worker2.durableObjects) {
-        existing.durableObjects = {
-          ...existing.durableObjects || {},
-          ...worker2.durableObjects
-        };
-      }
-    }
-    const workers = [primaryWorker, ...workersByName.values()];
-    delete mfConfig.script;
-    delete mfConfig.modules;
-    delete mfConfig.kvNamespaces;
-    delete mfConfig.r2Buckets;
-    delete mfConfig.d1Databases;
-    delete mfConfig.durableObjects;
-    mfConfig.workers = workers;
-  }
-  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();
-      globalClient = null;
-    }
-    if (globalMiniflare) {
-      await globalMiniflare.dispose();
-      globalMiniflare = null;
-    }
-    globalEnvProxy = null;
-    globalTransportDecode = null;
-    globalRemoteBindings = null;
-    globalMiniflareBindings = null;
-    resetQueueState();
-    resetScheduledState();
-    resetWorkerState();
-    resetTailState();
-    resetEmailState();
-    __clearTestContext();
-  };
+    applyMultiWorkerConfig(mfConfig, config, serviceBindingResolution, doBindingResolution);
+  }
+  const usesMultiWorker = Boolean(hasMultiWorkerServices || hasMultiWorkerDOs);
+  const runtime = await bootTestRuntime(mfConfig, usesMultiWorker);
+  const activePort = runtime.activePort;
+  state.miniflare = runtime.miniflare;
+  state.miniflareBindings = runtime.miniflareBindings;
+  state.client = runtime.client;
+  const disposeContext = createDisposeContext(state);
   const getTestEnv = () => {
     return new Proxy({}, {
       get(_, prop) {
-        if (globalRemoteBindings && prop in globalRemoteBindings) {
-          return globalRemoteBindings[prop];
+        if (state.remoteBindings && prop in state.remoteBindings) {
+          return state.remoteBindings[prop];
         }
-        if (hints[prop] === "sendEmail" && globalEnvProxy && prop in globalEnvProxy) {
-          return globalEnvProxy[prop];
+        if (hints[prop] === "sendEmail" && state.envProxy && prop in state.envProxy) {
+          return state.envProxy[prop];
         }
-        if (globalMiniflareBindings && prop in globalMiniflareBindings) {
-          return globalMiniflareBindings[prop];
+        if (state.miniflareBindings && prop in state.miniflareBindings) {
+          return state.miniflareBindings[prop];
         }
-        if (globalEnvProxy && prop in globalEnvProxy) {
-          return globalEnvProxy[prop];
+        if (state.envProxy && prop in state.envProxy) {
+          return state.envProxy[prop];
         }
         return;
       },
       has(_, prop) {
-        return Boolean(globalRemoteBindings && prop in globalRemoteBindings || globalMiniflareBindings && prop in globalMiniflareBindings || globalEnvProxy && prop in globalEnvProxy);
+        return Boolean(state.remoteBindings && prop in state.remoteBindings || state.miniflareBindings && prop in state.miniflareBindings || state.envProxy && prop in state.envProxy);
       }
     });
   };
-  const queuePath = config.files?.queue;
-  const scheduledPath = config.files?.scheduled;
-  const fetchPath = config.files?.fetch;
-  const emailPath = config.files?.email;
-  const DEFAULT_FETCH_PATH = "src/fetch.ts";
-  const DEFAULT_QUEUE_PATH = "src/queue.ts";
-  const DEFAULT_SCHEDULED_PATH = "src/scheduled.ts";
-  const DEFAULT_EMAIL_PATH = "src/email.ts";
-  const DEFAULT_TAIL_PATH = "src/tail.ts";
-  const resolvePath = async (configValue, defaultPath) => {
-    if (typeof configValue === "string") {
-      return configValue;
-    }
-    if (configValue === false) {
-      return null;
-    }
-    const defaultAbsolute = join9(configDir6, defaultPath);
-    try {
-      const fs = await import("fs/promises");
-      await fs.access(defaultAbsolute);
-      return defaultPath;
-    } catch {
-      return null;
-    }
-  };
-  const [resolvedFetchPath, resolvedQueuePath, resolvedScheduledPath, resolvedEmailPath, resolvedTailPath, resolvedRoutes] = await Promise.all([
-    resolvePath(fetchPath, DEFAULT_FETCH_PATH),
-    resolvePath(queuePath, DEFAULT_QUEUE_PATH),
-    resolvePath(scheduledPath, DEFAULT_SCHEDULED_PATH),
-    resolvePath(emailPath, DEFAULT_EMAIL_PATH),
-    resolvePath(undefined, DEFAULT_TAIL_PATH),
-    discoverRoutes(configDir6, config)
-  ]);
-  configureQueue({
-    handlerPath: resolvedQueuePath,
-    configDir: configDir6,
-    getEnv: getTestEnv
-  });
-  configureScheduled({
-    handlerPath: resolvedScheduledPath,
-    configDir: configDir6,
-    getEnv: getTestEnv
-  });
-  configureWorker({
-    handlerPath: resolvedFetchPath,
-    routes: resolvedRoutes?.routes.map((route) => ({
-      filePath: route.filePath,
-      routePath: route.routePath,
-      segments: route.segments
-    })) ?? [],
+  const handlerPaths = await resolveHandlerPaths(configDir6, config);
+  configureSurfaceHandlers({
+    handlerPaths,
     configDir: configDir6,
+    activePort,
     getEnv: getTestEnv
   });
-  configureTail({
-    handlerPath: resolvedTailPath,
-    configDir: configDir6,
-    getEnv: getTestEnv
-  });
-  configureEmail({
-    port: activePort,
-    handlerPath: resolvedEmailPath,
-    configDir: configDir6,
-    getEnv: getTestEnv
-  });
-  if (hasMultiWorkerServices || hasMultiWorkerDOs) {
+  if (usesMultiWorker) {
     setBindingHints(hints);
-    const envAccessor2 = new Proxy({}, {
-      get(_, prop) {
-        if (globalRemoteBindings && prop in globalRemoteBindings) {
-          return globalRemoteBindings[prop];
-        }
-        if (globalMiniflareBindings && prop in globalMiniflareBindings) {
-          return globalMiniflareBindings[prop];
-        }
-        return;
-      },
-      has(_, prop) {
-        return Boolean(globalRemoteBindings && prop in globalRemoteBindings || globalMiniflareBindings && prop in globalMiniflareBindings);
-      }
-    });
-    __setTestContext(envAccessor2, disposeContext);
+    __setTestContext(createMultiWorkerEnvAccessor(state), disposeContext);
     return;
   }
-  const bridgeClient = globalClient;
+  const bridgeClient = state.client;
   if (!bridgeClient) {
     throw new Error("Bridge-backed test context did not initialize a client.");
   }
   setBindingHints(hints);
-  globalEnvProxy = createEnvProxy({
+  state.envProxy = createEnvProxy({
     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 (!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) {
-      return Boolean(globalRemoteBindings && prop in globalRemoteBindings || globalMiniflareBindings && prop in globalMiniflareBindings || globalEnvProxy !== null);
-    }
-  });
-  __setTestContext(envAccessor, disposeContext);
-}
-function decodeTransport(value) {
-  if (!globalTransportDecode || value === null || typeof value !== "object") {
-    return value;
-  }
-  if ("__transport" in value) {
-    const encoded = value;
-    const decoder = globalTransportDecode.get(encoded.__transport);
-    if (decoder) {
-      return decoder(encoded.value);
-    }
-  }
-  if (Array.isArray(value)) {
-    return value.map(decodeTransport);
-  }
-  const result = {};
-  for (const [k, v] of Object.entries(value)) {
-    result[k] = decodeTransport(v);
-  }
-  return result;
+  __setTestContext(createBridgeEnvAccessor(state, hints, shouldPreferBridgeBinding), disposeContext);
 }
 // src/test/cf.ts
 var cf = {
@@ -2252,56 +2313,88 @@ async function withTestContext(options, handler) {
   return runWithContext(testCtx.env, testCtx.ctx, options.request ?? null, handler, options.type ?? "fetch");
 }
 function createMockKV(initialData = {}) {
-  const store = new Map(Object.entries(initialData));
+  const store = new Map;
   const metadata = new Map;
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  for (const [key, value] of Object.entries(initialData)) {
+    store.set(key, encoder.encode(value));
+  }
+  const toBytes = async (value) => {
+    if (typeof value === "string") {
+      return encoder.encode(value);
+    }
+    if (value instanceof ArrayBuffer) {
+      return new Uint8Array(value.slice(0));
+    }
+    if (ArrayBuffer.isView(value)) {
+      const view = value;
+      const copy = new Uint8Array(view.byteLength);
+      copy.set(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+      return copy;
+    }
+    const reader = value.getReader();
+    const chunks = [];
+    let total = 0;
+    while (true) {
+      const result = await reader.read();
+      if (result.done)
+        break;
+      if (result.value) {
+        const chunk = result.value instanceof Uint8Array ? result.value : new Uint8Array(result.value);
+        chunks.push(chunk);
+        total += chunk.length;
+      }
+    }
+    const combined = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      combined.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return combined;
+  };
+  const decodeBytes = (bytes, type) => {
+    switch (type) {
+      case "json":
+        return JSON.parse(decoder.decode(bytes));
+      case "arrayBuffer": {
+        const copy = new Uint8Array(bytes.length);
+        copy.set(bytes);
+        return copy.buffer;
+      }
+      case "stream": {
+        const copy = new Uint8Array(bytes.length);
+        copy.set(bytes);
+        return new ReadableStream({
+          start(controller) {
+            controller.enqueue(copy);
+            controller.close();
+          }
+        });
+      }
+      default:
+        return decoder.decode(bytes);
+    }
+  };
+  const resolveType = (options) => {
+    const type = typeof options === "string" ? options : options?.type ?? "text";
+    return type;
+  };
   return {
     async get(key, options) {
-      const value = store.get(key);
-      if (value === null || value === undefined)
+      const bytes = store.get(key);
+      if (bytes === undefined)
         return null;
-      const type = typeof options === "string" ? options : options?.type ?? "text";
-      switch (type) {
-        case "json":
-          return JSON.parse(value);
-        case "arrayBuffer":
-          return new TextEncoder().encode(value).buffer;
-        case "stream":
-          return new ReadableStream({
-            start(controller) {
-              controller.enqueue(new TextEncoder().encode(value));
-              controller.close();
-            }
-          });
-        default:
-          return value;
-      }
+      return decodeBytes(bytes, resolveType(options));
     },
-    async put(key, value, options) {
-      if (typeof value === "string") {
-        store.set(key, value);
-      } else if (value instanceof ArrayBuffer) {
-        store.set(key, new TextDecoder().decode(value));
-      } else {
-        const reader = value.getReader();
-        const chunks = [];
-        let done = false;
-        while (!done) {
-          const result = await reader.read();
-          done = result.done;
-          if (result.value)
-            chunks.push(result.value);
-        }
-        const combined = new Uint8Array(chunks.reduce((acc, c) => acc + c.length, 0));
-        let offset = 0;
-        for (const chunk of chunks) {
-          combined.set(chunk, offset);
-          offset += chunk.length;
-        }
-        store.set(key, new TextDecoder().decode(combined));
-      }
+    async put(key, value, _options) {
+      const bytes = await toBytes(value);
+      store.set(key, bytes);
     },
     async delete(key) {
       store.delete(key);
+      metadata.delete(key);
     },
     async list(options) {
       const prefix = options?.prefix ?? "";
@@ -2314,52 +2407,106 @@ function createMockKV(initialData = {}) {
       };
     },
     async getWithMetadata(key, options) {
+      const bytes = store.get(key);
       return {
-        value: store.get(key) ?? null,
+        value: bytes === undefined ? null : decodeBytes(bytes, resolveType(options)),
         metadata: metadata.get(key) ?? null
       };
     }
   };
 }
-function createMockD1(mockResults = []) {
-  let boundValues = [];
-  let currentResults = [...mockResults];
-  const createStatement = () => ({
-    bind(...values) {
-      boundValues = values;
-      return this;
-    },
-    async first(column) {
-      const row = currentResults[0];
-      if (!row)
-        return null;
-      if (column)
-        return row[column];
-      return row;
-    },
-    async all() {
-      return {
-        results: currentResults,
-        success: true,
-        meta: { duration: 0, changes: 0, last_row_id: 0 }
-      };
-    },
-    async run() {
-      return {
-        results: [],
-        success: true,
-        meta: { duration: 0, changes: 1, last_row_id: 1 }
-      };
-    },
-    async raw(options) {
-      return currentResults.map((row) => Object.values(row));
-    }
-  });
+var TABLE_NAME_RE = /(?:from|into|update)\s+["'`]?([a-zA-Z_][a-zA-Z0-9_]*)["'`]?/i;
+var extractTable = (sql) => {
+  const match = TABLE_NAME_RE.exec(sql);
+  return match ? match[1] : null;
+};
+var detectOp = (sql) => {
+  const trimmed = sql.trimStart().toLowerCase();
+  if (trimmed.startsWith("select"))
+    return "select";
+  if (trimmed.startsWith("insert"))
+    return "insert";
+  if (trimmed.startsWith("update"))
+    return "update";
+  if (trimmed.startsWith("delete"))
+    return "delete";
+  return "other";
+};
+function createMockD1(mockResultsOrOptions = []) {
+  const options = Array.isArray(mockResultsOrOptions) ? { results: mockResultsOrOptions } : mockResultsOrOptions;
+  const tables = new Map;
+  for (const [name, rows] of Object.entries(options.fixtures ?? {})) {
+    tables.set(name, [...rows]);
+  }
+  const fallback = options.results ?? [];
+  const resolveRows = (sql) => {
+    const op = detectOp(sql);
+    const table = extractTable(sql);
+    if (table && tables.has(table)) {
+      return { rows: tables.get(table) ?? [], op, table };
+    }
+    return { rows: [...fallback], op, table };
+  };
+  const createStatement = (sql) => {
+    let boundValues = [];
+    const statement = {
+      bind(...values) {
+        boundValues = values;
+        return statement;
+      },
+      async first(column) {
+        const { rows } = resolveRows(sql);
+        const row = rows[0];
+        if (!row)
+          return null;
+        if (column)
+          return row[column];
+        return row;
+      },
+      async all() {
+        const { rows } = resolveRows(sql);
+        return {
+          results: rows,
+          success: true,
+          meta: { duration: 0, changes: 0, last_row_id: 0 }
+        };
+      },
+      async run() {
+        const { op, table } = resolveRows(sql);
+        let changes = 0;
+        let lastRowId = 0;
+        if (op === "insert" && table) {
+          const rows = tables.get(table) ?? [];
+          const bound = boundValues.length > 0 ? Object.fromEntries(boundValues.map((v, i) => [`col${i}`, v])) : {};
+          rows.push(bound);
+          tables.set(table, rows);
+          changes = 1;
+          lastRowId = rows.length;
+        } else if (op === "delete" && table) {
+          const rows = tables.get(table) ?? [];
+          changes = rows.length;
+          tables.set(table, []);
+        } else if (op === "update" && table) {
+          changes = (tables.get(table) ?? []).length;
+        }
+        return {
+          results: [],
+          success: true,
+          meta: { duration: 0, changes, last_row_id: lastRowId }
+        };
+      },
+      async raw(_options) {
+        const { rows } = resolveRows(sql);
+        return rows.map((row) => Object.values(row));
+      }
+    };
+    return statement;
+  };
   return {
     prepare(query) {
-      return createStatement();
+      return createStatement(query);
     },
-    async exec(query) {
+    async exec(_query) {
       return {
         results: [],
         success: true,
@@ -2376,7 +2523,7 @@ function createMockD1(mockResults = []) {
     async dump() {
       return new ArrayBuffer(0);
     },
-    withSession(constraintOrBookmark) {
+    withSession(_constraintOrBookmark) {
       return this;
     }
   };
@@ -2539,111 +2686,26 @@ function createMockEnv(options = {}) {
   }
   return env2;
 }
-// src/test/bridge-context.ts
-var globalTestContext = null;
-async function createBridgeTestContext(options = {}) {
-  if (globalTestContext) {
-    await globalTestContext.stop();
-  }
-  let config = options.config;
-  if (options.configPath && !config) {
-    config = await loadConfig({ cwd: options.configPath.replace(/[/\\][^/\\]+$/, ""), configFile: options.configPath.split(/[/\\]/).pop() });
-  }
-  let miniflare;
-  if (config) {
-    miniflare = await startMiniflareFromConfig(config, {
-      ...options.miniflare,
-      port: options.port ?? 8787,
-      persist: options.persist ?? false,
-      verbose: options.verbose ?? false
-    });
-  } else {
-    miniflare = await startMiniflare({
-      ...options.miniflare,
-      port: options.port ?? 8787,
-      persist: options.persist ?? false,
-      verbose: options.verbose ?? false
-    });
-  }
-  const bindings = wrapEnvSendEmailBindings(await miniflare.getBindings());
-  if (config?.bindings) {
-    const hints = {};
-    if (config.bindings.kv) {
-      Object.keys(config.bindings.kv).forEach((name) => {
-        hints[name] = "kv";
-      });
-    }
-    if (config.bindings.r2) {
-      Object.keys(config.bindings.r2).forEach((name) => {
-        hints[name] = "r2";
-      });
-    }
-    if (config.bindings.d1) {
-      Object.keys(config.bindings.d1).forEach((name) => {
-        hints[name] = "d1";
-      });
-    }
-    if (config.bindings.durableObjects) {
-      Object.keys(config.bindings.durableObjects).forEach((name) => {
-        hints[name] = "do";
-      });
-    }
-    if (config.bindings.queues?.consumers) {
-      config.bindings.queues.consumers.forEach((c) => {
-        hints[c.queue] = "queue";
-      });
-    }
-    if (config.bindings.ai)
-      hints[config.bindings.ai.binding] = "ai";
-    if (config.bindings.sendEmail) {
-      Object.keys(config.bindings.sendEmail).forEach((name) => {
-        hints[name] = "sendEmail";
-      });
-    }
-    setBindingHints(hints);
-  }
-  const ctx = {
-    env: bindings,
-    miniflare,
-    async stop() {
-      await miniflare.dispose();
-      globalTestContext = null;
-    },
-    async reset() {
-      for (const [name, binding] of Object.entries(bindings)) {
-        if (isKVNamespace(binding)) {
-          const kv = binding;
-          const { keys } = await kv.list();
-          for (const key of keys) {
-            await kv.delete(key.name);
-          }
-        }
-      }
-    }
-  };
-  globalTestContext = ctx;
-  return ctx;
-}
-async function stopBridgeTestContext() {
-  if (globalTestContext) {
-    await globalTestContext.stop();
-  }
-}
-function getBridgeTestContext() {
-  if (!globalTestContext) {
-    throw new Error("Bridge test context not initialized. Call createBridgeTestContext() in beforeAll().");
-  }
-  return globalTestContext;
-}
-var testEnv = new Proxy({}, {
-  get(target, prop) {
-    if (typeof prop !== "string")
-      return;
-    const ctx = getBridgeTestContext();
-    return ctx.env[prop];
-  }
-});
-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, email, queue, scheduled, tail, worker, createTestContext, cf, shouldSkip, createMockTestContext, withTestContext, createMockKV, createMockD1, createMockR2, createMockQueue, createMockEnv, createBridgeTestContext, stopBridgeTestContext, getBridgeTestContext, testEnv };
+export {
+  worker,
+  withTestContext,
+  tail,
+  shouldSkip,
+  scheduled,
+  resolveServiceBindings,
+  resolveDOBindings,
+  queue,
+  hasServiceBindings,
+  hasCrossWorkerDOs,
+  env,
+  email,
+  createTestContext,
+  createMockTestContext,
+  createMockR2,
+  createMockQueue,
+  createMockKV,
+  createMockEnv,
+  createMockD1,
+  clearBundleCache,
+  cf
+};