devflare 1.0.0-next.1 → 1.0.0-next.10

package/dist/{index-ep3445yc.js → index-jht2j546.js}

@@ -1,34 +1,62 @@
+import {
+  getRemoteModeStatus,
+  isRemoteModeActive
+} from "./index-d8bdkx2h.js";
 import {
   transformWorkerEntrypoint
-} from "./index-z14anrqp.js";
+} from "./index-wfbfz02q.js";
 import {
   discoverEntrypointsSync,
   resolvePackageSpecifier
-} from "./index-tk6ej9dj.js";
+} from "./index-2q3pmzrx.js";
 import {
-  getRemoteModeStatus,
-  isRemoteModeActive
-} from "./index-d8bdkx2h.js";
+  __clearTestContext,
+  __setTestContext
+} from "./index-vky23txa.js";
+import {
+  createRouteResolve,
+  invokeFetchModule,
+  matchFetchRoute,
+  resolveFetchHandler
+} from "./index-8gtqgb3q.js";
+import {
+  createEmailEvent,
+  createFetchEvent,
+  createQueueEvent,
+  createScheduledEvent,
+  createTailEvent,
+  runWithContext,
+  runWithEventContext
+} from "./index-5yxg30va.js";
+import {
+  discoverRoutes
+} from "./index-1p814k7s.js";
+import {
+  findDurableObjectClasses
+} from "./index-9wt9x09k.js";
 import {
   DEFAULT_DO_PATTERN,
   findFiles,
   findFilesSync
 } from "./index-rbht7m9r.js";
 import {
-  findDurableObjectClasses
-} from "./index-gz1gndna.js";
+  startMiniflare,
+  startMiniflareFromConfig
+} from "./index-vs49yxn4.js";
 import {
   BridgeClient,
-  bridgeEnv,
   createEnvProxy,
-  setBindingHints,
-  startMiniflare,
-  startMiniflareFromConfig
-} from "./index-pf5s73n9.js";
+  setBindingHints
+} from "./index-59df49vn.js";
+import {
+  createLocalSendEmailBinding,
+  wrapEnvSendEmailBindings
+} from "./index-fef08w43.js";
 import {
   loadConfig,
-  normalizeDOBinding
-} from "./index-hcex3rgh.js";
+  normalizeDOBinding,
+  resolveConfigPath
+} from "./index-1phx14av.js";
 import {
   canProceedWithTest,
   getApiToken,
@@ -41,7 +69,7 @@ import {
 } from "./index-37x76zdn.js";
 
 // src/test/simple-context.ts
-import { resolve as resolve2, dirname as dirname2, join as join6 } from "path";
+import { resolve as resolve2, dirname as dirname2, join as join7 } from "path";
 import { existsSync as existsSync2 } from "fs";
 
 // src/test/remote-ai.ts
@@ -242,6 +270,15 @@ var bundleCache = new Map;
 function clearBundleCache() {
   bundleCache.clear();
 }
+function findDefaultServiceWorkerEntrypoint(refConfigDir) {
+  for (const candidate of ["src/worker.ts", "src/worker.js"]) {
+    const absolutePath = resolve(refConfigDir, candidate);
+    if (existsSync(absolutePath)) {
+      return absolutePath;
+    }
+  }
+  return null;
+}
 function hasServiceBindings(config) {
   const services = config.bindings?.services;
   if (!services)
@@ -297,24 +334,23 @@ async function resolveRefWorker(ref, _entrypoint, parentConfigDir) {
   }
   const refConfigDir = resolve(parentConfigDir, dirname(configPath));
   const entrypoints = [];
-  const files = config.files;
-  const mainPath = files?.fetch ?? "src/worker.ts";
-  const workerTsPath = resolve(refConfigDir, mainPath);
-  if (existsSync(workerTsPath)) {
-    const isWorkerTs = mainPath.endsWith("worker.ts") || mainPath.endsWith("worker.js");
+  const workerEntrypointPath = findDefaultServiceWorkerEntrypoint(refConfigDir);
+  if (workerEntrypointPath) {
     entrypoints.push({
-      path: workerTsPath,
+      path: workerEntrypointPath,
       className: "Worker",
-      isWorkerTs
+      isWorkerTs: true
     });
   }
-  const discoveredEntrypoints = discoverEntrypointsSync(refConfigDir);
-  for (const ep of discoveredEntrypoints) {
-    entrypoints.push({
-      path: ep.filePath,
-      className: ep.className,
-      isWorkerTs: false
-    });
+  if (config.files?.entrypoints !== false) {
+    const discoveredEntrypoints = discoverEntrypointsSync(refConfigDir, typeof config.files?.entrypoints === "string" ? config.files.entrypoints : undefined);
+    for (const ep of discoveredEntrypoints) {
+      entrypoints.push({
+        path: ep.filePath,
+        className: ep.className,
+        isWorkerTs: false
+      });
+    }
   }
   if (entrypoints.length === 0) {
     console.warn(`[devflare] Worker "${ref.name}" has no entry points`);
@@ -574,86 +610,6 @@ export default {
   }
 }
 
-// src/runtime/context.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-var storage = new AsyncLocalStorage;
-function runWithContext(env, ctx, request, fn, type = "fetch") {
-  const context = {
-    env,
-    ctx,
-    request,
-    locals: {},
-    type
-  };
-  return storage.run(context, fn);
-}
-function getContextOrNull() {
-  const context = storage.getStore();
-  return context ?? null;
-}
-
-// src/env.ts
-var testContextEnv = null;
-var testContextDispose = null;
-function __setTestContext(envBindings, dispose) {
-  testContextEnv = envBindings;
-  testContextDispose = dispose;
-}
-function __clearTestContext() {
-  testContextEnv = null;
-  testContextDispose = null;
-}
-var env = new Proxy({}, {
-  get(_target, prop) {
-    if (prop === "dispose") {
-      return async () => {
-        if (testContextDispose) {
-          await testContextDispose();
-          __clearTestContext();
-        }
-      };
-    }
-    const ctx = getContextOrNull();
-    if (ctx?.env) {
-      return ctx.env[prop];
-    }
-    if (testContextEnv) {
-      return testContextEnv[prop];
-    }
-    return bridgeEnv[prop];
-  },
-  has(_target, prop) {
-    if (prop === "dispose")
-      return true;
-    const ctx = getContextOrNull();
-    if (ctx?.env) {
-      return prop in ctx.env;
-    }
-    if (testContextEnv) {
-      return prop in testContextEnv;
-    }
-    return prop in bridgeEnv;
-  },
-  ownKeys(_target) {
-    const ctx = getContextOrNull();
-    if (ctx?.env) {
-      return Reflect.ownKeys(ctx.env);
-    }
-    if (testContextEnv) {
-      return Reflect.ownKeys(testContextEnv);
-    }
-    return Reflect.ownKeys(bridgeEnv);
-  },
-  getOwnPropertyDescriptor(_target, prop) {
-    if (prop === "dispose") {
-      return { configurable: true, enumerable: false, writable: false };
-    }
-    const ctx = getContextOrNull();
-    const source = ctx?.env ?? testContextEnv ?? bridgeEnv;
-    return Reflect.getOwnPropertyDescriptor(source, prop);
-  }
-});
-
 // src/test/queue.ts
 import { join as join2 } from "path";
 var queueHandlerPath = null;
@@ -721,8 +677,8 @@ async function trigger(messages) {
   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 default async function queue(batch, env, ctx) { ... }
-Or: export async function queue(batch, env, ctx) { ... }`);
+Expected: export async function queue(event) { ... }
+Legacy compatibility is still supported for queue(batch, env, ctx).`);
   }
   const normalizedMessages = messages.map((msg) => {
     if (typeof msg === "object" && msg !== null && "body" in msg) {
@@ -740,8 +696,9 @@ Or: export async function queue(batch, env, ctx) { ... }`);
     passThroughOnException() {},
     props: {}
   };
-  const env2 = testEnvGetter();
-  await queueHandler(batch, env2, ctx);
+  const env = testEnvGetter();
+  const queueEvent = createQueueEvent(batch, env, ctx);
+  await runWithEventContext(queueEvent, () => queueHandler(queueEvent, env, ctx));
   await Promise.all(waitUntilPromises);
   const acked = [];
   const retried = [];
@@ -804,8 +761,8 @@ async function trigger2(cronOrOptions) {
   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 default async function scheduled(controller, env, ctx) { ... }
-Or: export async function scheduled(controller, env, ctx) { ... }`);
+Expected: export async function scheduled(event) { ... }
+Legacy compatibility is still supported for scheduled(controller, env, ctx).`);
   }
   const controller = {
     scheduledTime,
@@ -820,9 +777,10 @@ Or: export async function scheduled(controller, env, ctx) { ... }`);
     passThroughOnException() {},
     props: {}
   };
-  const env2 = testEnvGetter2();
+  const env = testEnvGetter2();
+  const scheduledEvent = createScheduledEvent(controller, env, ctx);
   try {
-    await scheduledHandler(controller, env2, ctx);
+    await runWithEventContext(scheduledEvent, () => scheduledHandler(scheduledEvent, env, ctx));
     await Promise.all(waitUntilPromises);
     return {
       success: true,
@@ -847,23 +805,28 @@ 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) {
-    throw new Error("Fetch handler not configured. Make sure your devflare.config.ts has files.fetch set, " + "and the file exists at the specified path (default: src/fetch.ts)");
+  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}`;
@@ -887,13 +850,24 @@ async function fetch2(request, options) {
   } else {
     req = request;
   }
-  const absolutePath = join4(configDir3, fetchHandlerPath);
-  const handlerModule = await import(absolutePath);
-  const fetchHandler = handlerModule.default ?? handlerModule.fetch;
-  if (typeof fetchHandler !== "function") {
-    throw new Error(`Fetch handler at "${fetchHandlerPath}" must export a default function or named "fetch" export.
-Expected: export default async function fetch(request, env, ctx) { ... }
-Or: export async function fetch(request, env, ctx) { ... }`);
+  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 = {
@@ -903,8 +877,12 @@ Or: export async function fetch(request, env, ctx) { ... }`);
     passThroughOnException() {},
     props: {}
   };
-  const env2 = testEnvGetter3();
-  const response = await fetchHandler(req, env2, ctx);
+  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) {
@@ -967,7 +945,7 @@ function createTraceItem(options) {
 }
 async function trigger3(items) {
   if (!tailHandlerPath) {
-    throw new Error("Tail handler not configured. Make sure your devflare.config.ts has files.tail set, " + "or the file exists at src/tail.ts");
+    throw new Error("Tail handler not configured. Add a src/tail.ts file exporting tail(), " + "or configure a tail handler before calling cf.tail.trigger().");
   }
   if (!configDir4 || !testEnvGetter4) {
     throw new Error("Tail helper not initialized. Call createTestContext() before using cf.tail.trigger()");
@@ -983,8 +961,8 @@ async function trigger3(items) {
   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 default async function tail(events, env, ctx) { ... }
-Or: export async function tail(events, env, ctx) { ... }`);
+Expected: export async function tail(event) { ... }
+Legacy compatibility is still supported for tail(events, env, ctx).`);
   }
   const waitUntilPromises = [];
   const ctx = {
@@ -994,9 +972,10 @@ Or: export async function tail(events, env, ctx) { ... }`);
     passThroughOnException() {},
     props: {}
   };
-  const env2 = testEnvGetter4();
+  const env = testEnvGetter4();
+  const tailEvent = createTailEvent(traceItems, env, ctx);
   try {
-    await tailHandler(traceItems, env2, ctx);
+    await runWithEventContext(tailEvent, () => tailHandler(tailEvent, env, ctx));
     await Promise.all(waitUntilPromises);
     return {
       success: true,
@@ -1019,13 +998,20 @@ var tail = {
 };
 
 // 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) {
@@ -1053,8 +1039,103 @@ function buildRawEmail(options) {
   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 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
+        });
+      }
+    };
+    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" }
+    });
+  }
   const url = new URL(`http://localhost:${miniflarePort}/cdn-cgi/handler/email`);
   url.searchParams.set("from", options.from);
   url.searchParams.set("to", options.to);
@@ -1079,7 +1160,21 @@ function getSentEmails() {
 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;
+  configDir5 = null;
+  testEnvGetter5 = null;
   emailListeners = [];
   sentEmails = [];
 }
@@ -1134,15 +1229,12 @@ function getCallerDirectory() {
   }
   return process.cwd();
 }
-function findNearestConfig(startDir) {
-  const configNames = ["devflare.config.ts", "devflare.config.js"];
+async function findNearestConfig(startDir) {
   let currentDir = startDir;
   while (true) {
-    for (const name of configNames) {
-      const configPath = join6(currentDir, name);
-      if (existsSync2(configPath)) {
-        return configPath;
-      }
+    const configPath = await resolveConfigPath(currentDir);
+    if (configPath) {
+      return configPath;
     }
     const parentDir = dirname2(currentDir);
     if (parentDir === currentDir) {
@@ -1157,16 +1249,17 @@ async function createTestContext(configPath) {
   if (configPath) {
     absolutePath = resolve2(callerDir, configPath);
   } else {
-    const found = findNearestConfig(callerDir);
+    const found = await findNearestConfig(callerDir);
     if (!found) {
-      throw new Error(`Could not find devflare.config.ts. Searched upward from: ${callerDir}
+      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 configDir5 = dirname2(absolutePath);
+  const configDir6 = dirname2(absolutePath);
   const config = await loadConfig({
-    cwd: configDir5,
+    cwd: configDir6,
     configFile: absolutePath.split(/[/\\]/).pop()
   });
   globalRemoteBindings = {};
@@ -1186,6 +1279,11 @@ async function createTestContext(configPath) {
       globalRemoteBindings[key] = value;
     }
   }
+  if (config.bindings?.sendEmail) {
+    for (const [name, binding] of Object.entries(config.bindings.sendEmail)) {
+      globalRemoteBindings[name] = createLocalSendEmailBinding(binding);
+    }
+  }
   const hints = {};
   if (config.bindings?.kv) {
     for (const name of Object.keys(config.bindings.kv))
@@ -1207,18 +1305,23 @@ async function createTestContext(configPath) {
     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))
+      hints[name] = "sendEmail";
+  }
   const needsMultiWorkerForServices = hasServiceBindings(config);
   const needsMultiWorkerForDOs = hasCrossWorkerDOs(config);
   const needsMultiWorker = needsMultiWorkerForServices || needsMultiWorkerForDOs;
   let serviceBindingResolution = null;
   let doBindingResolution = null;
   if (needsMultiWorkerForServices) {
-    serviceBindingResolution = await resolveServiceBindings(config, configDir5);
+    serviceBindingResolution = await resolveServiceBindings(config, configDir6);
   }
   if (needsMultiWorkerForDOs) {
-    doBindingResolution = await resolveDOBindings(config, configDir5);
+    doBindingResolution = await resolveDOBindings(config, configDir6);
   }
   const randomPort = 1e4 + Math.floor(Math.random() * 50000);
+  const localWorkerBindings = config.vars ?? {};
   const mfConfig = {
     modules: true,
     port: randomPort
@@ -1236,9 +1339,28 @@ async function createTestContext(configPath) {
     }
     mfConfig.queueProducers = queueProducers;
   }
+  if (Object.keys(localWorkerBindings).length > 0) {
+    mfConfig.bindings = localWorkerBindings;
+  }
+  if (config.bindings?.sendEmail) {
+    mfConfig.email = {
+      send_email: Object.entries(config.bindings.sendEmail).map(([name, binding]) => ({
+        name,
+        ...binding.destinationAddress && {
+          destination_address: binding.destinationAddress
+        },
+        ...binding.allowedDestinationAddresses && {
+          allowed_destination_addresses: binding.allowedDestinationAddresses
+        },
+        ...binding.allowedSenderAddresses && {
+          allowed_sender_addresses: binding.allowedSenderAddresses
+        }
+      }))
+    };
+  }
   const transportFile = config.files?.transport;
   if (transportFile) {
-    const transportPath = join6(configDir5, transportFile);
+    const transportPath = join7(configDir6, transportFile);
     const transportModule = await import(transportPath);
     if (!transportModule.transport) {
       console.warn(`[devflare] Warning: Transport file "${transportFile}" does not export a named "transport" object.
@@ -1260,7 +1382,7 @@ Transport encoding/decoding will be disabled.`);
     const doPattern = typeof doPatternConfig === "string" ? doPatternConfig : DEFAULT_DO_PATTERN;
     if (doPatternConfig !== false) {
       const fs = await import("fs/promises");
-      const doFiles = await findFiles(doPattern, { cwd: configDir5 });
+      const doFiles = await findFiles(doPattern, { cwd: configDir6 });
       for (const filePath of doFiles) {
         try {
           const code = await fs.readFile(filePath, "utf-8");
@@ -1278,7 +1400,7 @@ Transport encoding/decoding will be disabled.`);
       }
       let scriptPath;
       if (doInfo.scriptName) {
-        scriptPath = join6(configDir5, "src", doInfo.scriptName);
+        scriptPath = join7(configDir6, "src", doInfo.scriptName);
       } else {
         const discoveredPath = classToFilePath.get(doInfo.className);
         if (!discoveredPath) {
@@ -1295,7 +1417,7 @@ Either:
     const virtualImports = [];
     const virtualExports = [];
     if (transportFile) {
-      const transportPath = join6(configDir5, transportFile);
+      const transportPath = join7(configDir6, transportFile);
       virtualImports.push(`import { transport } from '${transportPath.replace(/\\/g, "/")}'`);
       virtualExports.push("export { transport }");
     }
@@ -1307,7 +1429,7 @@ Either:
     if (virtualImports.length > 0) {
       const virtualEntry = [...virtualImports, "", ...virtualExports].join(`
 `);
-      const virtualPath = join6(configDir5, ".devflare", "__test_entry.ts");
+      const virtualPath = join7(configDir6, ".devflare", "__test_entry.ts");
       const { writeFileSync, mkdirSync } = await import("fs");
       mkdirSync(dirname2(virtualPath), { recursive: true });
       writeFileSync(virtualPath, virtualEntry);
@@ -1348,6 +1470,7 @@ Either:
       ...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 }
     };
@@ -1381,7 +1504,7 @@ Either:
   const { Miniflare } = await import("miniflare");
   globalMiniflare = new Miniflare(mfConfig);
   await globalMiniflare.ready;
-  globalMiniflareBindings = await globalMiniflare.getBindings();
+  globalMiniflareBindings = wrapEnvSendEmailBindings(await globalMiniflare.getBindings());
   const disposeContext = async () => {
     if (globalClient) {
       await globalClient.disconnect();
@@ -1403,26 +1526,42 @@ Either:
     __clearTestContext();
   };
   const getTestEnv = () => {
-    if (globalMiniflareBindings)
-      return globalMiniflareBindings;
-    if (globalRemoteBindings)
-      return globalRemoteBindings;
-    if (globalEnvProxy)
-      return globalEnvProxy;
-    return {};
+    return new Proxy({}, {
+      get(_, prop) {
+        if (globalRemoteBindings && prop in globalRemoteBindings) {
+          return globalRemoteBindings[prop];
+        }
+        if (hints[prop] === "sendEmail" && globalEnvProxy && prop in globalEnvProxy) {
+          return globalEnvProxy[prop];
+        }
+        if (globalMiniflareBindings && prop in globalMiniflareBindings) {
+          return globalMiniflareBindings[prop];
+        }
+        if (globalEnvProxy && prop in globalEnvProxy) {
+          return globalEnvProxy[prop];
+        }
+        return;
+      },
+      has(_, prop) {
+        return Boolean(globalRemoteBindings && prop in globalRemoteBindings || globalMiniflareBindings && prop in globalMiniflareBindings || globalEnvProxy && prop in globalEnvProxy);
+      }
+    });
   };
   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 = join6(configDir5, defaultPath);
+    const defaultAbsolute = join7(configDir6, defaultPath);
     try {
       const fs = await import("fs/promises");
       await fs.access(defaultAbsolute);
@@ -1431,32 +1570,45 @@ Either:
       return null;
     }
   };
-  const [resolvedFetchPath, resolvedQueuePath, resolvedScheduledPath] = await Promise.all([
+  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(scheduledPath, DEFAULT_SCHEDULED_PATH),
+    resolvePath(emailPath, DEFAULT_EMAIL_PATH),
+    resolvePath(undefined, DEFAULT_TAIL_PATH),
+    discoverRoutes(configDir6, config)
   ]);
   configureQueue({
     handlerPath: resolvedQueuePath,
-    configDir: configDir5,
+    configDir: configDir6,
     getEnv: getTestEnv
   });
   configureScheduled({
     handlerPath: resolvedScheduledPath,
-    configDir: configDir5,
+    configDir: configDir6,
     getEnv: getTestEnv
   });
   configureWorker({
     handlerPath: resolvedFetchPath,
-    configDir: configDir5,
+    routes: resolvedRoutes?.routes.map((route) => ({
+      filePath: route.filePath,
+      routePath: route.routePath,
+      segments: route.segments
+    })) ?? [],
+    configDir: configDir6,
     getEnv: getTestEnv
   });
   configureTail({
-    handlerPath: null,
-    configDir: configDir5,
+    handlerPath: resolvedTailPath,
+    configDir: configDir6,
+    getEnv: getTestEnv
+  });
+  configureEmail({
+    port: randomPort,
+    handlerPath: resolvedEmailPath,
+    configDir: configDir6,
     getEnv: getTestEnv
   });
-  configureEmail({ port: randomPort });
   if (hasMultiWorkerServices || hasMultiWorkerDOs) {
     setBindingHints(hints);
     const envAccessor2 = new Proxy({}, {
@@ -1490,6 +1642,9 @@ Either:
       if (globalRemoteBindings && prop in globalRemoteBindings) {
         return globalRemoteBindings[prop];
       }
+      if (hints[prop] === "sendEmail" && globalEnvProxy && prop in globalEnvProxy) {
+        return globalEnvProxy[prop];
+      }
       if (globalMiniflareBindings && prop in globalMiniflareBindings) {
         return globalMiniflareBindings[prop];
       }
@@ -1588,6 +1743,7 @@ 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
@@ -1619,6 +1775,11 @@ async function executeRpc(env, method, params) {
 	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() }
@@ -1637,6 +1798,63 @@ async function executeRpc(env, method, params) {
 
 	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
@@ -2146,7 +2364,7 @@ async function createBridgeTestContext(options = {}) {
       verbose: options.verbose ?? false
     });
   }
-  const bindings = await miniflare.getBindings();
+  const bindings = wrapEnvSendEmailBindings(await miniflare.getBindings());
   if (config?.bindings) {
     const hints = {};
     if (config.bindings.kv) {
@@ -2176,6 +2394,11 @@ async function createBridgeTestContext(options = {}) {
     }
     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 = {
@@ -2222,4 +2445,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 { env, 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, queue, scheduled, worker, tail, email, createTestContext, cf, createMultiWorkerContext, createEntrypointScript, isRemoteModeEnabled, shouldSkip, createMockTestContext, withTestContext, createMockKV, createMockD1, createMockR2, createMockQueue, createMockEnv, createBridgeTestContext, stopBridgeTestContext, getBridgeTestContext, testEnv };