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

package/dist/index-hfj1a2c4.js

@@ -1,2649 +0,0 @@
-import {
-  getRemoteModeStatus,
-  isRemoteModeActive
-} from "./index-d8bdkx2h.js";
-import {
-  discoverEntrypointsSync
-} from "./index-zt22fe2j.js";
-import {
-  canProceedWithTest
-} from "./index-7g8zyws4.js";
-import {
-  transformWorkerEntrypoint
-} from "./index-wfbfz02q.js";
-import {
-  resolvePackageSpecifier
-} from "./index-82f1z98k.js";
-import {
-  __clearTestContext,
-  __setTestContext
-} from "./index-m3fmw6mx.js";
-import {
-  createRouteResolve,
-  invokeFetchModule,
-  matchFetchRoute,
-  resolveFetchHandler
-} from "./index-hjy8ctpc.js";
-import {
-  createEmailEvent,
-  createFetchEvent,
-  createQueueEvent,
-  createScheduledEvent,
-  createTailEvent,
-  runWithContext,
-  runWithEventContext
-} from "./index-cgbvmse6.js";
-import {
-  discoverRoutes
-} from "./index-1p814k7s.js";
-import {
-  DEFAULT_DO_PATTERN,
-  findFiles,
-  findFilesSync
-} from "./index-rbht7m9r.js";
-import {
-  findDurableObjectClasses
-} from "./index-9wt9x09k.js";
-import {
-  startMiniflare,
-  startMiniflareFromConfig
-} from "./index-1sp39f2f.js";
-import {
-  BridgeClient,
-  createEnvProxy,
-  setBindingHints
-} from "./index-9ba1etyz.js";
-import {
-  createLocalSendEmailBinding,
-  wrapEnvSendEmailBindings
-} from "./index-h18pxvzs.js";
-import {
-  getLocalD1DatabaseIdentifier,
-  loadConfig,
-  normalizeDOBinding,
-  resolveConfigPath
-} from "./index-43dq8yx8.js";
-import {
-  getEffectiveAccountId,
-  getPrimaryAccount
-} from "./index-xk9djfjp.js";
-import {
-  getApiToken,
-  isAuthenticated
-} from "./index-0w826dsr.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;
-}
-
-// src/test/resolve-service-bindings.ts
-import { dirname, join, resolve } from "path";
-import { existsSync, readFileSync } from "fs";
-function getBunRuntime() {
-  const g = globalThis;
-  if (typeof g.Bun === "object" && g.Bun !== null) {
-    return g.Bun;
-  }
-  return;
-}
-function discoverDOFilesSync(dir) {
-  const classToPath = new Map;
-  try {
-    const files = findFilesSync(DEFAULT_DO_PATTERN, { cwd: dir });
-    for (const filePath of files) {
-      try {
-        const code = readFileSync(filePath, "utf-8");
-        const classNames = findDurableObjectClasses(code);
-        for (const className of classNames) {
-          if (!classToPath.has(className)) {
-            classToPath.set(className, filePath);
-          }
-        }
-      } catch {}
-    }
-  } catch {}
-  return classToPath;
-}
-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)
-    return false;
-  return Object.keys(services).length > 0;
-}
-async function resolveServiceBindings(config, configDir) {
-  const services = config.bindings?.services;
-  if (!services) {
-    return { workers: [], primaryServiceBindings: {} };
-  }
-  const workersByName = new Map;
-  const primaryServiceBindings = {};
-  for (const [bindingName, binding] of Object.entries(services)) {
-    const workerBinding = binding;
-    const ref = workerBinding.__ref;
-    if (ref) {
-      if ("__import" in ref && typeof ref.__import === "function") {
-        await ref.resolve();
-      }
-      const workerName = ref.name;
-      const entrypoint = workerBinding.entrypoint;
-      if (!workersByName.has(workerName)) {
-        const worker = await resolveRefWorker(ref, entrypoint, configDir);
-        if (worker) {
-          workersByName.set(workerName, worker);
-        }
-      }
-      primaryServiceBindings[bindingName] = {
-        name: workerName,
-        ...entrypoint && { entrypoint }
-      };
-    } else {
-      primaryServiceBindings[bindingName] = {
-        name: workerBinding.service,
-        ...workerBinding.entrypoint && { entrypoint: workerBinding.entrypoint }
-      };
-    }
-  }
-  return {
-    workers: [...workersByName.values()],
-    primaryServiceBindings
-  };
-}
-async function resolveRefWorker(ref, _entrypoint, parentConfigDir) {
-  const config = ref.config;
-  if (!config)
-    return null;
-  const configPath = ref.configPath;
-  if (!configPath || configPath === "<resolved>") {
-    console.warn(`[devflare] Cannot resolve worker "${ref.name}" - configPath not available`);
-    return null;
-  }
-  const refConfigDir = resolve(parentConfigDir, dirname(configPath));
-  const entrypoints = [];
-  const workerEntrypointPath = findDefaultServiceWorkerEntrypoint(refConfigDir);
-  if (workerEntrypointPath) {
-    entrypoints.push({
-      path: workerEntrypointPath,
-      className: "Worker",
-      isWorkerTs: true
-    });
-  }
-  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`);
-    return null;
-  }
-  const script = await bundleAllEntrypoints(entrypoints, ref.name);
-  if (!script)
-    return null;
-  return {
-    name: ref.name,
-    script,
-    modules: true,
-    compatibilityDate: config.compatibilityDate ?? "2025-01-01"
-  };
-}
-async function bundleAllEntrypoints(entrypoints, workerName) {
-  const cacheKey = entrypoints.map((ep) => `${ep.path}::${ep.className}`).join("|");
-  const cached = bundleCache.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-  const bun = getBunRuntime();
-  if (!bun) {
-    console.warn("[devflare] Bun runtime required for bundling worker scripts");
-    return null;
-  }
-  try {
-    const { readFileSync: readFileSync2, writeFileSync, mkdirSync, unlinkSync } = await import("fs");
-    const imports = [];
-    const exports = [];
-    let defaultExportClass = null;
-    for (let i = 0;i < entrypoints.length; i++) {
-      const ep = entrypoints[i];
-      const sourceCode = readFileSync2(ep.path, "utf-8");
-      if (ep.isWorkerTs) {
-        const result = transformWorkerEntrypoint(sourceCode, ep.path, {
-          className: ep.className,
-          injectContext: false
-        });
-        if (result) {
-          const tempDir2 = join(dirname(ep.path), ".devflare");
-          mkdirSync(tempDir2, { recursive: true });
-          const tempPath = join(tempDir2, `__${ep.className}_${i}.ts`);
-          writeFileSync(tempPath, result.code);
-          imports.push(`import { ${ep.className} } from '${tempPath.replace(/\\/g, "/")}'`);
-          exports.push(ep.className);
-          if (!defaultExportClass) {
-            defaultExportClass = ep.className;
-          }
-        }
-      } else {
-        imports.push(`import { ${ep.className} } from '${ep.path.replace(/\\/g, "/")}'`);
-        exports.push(ep.className);
-      }
-    }
-    const defaultExport = defaultExportClass ? `
-export default ${defaultExportClass}` : "";
-    const entryCode = `
-${imports.join(`
-`)}
-export { ${exports.join(", ")} }${defaultExport}
-`;
-    const tempDir = join(dirname(entrypoints[0].path), ".devflare");
-    mkdirSync(tempDir, { recursive: true });
-    const entryPath = join(tempDir, `__entry_${workerName}.ts`);
-    writeFileSync(entryPath, entryCode);
-    try {
-      const result = await bun.build({
-        entrypoints: [entryPath],
-        target: "browser",
-        format: "esm",
-        minify: false,
-        external: ["cloudflare:workers", "cloudflare:*"]
-      });
-      if (!result.success) {
-        console.warn(`[devflare] Failed to bundle worker "${workerName}": ${result.logs.join(`
-`)}`);
-        return null;
-      }
-      const bundledCode = await result.outputs[0].text();
-      bundleCache.set(cacheKey, bundledCode);
-      return bundledCode;
-    } finally {
-      try {
-        unlinkSync(entryPath);
-      } catch {}
-    }
-  } catch (error) {
-    console.warn(`[devflare] Error bundling worker "${workerName}":`, error);
-    return null;
-  }
-}
-function hasCrossWorkerDOs(config) {
-  const dos = config.bindings?.durableObjects;
-  if (!dos)
-    return false;
-  for (const doConfig of Object.values(dos)) {
-    const normalized = normalizeDOBinding(doConfig);
-    if (normalized.__ref)
-      return true;
-  }
-  return false;
-}
-async function resolveDOBindings(config, configDir) {
-  const dos = config.bindings?.durableObjects;
-  if (!dos) {
-    return { workers: [], crossWorkerDOBindings: {} };
-  }
-  const workersByName = new Map;
-  const crossWorkerDOBindings = {};
-  for (const [bindingName, rawDoConfig] of Object.entries(dos)) {
-    const hasRef = typeof rawDoConfig === "object" && "__ref" in rawDoConfig;
-    if (!hasRef) {
-      continue;
-    }
-    const ref = rawDoConfig.__ref;
-    if ("__import" in ref && typeof ref.__import === "function") {
-      await ref.resolve();
-    }
-    const doConfig = normalizeDOBinding(rawDoConfig);
-    const workerName = ref.name;
-    if (!workersByName.has(workerName)) {
-      const worker = await resolveDORefWorker(ref, configDir);
-      if (worker) {
-        workersByName.set(workerName, worker);
-      }
-    }
-    crossWorkerDOBindings[bindingName] = {
-      className: doConfig.className,
-      scriptName: workerName
-    };
-  }
-  return {
-    workers: [...workersByName.values()],
-    crossWorkerDOBindings
-  };
-}
-async function resolveDORefWorker(ref, parentConfigDir) {
-  const config = ref.config;
-  if (!config)
-    return null;
-  const configPath = ref.configPath;
-  if (!configPath || configPath === "<resolved>") {
-    console.warn(`[devflare] Cannot resolve DO worker "${ref.name}" - configPath not available`);
-    return null;
-  }
-  const resolvedConfigPath = resolvePackageSpecifier(configPath, parentConfigDir);
-  const refConfigDir = dirname(resolvedConfigPath);
-  const dosConfig = config.bindings?.durableObjects;
-  if (!dosConfig || Object.keys(dosConfig).length === 0) {
-    console.warn(`[devflare] Referenced worker "${ref.name}" has no Durable Objects`);
-    return null;
-  }
-  const discoveredDOs = discoverDOFilesSync(refConfigDir);
-  const doClasses = [];
-  for (const [bindingName, rawDoConfig] of Object.entries(dosConfig)) {
-    const doConfig = normalizeDOBinding(rawDoConfig);
-    const className = doConfig.className;
-    const scriptName = doConfig.scriptName;
-    if (scriptName) {
-      const scriptPath = resolve(refConfigDir, "src", scriptName);
-      if (!existsSync(scriptPath)) {
-        const altPath = resolve(refConfigDir, scriptName);
-        if (!existsSync(altPath)) {
-          console.warn(`[devflare] DO script not found: ${scriptPath} or ${altPath}`);
-          continue;
-        }
-        doClasses.push({ bindingName, className, scriptPath: altPath });
-      } else {
-        doClasses.push({ bindingName, className, scriptPath });
-      }
-    } else {
-      const discoveredPath = discoveredDOs.get(className);
-      if (discoveredPath) {
-        doClasses.push({ bindingName, className, scriptPath: discoveredPath });
-      } else {
-        console.warn(`[devflare] DO "${bindingName}" (class: ${className}) not found in do.*.ts files in "${ref.name}"`);
-        continue;
-      }
-    }
-  }
-  if (doClasses.length === 0) {
-    console.warn(`[devflare] No valid DO classes found in "${ref.name}"`);
-    return null;
-  }
-  const script = await bundleDOClasses(doClasses, ref.name);
-  if (!script)
-    return null;
-  const durableObjects = {};
-  for (const do_ of doClasses) {
-    durableObjects[do_.bindingName] = do_.className;
-  }
-  return {
-    name: ref.name,
-    script,
-    modules: true,
-    compatibilityDate: config.compatibilityDate ?? "2025-01-01",
-    durableObjects
-  };
-}
-async function bundleDOClasses(doClasses, workerName) {
-  const cacheKey = `do:${doClasses.map((d) => `${d.scriptPath}::${d.className}`).join("|")}`;
-  const cached = bundleCache.get(cacheKey);
-  if (cached)
-    return cached;
-  const bun = getBunRuntime();
-  if (!bun) {
-    console.warn("[devflare] Bun runtime required for bundling DO classes");
-    return null;
-  }
-  try {
-    const { writeFileSync, mkdirSync, unlinkSync } = await import("fs");
-    const imports = doClasses.map((d) => `import { ${d.className} } from '${d.scriptPath.replace(/\\/g, "/")}'`).join(`
-`);
-    const exports = doClasses.map((d) => d.className).join(", ");
-    const entryCode = `
-${imports}
-
-// Re-export DO classes for Miniflare binding
-export { ${exports} }
-
-// Default export with fetch handler
-export default {
-	async fetch(request, env) {
-		return new Response('DO Worker: ${workerName}')
-	}
-}
-`;
-    const tempDir = join(dirname(doClasses[0].scriptPath), ".devflare");
-    mkdirSync(tempDir, { recursive: true });
-    const entryPath = join(tempDir, `__do_entry_${workerName}.ts`);
-    writeFileSync(entryPath, entryCode);
-    try {
-      const result = await bun.build({
-        entrypoints: [entryPath],
-        target: "browser",
-        format: "esm",
-        minify: false,
-        external: ["cloudflare:workers", "cloudflare:*"]
-      });
-      if (!result.success) {
-        console.warn(`[devflare] Failed to bundle DO worker "${workerName}": ${result.logs.join(`
-`)}`);
-        return null;
-      }
-      const bundledCode = await result.outputs[0].text();
-      bundleCache.set(cacheKey, bundledCode);
-      return bundledCode;
-    } finally {
-      try {
-        unlinkSync(entryPath);
-      } catch {}
-    }
-  } catch (error) {
-    console.warn(`[devflare] Error bundling DO worker "${workerName}":`, error);
-    return null;
-  }
-}
-
-// src/test/simple-context-durable-objects.ts
-import { mkdirSync, writeFileSync } from "fs";
-import { readFile } from "fs/promises";
-import { dirname as dirname3, join as join3 } from "path";
-
-// src/test/simple-context-gateway-script.ts
-function buildGatewayScript(bundledCode, wrappers) {
-  return `
-// Bundled transport + DO classes
-${bundledCode}
-
-// DO Wrappers with RPC
-${wrappers}
-
-// Transport encoding helper
-const __transportEncoders = typeof transport !== 'undefined' ? transport : {}
-
-function __encodeTransport(value) {
-	if (value === null || value === undefined) return value
-	
-	// Try each encoder
-	for (const [typeName, transporter] of Object.entries(__transportEncoders)) {
-		const encoded = transporter.encode(value)
-		if (encoded !== false && encoded !== undefined) {
-			return { __transport: typeName, value: encoded }
-		}
-	}
-	
-	// Recursively encode arrays and objects
-	if (Array.isArray(value)) {
-		return value.map(__encodeTransport)
-	}
-	if (typeof value === 'object') {
-		const result = {}
-		for (const [k, v] of Object.entries(value)) {
-			result[k] = __encodeTransport(v)
-		}
-		return result
-	}
-	
-	return value
-}
-
-// Gateway with WebSocket RPC
-export default {
-	async fetch(request, env) {
-		if (request.headers.get('Upgrade') === 'websocket') {
-			const { 0: client, 1: server } = new WebSocketPair()
-			server.accept()
-			server.addEventListener('message', async (e) => {
-				try {
-					const m = JSON.parse(e.data)
-					if (m.t === 'rpc.call') {
-						const result = await executeRpc(env, m.method, m.params)
-						server.send(JSON.stringify({ t: 'rpc.ok', id: m.id, result }))
-					}
-				} catch (error) {
-					server.send(JSON.stringify({ t: 'rpc.err', id: 'unknown', error: { code: 'RPC_ERROR', message: error.message } }))
-				}
-			})
-			return new Response(null, { status: 101, webSocket: client })
-		}
-		return new Response('Gateway')
-	}
-}
-
-async function executeRpc(env, method, params) {
-	const [bindingName, ...rest] = method.split('.')
-	const op = rest.join('.')
-	const binding = env[bindingName]
-	const RAW_EMAIL = 'EmailMessage::raw'
-	if (!binding) throw new Error('Binding not found: ' + bindingName)
-
-	// KV operations
-	if (op === 'get') return binding.get(params[0], params[1])
-	if (op === 'put') return binding.put(params[0], params[1], params[2])
-	if (op === 'delete') return binding.delete(params[0])
-	if (op === 'list') return binding.list(params[0])
-	if (op === 'getWithMetadata') return binding.getWithMetadata(params[0], params[1])
-
-	// R2 operations
-	if (op === 'r2.get') return binding.get(params[0], params[1])
-	if (op === 'r2.put') return binding.put(params[0], params[1], params[2])
-	if (op === 'r2.delete') return binding.delete(params[0])
-	if (op === 'r2.list') return binding.list(params[0])
-	if (op === 'head') return binding.head(params[0])
-
-	// D1 operations
-	if (op === 'exec') return binding.exec(params[0])
-	if (op === 'dump') return binding.dump()
-	if (op === 'batch') {
-		const stmts = params[0].map(s => {
-			const stmt = binding.prepare(s.sql)
-			return s.bindings?.length ? stmt.bind(...s.bindings) : stmt
-		})
-		return binding.batch(stmts)
-	}
-	if (op === 'prepare.run') return binding.prepare(params[0]).bind(...(params[1] || [])).run()
-	if (op === 'prepare.all') return binding.prepare(params[0]).bind(...(params[1] || [])).all()
-	if (op === 'prepare.first') return binding.prepare(params[0]).bind(...(params[1] || [])).first(params[2])
-	if (op === 'prepare.raw') return binding.prepare(params[0]).bind(...(params[1] || [])).raw({ columnNames: params[2] })
-
-	// Send email operations
-	if (op === 'email.send') {
-		return binding.send(__normalizeEmailMessage(params[0]))
-	}
-
-	// DO operations
-	if (op === 'idFromName') {
-		return { __type: 'DOId', hex: binding.idFromName(params[0]).toString() }
-	}
-	if (op === 'stub.rpc') {
-		const [, idSerialized, rpcMethod, rpcParams] = params
-		const stub = binding.get(binding.idFromString(idSerialized.hex))
-
-		if (typeof stub[rpcMethod] === 'function') {
-			let result = await stub[rpcMethod](...(rpcParams || []))
-			result = __encodeTransport(result)
-			return result
-		}
-
-		const response = await stub.fetch(new Request('http://do/_rpc', {
-			method: 'POST',
-			headers: { 'Content-Type': 'application/json' },
-			body: JSON.stringify({ method: rpcMethod, params: rpcParams || [] })
-		}))
-
-		const payload = await response.json()
-		if (!response.ok || !payload?.ok) {
-			throw new Error(payload?.error?.message || ('DO RPC failed with status ' + response.status))
-		}
-
-		return payload.result
-	}
-
-	throw new Error('Unknown operation: ' + method)
-}
-
-function __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/simple-context-paths.ts
-import { existsSync as existsSync2 } from "fs";
-import { createServer } from "net";
-import { dirname as dirname2, join as join2 } from "path";
-import { fileURLToPath } from "url";
-var DEFAULT_TRANSPORT_ENTRY_FILES = [
-  "src/transport.ts",
-  "src/transport.js",
-  "src/transport.mts",
-  "src/transport.mjs"
-];
-var CURRENT_PACKAGE_ROOT = findPackageRoot(dirname2(fileURLToPath(import.meta.url)));
-function getBunRuntime2() {
-  const g = globalThis;
-  if (typeof g.Bun === "object" && g.Bun !== null) {
-    return g.Bun;
-  }
-  return;
-}
-function getCallerDirectory() {
-  const stackCallerDirectory = getStackCallerDirectory();
-  if (stackCallerDirectory) {
-    return stackCallerDirectory;
-  }
-  return process.cwd();
-}
-function getStackCallerDirectory() {
-  const originalPrepare = Error.prepareStackTrace;
-  Error.prepareStackTrace = (_, stack) => stack;
-  try {
-    const err = new Error;
-    const stack = err.stack;
-    for (const site of stack ?? []) {
-      const filename = site.getFileName?.();
-      if (filename && !isInsideCurrentPackage(filename) && !filename.includes("simple-context") && !filename.includes("node_modules") && !filename.includes("[") && existsSync2(filename)) {
-        return dirname2(filename);
-      }
-    }
-  } finally {
-    Error.prepareStackTrace = originalPrepare;
-  }
-  return null;
-}
-function findPackageRoot(startDir) {
-  let currentDir = startDir;
-  while (true) {
-    if (existsSync2(join2(currentDir, "package.json"))) {
-      return currentDir;
-    }
-    const parentDir = dirname2(currentDir);
-    if (parentDir === currentDir) {
-      return startDir;
-    }
-    currentDir = parentDir;
-  }
-}
-function isInsideCurrentPackage(filePath) {
-  const normalizedFilePath = filePath.replace(/\\/g, "/");
-  const normalizedPackageRoot = CURRENT_PACKAGE_ROOT.replace(/\\/g, "/");
-  return normalizedFilePath === normalizedPackageRoot || normalizedFilePath.startsWith(`${normalizedPackageRoot}/`);
-}
-async function findNearestConfig(startDir) {
-  let currentDir = startDir;
-  while (true) {
-    const configPath = await resolveConfigPath(currentDir);
-    if (configPath) {
-      return configPath;
-    }
-    const parentDir = dirname2(currentDir);
-    if (parentDir === currentDir) {
-      return null;
-    }
-    currentDir = parentDir;
-  }
-}
-async function getAvailablePort() {
-  return await new Promise((resolvePort, reject) => {
-    const server = createServer();
-    server.once("error", reject);
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address();
-      if (!address || typeof address === "string") {
-        server.close(() => reject(new Error("Could not determine an available port")));
-        return;
-      }
-      const { port } = address;
-      server.close((error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolvePort(port);
-      });
-    });
-  });
-}
-function resolveTransportFile(configDir, configuredPath) {
-  if (typeof configuredPath === "string") {
-    return configuredPath;
-  }
-  if (configuredPath === null) {
-    return null;
-  }
-  for (const defaultEntry of DEFAULT_TRANSPORT_ENTRY_FILES) {
-    if (existsSync2(join2(configDir, defaultEntry))) {
-      return defaultEntry;
-    }
-  }
-  return null;
-}
-
-// src/test/simple-context-durable-objects.ts
-function findExportedClasses(code) {
-  const classes = [];
-  const classPattern = /export\s+class\s+(\w+)/g;
-  let match;
-  while ((match = classPattern.exec(code)) !== null) {
-    classes.push(match[1]);
-  }
-  return classes;
-}
-function classSupportsNativeDurableObjectRpc(code, className) {
-  const nativeRpcPattern = new RegExp(`export\\s+class\\s+${className}\\s+extends\\s+DurableObject\\b`);
-  return nativeRpcPattern.test(code);
-}
-function toGeneratedIdentifier(value) {
-  const normalized = value.replace(/[^A-Za-z0-9_$]/g, "_");
-  return /^[A-Za-z_$]/.test(normalized) ? normalized : `_${normalized}`;
-}
-async function discoverLocalDurableObjectClasses(config, configDir) {
-  const classToFilePath = new Map;
-  const doPatternConfig = config.files?.durableObjects;
-  const doPattern = typeof doPatternConfig === "string" ? doPatternConfig : DEFAULT_DO_PATTERN;
-  if (doPatternConfig === false) {
-    return classToFilePath;
-  }
-  const doFiles = await findFiles(doPattern, { cwd: configDir });
-  for (const filePath of doFiles) {
-    try {
-      const code = await readFile(filePath, "utf-8");
-      const classNames = findExportedClasses(code);
-      for (const className of classNames) {
-        classToFilePath.set(className, {
-          filePath,
-          nativeRpc: classSupportsNativeDurableObjectRpc(code, className)
-        });
-      }
-    } catch {}
-  }
-  return classToFilePath;
-}
-async function resolveLocalDurableObjects(config, configDir) {
-  const doConfig = {};
-  const doInfos = [];
-  const classToFilePath = await discoverLocalDurableObjectClasses(config, configDir);
-  for (const [name, rawDoInfo] of Object.entries(config.bindings?.durableObjects ?? {})) {
-    const doInfo = normalizeDOBinding(rawDoInfo);
-    if (doInfo.__ref) {
-      continue;
-    }
-    let scriptPath;
-    let nativeRpc = false;
-    if (doInfo.scriptName) {
-      scriptPath = join3(configDir, "src", doInfo.scriptName);
-      try {
-        const code = await readFile(scriptPath, "utf-8");
-        nativeRpc = classSupportsNativeDurableObjectRpc(code, doInfo.className);
-      } catch {
-        nativeRpc = false;
-      }
-    } else {
-      const discoveredClass = classToFilePath.get(doInfo.className);
-      if (!discoveredClass) {
-        throw new Error(`Durable object ${name} (className: '${doInfo.className}') not found.
-` + `Either:
-` + `  1. Set files.durableObjects pattern in config (e.g., 'src/do.*.ts')
-` + `  2. Use explicit scriptName: { className: '${doInfo.className}', scriptName: 'do.file.ts' }`);
-      }
-      scriptPath = discoveredClass.filePath;
-      nativeRpc = discoveredClass.nativeRpc;
-    }
-    const runtimeClassName = nativeRpc ? doInfo.className : `__Devflare${toGeneratedIdentifier(name)}RpcWrapper`;
-    doConfig[name] = runtimeClassName;
-    doInfos.push({
-      name,
-      className: doInfo.className,
-      scriptPath,
-      nativeRpc,
-      runtimeClassName
-    });
-  }
-  return {
-    doConfig,
-    doInfos
-  };
-}
-function buildWrapperCode(doInfos) {
-  return doInfos.filter((info) => !info.nativeRpc).map((info) => `
-export class ${info.runtimeClassName} {
-	constructor(state, env) {
-		this.__instance = new ${info.className}(state, env)
-	}
-
-	async fetch(request) {
-		const url = new URL(request.url)
-		if (request.method !== 'POST' || url.pathname !== '/_rpc') {
-			return new Response('Not found', { status: 404 })
-		}
-
-		try {
-			const payload = await request.json()
-			const method = payload?.method
-			const params = Array.isArray(payload?.params) ? payload.params : []
-			const target = this.__instance?.[method]
-
-			if (typeof target !== 'function') {
-				return new Response(JSON.stringify({
-					ok: false,
-					error: { message: 'Method not found: ' + String(method) }
-				}), {
-					status: 404,
-					headers: { 'Content-Type': 'application/json' }
-				})
-			}
-
-			let result = await target.apply(this.__instance, params)
-			result = __encodeTransport(result)
-
-			return new Response(JSON.stringify({ ok: true, result }), {
-				headers: { 'Content-Type': 'application/json' }
-			})
-		} catch (error) {
-			return new Response(JSON.stringify({
-				ok: false,
-				error: { message: error instanceof Error ? error.message : String(error) }
-			}), {
-				status: 500,
-				headers: { 'Content-Type': 'application/json' }
-			})
-		}
-	}
-}`.trim()).join(`
-
-`);
-}
-async function bundleDurableObjectModules(configDir, doInfos, transportFile) {
-  const virtualImports = [];
-  const virtualExports = [];
-  if (transportFile) {
-    const transportPath = join3(configDir, transportFile);
-    virtualImports.push(`import { transport } from '${transportPath.replace(/\\/g, "/")}'`);
-    virtualExports.push("export { transport }");
-  }
-  for (const info of doInfos) {
-    virtualImports.push(`import { ${info.className} } from '${info.scriptPath.replace(/\\/g, "/")}'`);
-    virtualExports.push(`export { ${info.className} }`);
-  }
-  if (virtualImports.length === 0) {
-    return "";
-  }
-  const virtualEntry = [...virtualImports, "", ...virtualExports].join(`
-`);
-  const virtualPath = join3(configDir, ".devflare", "__test_entry.ts");
-  mkdirSync(dirname3(virtualPath), { recursive: true });
-  writeFileSync(virtualPath, virtualEntry);
-  const bun = getBunRuntime2();
-  if (!bun) {
-    throw new Error("Bun runtime is required for createTestContext with Durable Objects");
-  }
-  const result = await bun.build({
-    entrypoints: [virtualPath],
-    target: "browser",
-    format: "esm",
-    minify: false,
-    external: ["cloudflare:workers", "cloudflare:*"]
-  });
-  if (!result.success) {
-    throw new Error(`Failed to bundle test entry: ${result.logs.join(`
-`)}`);
-  }
-  return await result.outputs[0].text();
-}
-async function buildDurableObjectGateway(config, configDir, transportFile) {
-  if (!config.bindings?.durableObjects) {
-    return {
-      script: buildGatewayScript("", "")
-    };
-  }
-  const { doConfig, doInfos } = await resolveLocalDurableObjects(config, configDir);
-  const bundledCode = await bundleDurableObjectModules(configDir, doInfos, transportFile);
-  const wrapperCode = buildWrapperCode(doInfos);
-  return {
-    durableObjects: doConfig,
-    script: buildGatewayScript(bundledCode, wrapperCode)
-  };
-}
-
-// src/test/email.ts
-import { join as join4 } from "path";
-var miniflarePort = 8787;
-var emailListeners = [];
-var sentEmails = [];
-var emailHandlerPath = null;
-var configDir = null;
-var testEnvGetter = null;
-function configureEmail(options = {}) {
-  if (options.port) {
-    miniflarePort = options.port;
-  }
-  emailHandlerPath = options.handlerPath ?? emailHandlerPath;
-  configDir = options.configDir ?? configDir;
-  testEnvGetter = options.getEnv ?? testEnvGetter;
-}
-function buildRawEmail(options) {
-  if (options.raw) {
-    return options.raw;
-  }
-  const lines = [];
-  const messageId = `<${Date.now()}-${Math.random().toString(36).slice(2)}@devflare.dev>`;
-  const date = new Date().toUTCString();
-  lines.push(`From: ${options.from}`);
-  lines.push(`To: ${options.to}`);
-  lines.push(`Date: ${date}`);
-  lines.push(`Message-ID: ${messageId}`);
-  if (options.subject) {
-    lines.push(`Subject: ${options.subject}`);
-  }
-  if (options.headers) {
-    for (const [key, value] of Object.entries(options.headers)) {
-      lines.push(`${key}: ${value}`);
-    }
-  }
-  lines.push("MIME-Version: 1.0");
-  lines.push("Content-Type: text/plain; charset=UTF-8");
-  lines.push("");
-  lines.push(options.body ?? "");
-  return lines.join(`\r
-`);
-}
-function createEmailHeaders(rawEmail) {
-  const headers = new Headers;
-  const lines = rawEmail.split(/\r?\n/);
-  for (const line of lines) {
-    if (!line.trim()) {
-      break;
-    }
-    const colonIndex = line.indexOf(":");
-    if (colonIndex <= 0) {
-      continue;
-    }
-    headers.append(line.slice(0, colonIndex).trim(), line.slice(colonIndex + 1).trim());
-  }
-  return headers;
-}
-function createRawEmailStream(rawEmail) {
-  return new ReadableStream({
-    start(controller) {
-      controller.enqueue(new TextEncoder().encode(rawEmail));
-      controller.close();
-    }
-  });
-}
-function resolveEmailHandler(module) {
-  if (typeof module.default === "function") {
-    return module.default;
-  }
-  if (module.default && typeof module.default.email === "function") {
-    return module.default.email.bind(module.default);
-  }
-  if (typeof module.email === "function") {
-    return module.email;
-  }
-  return null;
-}
-function getRecordedRawContent(raw) {
-  if (typeof raw === "string") {
-    return raw;
-  }
-  return;
-}
-async function send(options) {
-  const raw = buildRawEmail(options);
-  if (emailHandlerPath && configDir && testEnvGetter) {
-    const absolutePath = join4(configDir, emailHandlerPath);
-    const handlerModule = await import(absolutePath);
-    const emailHandler = resolveEmailHandler(handlerModule);
-    if (!emailHandler) {
-      throw new Error(`Email handler at "${emailHandlerPath}" must export a default function or named "email" export.
-NaN`);
-    }
-    const waitUntilPromises = [];
-    const ctx = {
-      waitUntil(promise) {
-        waitUntilPromises.push(promise);
-      },
-      passThroughOnException() {},
-      props: {}
-    };
-    const runtimeEnv = testEnvGetter();
-    const timestamp = new Date;
-    const message = {
-      from: options.from,
-      to: options.to,
-      headers: createEmailHeaders(raw),
-      raw: createRawEmailStream(raw),
-      rawSize: raw.length,
-      setReject(reason) {
-        throw new Error(`Email rejected: ${reason}`);
-      },
-      async forward(rcptTo) {
-        recordSentEmail({
-          type: "forward",
-          from: options.from,
-          to: rcptTo,
-          raw,
-          timestamp
-        });
-      },
-      async reply(message2) {
-        recordSentEmail({
-          type: "reply",
-          from: message2.from ?? options.to,
-          to: message2.to ?? options.from,
-          raw: getRecordedRawContent(message2.raw),
-          timestamp
-        });
-      }
-    };
-    const emailEvent = createEmailEvent(message, runtimeEnv, ctx);
-    await runWithEventContext(emailEvent, () => emailHandler(emailEvent));
-    await Promise.all(waitUntilPromises);
-    return new Response(JSON.stringify({ ok: true, from: options.from, to: options.to }), {
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-  const url = new URL(`http://localhost:${miniflarePort}/cdn-cgi/handler/email`);
-  url.searchParams.set("from", options.from);
-  url.searchParams.set("to", options.to);
-  const response = await fetch(url.toString(), {
-    method: "POST",
-    headers: {
-      "Content-Type": "text/plain"
-    },
-    body: raw
-  });
-  return response;
-}
-function onReceive(callback) {
-  emailListeners.push(callback);
-  return () => {
-    emailListeners = emailListeners.filter((cb) => cb !== callback);
-  };
-}
-function getSentEmails() {
-  return [...sentEmails];
-}
-function clearSentEmails() {
-  sentEmails = [];
-}
-function recordSentEmail(email) {
-  sentEmails.push(email);
-  for (const listener of emailListeners) {
-    try {
-      listener(email);
-    } catch (error) {
-      console.error("[devflare/test] Email listener error:", error);
-    }
-  }
-}
-function resetEmailState() {
-  miniflarePort = 8787;
-  emailHandlerPath = null;
-  configDir = null;
-  testEnvGetter = null;
-  emailListeners = [];
-  sentEmails = [];
-}
-var email = {
-  send,
-  onReceive,
-  getSentEmails,
-  clearSentEmails
-};
-
-// src/test/queue.ts
-import { join as join5 } from "path";
-var queueHandlerPath = null;
-var configDir2 = null;
-var testEnvGetter2 = null;
-function configureQueue(options) {
-  queueHandlerPath = options.handlerPath;
-  configDir2 = options.configDir;
-  testEnvGetter2 = options.getEnv;
-}
-function resetQueueState() {
-  queueHandlerPath = null;
-  configDir2 = null;
-  testEnvGetter2 = null;
-}
-function createMessage(options) {
-  const id = options.id ?? crypto.randomUUID();
-  const timestamp = options.timestamp ?? new Date;
-  const attempts = options.attempts ?? 1;
-  let state = "pending";
-  return {
-    id,
-    timestamp,
-    body: options.body,
-    attempts,
-    ack() {
-      state = "acked";
-    },
-    retry(opts) {
-      state = "retried";
-    },
-    retryAll() {
-      state = "retried";
-    },
-    get _state() {
-      return state;
-    }
-  };
-}
-function createMessageBatch(messages) {
-  return {
-    queue: "test-queue",
-    messages,
-    ackAll() {
-      for (const msg of messages) {
-        msg.ack();
-      }
-    },
-    retryAll() {
-      for (const msg of messages) {
-        msg.retry();
-      }
-    }
-  };
-}
-async function trigger(messages) {
-  if (!queueHandlerPath) {
-    throw new Error("Queue handler not configured. Make sure your devflare.config.ts has files.queue set, " + "and the file exists at the specified path (default: src/queue.ts)");
-  }
-  if (!configDir2 || !testEnvGetter2) {
-    throw new Error("Queue helper not initialized. Call createTestContext() before using cf.queue.trigger()");
-  }
-  const absolutePath = join5(configDir2, queueHandlerPath);
-  const handlerModule = await import(absolutePath);
-  const queueHandler = handlerModule.default ?? handlerModule.queue;
-  if (typeof queueHandler !== "function") {
-    throw new Error(`Queue handler at "${queueHandlerPath}" must export a default function or named "queue" export.
-NaN`);
-  }
-  const normalizedMessages = messages.map((msg) => {
-    if (typeof msg === "object" && msg !== null && "body" in msg) {
-      return msg;
-    }
-    return { body: msg };
-  });
-  const mockMessages = normalizedMessages.map((opts) => createMessage(opts));
-  const batch = createMessageBatch(mockMessages);
-  const waitUntilPromises = [];
-  const ctx = {
-    waitUntil(promise) {
-      waitUntilPromises.push(promise);
-    },
-    passThroughOnException() {},
-    props: {}
-  };
-  const env = testEnvGetter2();
-  const queueEvent = createQueueEvent(batch, env, ctx);
-  await runWithEventContext(queueEvent, () => queueHandler(queueEvent));
-  await Promise.all(waitUntilPromises);
-  const acked = [];
-  const retried = [];
-  const failed = [];
-  for (const msg of mockMessages) {
-    switch (msg._state) {
-      case "acked":
-        acked.push(msg.id);
-        break;
-      case "retried":
-        retried.push(msg.id);
-        break;
-      case "failed":
-        failed.push(msg.id);
-        break;
-    }
-  }
-  return {
-    acked,
-    retried,
-    failed,
-    total: mockMessages.length
-  };
-}
-async function send2(message) {
-  return trigger([message]);
-}
-var queue = {
-  trigger,
-  send: send2
-};
-
-// src/test/scheduled.ts
-import { join as join6 } from "path";
-var scheduledHandlerPath = null;
-var configDir3 = null;
-var testEnvGetter3 = null;
-function configureScheduled(options) {
-  scheduledHandlerPath = options.handlerPath;
-  configDir3 = options.configDir;
-  testEnvGetter3 = options.getEnv;
-}
-function resetScheduledState() {
-  scheduledHandlerPath = null;
-  configDir3 = null;
-  testEnvGetter3 = null;
-}
-async function trigger2(cronOrOptions) {
-  if (!scheduledHandlerPath) {
-    throw new Error("Scheduled handler not configured. Make sure your devflare.config.ts has files.scheduled set, " + "and the file exists at the specified path (default: src/scheduled.ts)");
-  }
-  if (!configDir3 || !testEnvGetter3) {
-    throw new Error("Scheduled helper not initialized. Call createTestContext() before using cf.scheduled.trigger()");
-  }
-  const options = typeof cronOrOptions === "string" ? { cron: cronOrOptions } : cronOrOptions ?? {};
-  const cron = options.cron ?? "* * * * *";
-  const scheduledTime = options.scheduledTime instanceof Date ? options.scheduledTime.getTime() : options.scheduledTime ?? Date.now();
-  const absolutePath = join6(configDir3, scheduledHandlerPath);
-  const handlerModule = await import(absolutePath);
-  const scheduledHandler = handlerModule.default ?? handlerModule.scheduled;
-  if (typeof scheduledHandler !== "function") {
-    throw new Error(`Scheduled handler at "${scheduledHandlerPath}" must export a default function or named "scheduled" export.
-NaN`);
-  }
-  const controller = {
-    scheduledTime,
-    cron,
-    noRetry() {}
-  };
-  const waitUntilPromises = [];
-  const ctx = {
-    waitUntil(promise) {
-      waitUntilPromises.push(promise);
-    },
-    passThroughOnException() {},
-    props: {}
-  };
-  const env = testEnvGetter3();
-  const scheduledEvent = createScheduledEvent(controller, env, ctx);
-  try {
-    await runWithEventContext(scheduledEvent, () => scheduledHandler(scheduledEvent));
-    await Promise.all(waitUntilPromises);
-    return {
-      success: true,
-      cron,
-      scheduledTime
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error),
-      cron,
-      scheduledTime
-    };
-  }
-}
-var scheduled = {
-  trigger: trigger2
-};
-
-// src/test/tail.ts
-import { join as join7 } from "path";
-var tailHandlerPath = null;
-var configDir4 = null;
-var testEnvGetter4 = null;
-function configureTail(options) {
-  tailHandlerPath = options.handlerPath;
-  configDir4 = options.configDir;
-  testEnvGetter4 = options.getEnv;
-}
-function resetTailState() {
-  tailHandlerPath = null;
-  configDir4 = null;
-  testEnvGetter4 = null;
-}
-function createTraceItem(options) {
-  return {
-    scriptName: options.scriptName ?? "test-worker",
-    outcome: options.outcome ?? "ok",
-    eventTimestamp: options.eventTimestamp ?? Date.now(),
-    event: options.event ?? {
-      request: {
-        url: "https://example.com/",
-        method: "GET"
-      }
-    },
-    logs: options.logs ?? [],
-    exceptions: options.exceptions ?? [],
-    diagnosticsChannelEvents: options.diagnosticsChannelEvents ?? [],
-    scriptVersion: options.scriptVersion ?? { id: "test-version" },
-    dispatchNamespace: options.dispatchNamespace,
-    scriptTags: options.scriptTags ?? []
-  };
-}
-async function trigger3(items) {
-  if (!tailHandlerPath) {
-    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()");
-  }
-  const traceItems = items.map((item) => {
-    if ("eventTimestamp" in item && "outcome" in item && "scriptName" in item) {
-      return item;
-    }
-    return createTraceItem(item);
-  });
-  const absolutePath = join7(configDir4, tailHandlerPath);
-  const handlerModule = await import(absolutePath);
-  const tailHandler = handlerModule.default ?? handlerModule.tail;
-  if (typeof tailHandler !== "function") {
-    throw new Error(`Tail handler at "${tailHandlerPath}" must export a default function or named "tail" export.
-NaN`);
-  }
-  const waitUntilPromises = [];
-  const ctx = {
-    waitUntil(promise) {
-      waitUntilPromises.push(promise);
-    },
-    passThroughOnException() {},
-    props: {}
-  };
-  const env = testEnvGetter4();
-  const tailEvent = createTailEvent(traceItems, env, ctx);
-  try {
-    await runWithEventContext(tailEvent, () => tailHandler(tailEvent));
-    await Promise.all(waitUntilPromises);
-    return {
-      success: true,
-      itemCount: traceItems.length
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error),
-      itemCount: traceItems.length
-    };
-  }
-}
-function create(options = {}) {
-  return createTraceItem(options);
-}
-var tail = {
-  trigger: trigger3,
-  create
-};
-
-// src/test/worker.ts
-import { join as join8 } from "path";
-var fetchHandlerPath = null;
-var configDir5 = null;
-var testEnvGetter5 = null;
-var fileRoutes = [];
-function configureWorker(options) {
-  fetchHandlerPath = options.handlerPath;
-  fileRoutes = options.routes ?? [];
-  configDir5 = options.configDir;
-  testEnvGetter5 = options.getEnv;
-}
-function resetWorkerState() {
-  fetchHandlerPath = null;
-  fileRoutes = [];
-  configDir5 = null;
-  testEnvGetter5 = null;
-}
-async function fetch2(request, options) {
-  if (!fetchHandlerPath && fileRoutes.length === 0) {
-    throw new Error("Fetch handler not configured. Make sure your devflare.config.ts has files.fetch set or a routes directory is available, " + "and that the corresponding files exist (defaults: src/fetch.ts and src/routes/**).");
-  }
-  if (!configDir5 || !testEnvGetter5) {
-    throw new Error("Worker helper not initialized. Call createTestContext() before using cf.worker.fetch()");
-  }
-  const workerConfigDir = configDir5;
-  const getEnv = testEnvGetter5;
-  let req;
-  if (typeof request === "string") {
-    const url = request.startsWith("http") ? request : `http://localhost${request.startsWith("/") ? "" : "/"}${request}`;
-    const headers = new Headers(options?.headers);
-    let body;
-    if (options?.body !== undefined) {
-      if (typeof options.body === "string") {
-        body = options.body;
-      } else {
-        body = JSON.stringify(options.body);
-        if (!headers.has("Content-Type")) {
-          headers.set("Content-Type", "application/json");
-        }
-      }
-    }
-    req = new Request(url, {
-      method: options?.method ?? "GET",
-      headers,
-      body
-    });
-  } else {
-    req = request;
-  }
-  const handlerModule = fetchHandlerPath ? await import(join8(workerConfigDir, fetchHandlerPath)) : {};
-  const routeModules = await Promise.all(fileRoutes.map(async (route) => {
-    return {
-      ...route,
-      module: await import(join8(workerConfigDir, route.filePath))
-    };
-  }));
-  const methodExports = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "ALL"];
-  const hasMethodHandler = methodExports.some((method) => {
-    return typeof handlerModule[method] === "function" || typeof handlerModule.default?.[method] === "function";
-  });
-  if (!resolveFetchHandler(handlerModule) && !hasMethodHandler && routeModules.length === 0) {
-    throw new Error(`Fetch handler at "${fetchHandlerPath}" must export one of:
-- request-wide "handle" middleware
-- named "fetch"
-- default fetch handler
-- HTTP method exports such as "GET" or "POST"`);
-  }
-  const waitUntilPromises = [];
-  const ctx = {
-    waitUntil(promise) {
-      waitUntilPromises.push(promise);
-    },
-    passThroughOnException() {},
-    props: {}
-  };
-  const env = getEnv();
-  const initialRouteMatch = routeModules.length > 0 ? matchFetchRoute(routeModules, req) : null;
-  const fetchEvent = createFetchEvent(req, env, ctx, {
-    params: initialRouteMatch?.params ?? {}
-  });
-  const response = await runWithEventContext(fetchEvent, () => invokeFetchModule(handlerModule, fetchEvent, routeModules.length > 0 ? createRouteResolve(routeModules, fetchEvent) : undefined));
-  return response;
-}
-async function get(path, headers) {
-  return fetch2(path, { method: "GET", headers });
-}
-async function post(path, body, headers) {
-  return fetch2(path, { method: "POST", body, headers });
-}
-async function put(path, body, headers) {
-  return fetch2(path, { method: "PUT", body, headers });
-}
-async function del(path, headers) {
-  return fetch2(path, { method: "DELETE", headers });
-}
-async function patch(path, body, headers) {
-  return fetch2(path, { method: "PATCH", body, headers });
-}
-var worker = {
-  fetch: fetch2,
-  get,
-  post,
-  put,
-  delete: del,
-  patch
-};
-
-// src/test/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";
-}
-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({
-        ...mfConfig,
-        port
-      });
-      await miniflare.ready;
-      const miniflareBindings = wrapEnvSendEmailBindings(await miniflare.getBindings());
-      client = await connectBridgeClientWithRetry(`ws://localhost:${port}`);
-      return {
-        port,
-        client,
-        miniflare,
-        miniflareBindings
-      };
-    } catch (error) {
-      client?.disconnect();
-      if (miniflare) {
-        try {
-          await miniflare.dispose();
-        } catch {}
-      }
-      if (attempt >= TEST_CONTEXT_STARTUP_RETRY_ATTEMPTS || !isRetriableTestContextStartupError(error)) {
-        throw error;
-      }
-      await waitForTestContextStartupRetry();
-    }
-  }
-  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;
-  }
-  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);
-      }
-    }
-  }
-  if (config.vars) {
-    for (const [key, value] of Object.entries(config.vars)) {
-      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)) {
-      hints[name] = "kv";
-    }
-  }
-  if (config.bindings?.r2) {
-    for (const name of Object.keys(config.bindings.r2)) {
-      hints[name] = "r2";
-    }
-  }
-  if (config.bindings?.d1) {
-    for (const name of Object.keys(config.bindings.d1)) {
-      hints[name] = "d1";
-    }
-  }
-  if (config.bindings?.durableObjects) {
-    for (const name of Object.keys(config.bindings.durableObjects)) {
-      hints[name] = "do";
-    }
-  }
-  if (config.bindings?.services) {
-    for (const name of Object.keys(config.bindings.services)) {
-      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, configDir6);
-  }
-  if (needsMultiWorkerForDOs) {
-    doBindingResolution = await resolveDOBindings(config, configDir6);
-  }
-  const localWorkerBindings = config.vars ?? {};
-  const mfConfig = {
-    modules: true
-  };
-  if (config.bindings?.kv) {
-    mfConfig.kvNamespaces = Object.keys(config.bindings.kv);
-  }
-  if (config.bindings?.r2) {
-    mfConfig.r2Buckets = Object.keys(config.bindings.r2);
-  }
-  if (config.bindings?.d1) {
-    mfConfig.d1Databases = Object.fromEntries(Object.entries(config.bindings.d1).map(([bindingName, bindingConfig]) => {
-      return [bindingName, getLocalD1DatabaseIdentifier(bindingConfig)];
-    }));
-  }
-  if (config.bindings?.queues?.producers) {
-    const queueProducers = {};
-    for (const [bindingName, queueName] of Object.entries(config.bindings.queues.producers)) {
-      queueProducers[bindingName] = { queueName };
-    }
-    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 = 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);
-      }
-    }
-  }
-  const gateway = await buildDurableObjectGateway(config, configDir6, transportFile);
-  mfConfig.script = gateway.script;
-  if (gateway.durableObjects) {
-    mfConfig.durableObjects = gateway.durableObjects;
-  }
-  const hasMultiWorkerServices = serviceBindingResolution && serviceBindingResolution.workers.length > 0;
-  const hasMultiWorkerDOs = doBindingResolution && doBindingResolution.workers.length > 0;
-  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();
-  };
-  const getTestEnv = () => {
-    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 = 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
-    })) ?? [],
-    configDir: configDir6,
-    getEnv: getTestEnv
-  });
-  configureTail({
-    handlerPath: resolvedTailPath,
-    configDir: configDir6,
-    getEnv: getTestEnv
-  });
-  configureEmail({
-    port: activePort,
-    handlerPath: resolvedEmailPath,
-    configDir: configDir6,
-    getEnv: getTestEnv
-  });
-  if (hasMultiWorkerServices || hasMultiWorkerDOs) {
-    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);
-    return;
-  }
-  const bridgeClient = globalClient;
-  if (!bridgeClient) {
-    throw new Error("Bridge-backed test context did not initialize a client.");
-  }
-  setBindingHints(hints);
-  globalEnvProxy = 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;
-}
-// src/test/cf.ts
-var cf = {
-  email,
-  queue,
-  scheduled,
-  worker,
-  tail
-};
-// src/test/should-skip.ts
-var REMOTE_ONLY_SERVICES = new Set([
-  "ai",
-  "vectorize"
-]);
-var skipResults = new Map;
-var EXPECTED_ERROR_PATTERNS = [
-  "ECONNREFUSED",
-  "ETIMEDOUT",
-  "ENOTFOUND",
-  "fetch failed",
-  "network",
-  "401",
-  "403",
-  "429",
-  "500",
-  "502",
-  "503",
-  "504",
-  "rate limit",
-  "unauthorized",
-  "forbidden",
-  "timeout"
-];
-function isExpectedError(error) {
-  if (!(error instanceof Error))
-    return false;
-  const msg = error.message.toLowerCase();
-  return EXPECTED_ERROR_PATTERNS.some((pattern) => msg.includes(pattern.toLowerCase()));
-}
-async function computeSkip(service) {
-  try {
-    if (REMOTE_ONLY_SERVICES.has(service) && !isRemoteModeActive()) {
-      const status = getRemoteModeStatus();
-      console.log(`⏭️  ${service.toUpperCase()} tests skipped: Remote-only service.
-` + `   Enable with: ${status.isEnabled ? "" : "devflare remote enable"}
-` + `   Or set: DEVFLARE_REMOTE=1
-` + `   See: https://github.com/ArthurvdVenne/devflare#remote-testing`);
-      return true;
-    }
-    const isAuth = await isAuthenticated();
-    if (!isAuth) {
-      console.log(`⏭️  ${service.toUpperCase()} tests skipped: Not authenticated. Run: bunx wrangler login
-` + `   See: https://github.com/ArthurvdVenne/devflare#authentication`);
-      return true;
-    }
-    const primary = await getPrimaryAccount();
-    if (!primary) {
-      console.log(`⏭️  ${service.toUpperCase()} tests skipped: No Cloudflare account found
-` + `   See: https://github.com/ArthurvdVenne/devflare#authentication`);
-      return true;
-    }
-    const { accountId } = await getEffectiveAccountId(primary.id);
-    try {
-      const { allowed, reason } = await canProceedWithTest(accountId, service);
-      if (!allowed) {
-        console.log(`⏭️  ${service.toUpperCase()} tests skipped: ${reason}`);
-        return true;
-      }
-    } catch {}
-    return false;
-  } catch (error) {
-    if (isExpectedError(error)) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      console.log(`⏭️  ${service.toUpperCase()} tests skipped: ${message}`);
-      return true;
-    }
-    throw error;
-  }
-}
-function getSkipResult(service) {
-  let result = skipResults.get(service);
-  if (!result) {
-    result = computeSkip(service);
-    skipResults.set(service, result);
-  }
-  return result;
-}
-var shouldSkip = {
-  get ai() {
-    return getSkipResult("ai");
-  },
-  get vectorize() {
-    return getSkipResult("vectorize");
-  },
-  get workers() {
-    return getSkipResult("workers");
-  },
-  get kv() {
-    return getSkipResult("kv");
-  },
-  get d1() {
-    return getSkipResult("d1");
-  },
-  get r2() {
-    return getSkipResult("r2");
-  },
-  get queues() {
-    return getSkipResult("queues");
-  },
-  get durableObjects() {
-    return getSkipResult("durable_objects");
-  }
-};
-// src/test/utilities.ts
-function createMockTestContext(options = {}) {
-  const waitUntilPromises = [];
-  const ctx = {
-    waitUntil(promise) {
-      waitUntilPromises.push(promise);
-    },
-    passThroughOnException() {},
-    props: {}
-  };
-  return {
-    env: options.env ?? {},
-    ctx,
-    request: options.request ?? null,
-    waitUntilPromises
-  };
-}
-async function withTestContext(options, handler) {
-  const testCtx = createMockTestContext(options);
-  return runWithContext(testCtx.env, testCtx.ctx, options.request ?? null, handler, options.type ?? "fetch");
-}
-function createMockKV(initialData = {}) {
-  const store = new Map(Object.entries(initialData));
-  const metadata = new Map;
-  return {
-    async get(key, options) {
-      const value = store.get(key);
-      if (value === null || value === 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;
-      }
-    },
-    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 delete(key) {
-      store.delete(key);
-    },
-    async list(options) {
-      const prefix = options?.prefix ?? "";
-      const limit = options?.limit ?? 1000;
-      const keys = Array.from(store.keys()).filter((key) => key.startsWith(prefix)).slice(0, limit).map((name) => ({ name }));
-      return {
-        keys,
-        list_complete: keys.length < limit,
-        cursor: undefined
-      };
-    },
-    async getWithMetadata(key, options) {
-      return {
-        value: store.get(key) ?? null,
-        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));
-    }
-  });
-  return {
-    prepare(query) {
-      return createStatement();
-    },
-    async exec(query) {
-      return {
-        results: [],
-        success: true,
-        meta: { duration: 0, changes: 0, last_row_id: 0 }
-      };
-    },
-    async batch(statements) {
-      return statements.map(() => ({
-        results: [],
-        success: true,
-        meta: { duration: 0, changes: 0, last_row_id: 0 }
-      }));
-    },
-    async dump() {
-      return new ArrayBuffer(0);
-    },
-    withSession(constraintOrBookmark) {
-      return this;
-    }
-  };
-}
-function createMockR2() {
-  const store = new Map;
-  const createR2Object = (key, content, metadata) => {
-    const encoder = new TextEncoder;
-    const data = encoder.encode(content);
-    return {
-      key,
-      version: "1",
-      size: data.length,
-      etag: `"${key}-etag"`,
-      httpEtag: `"${key}-etag"`,
-      uploaded: new Date,
-      httpMetadata: metadata ?? {},
-      customMetadata: {},
-      checksums: {},
-      storageClass: "Standard",
-      body: new ReadableStream({
-        start(controller) {
-          controller.enqueue(data);
-          controller.close();
-        }
-      }),
-      bodyUsed: false,
-      async arrayBuffer() {
-        return new Uint8Array(data).buffer;
-      },
-      async text() {
-        return content;
-      },
-      async json() {
-        return JSON.parse(content);
-      },
-      async blob() {
-        return new Blob([data]);
-      },
-      writeHttpMetadata(headers) {}
-    };
-  };
-  return {
-    async put(key, value, options) {
-      let content;
-      if (typeof value === "string") {
-        content = value;
-      } else if (value instanceof ArrayBuffer) {
-        content = new TextDecoder().decode(value);
-      } else if (value instanceof Blob) {
-        content = await value.text();
-      } else if (value === null) {
-        content = "";
-      } 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(new TextDecoder().decode(result.value));
-          }
-        }
-        content = chunks.join("");
-      }
-      store.set(key, { content });
-      return createR2Object(key, content);
-    },
-    async get(key, options) {
-      const item = store.get(key);
-      if (!item)
-        return null;
-      return createR2Object(key, item.content, item.metadata);
-    },
-    async head(key) {
-      const item = store.get(key);
-      if (!item)
-        return null;
-      return {
-        key,
-        version: "1",
-        size: new TextEncoder().encode(item.content).length,
-        etag: `"${key}-etag"`,
-        httpEtag: `"${key}-etag"`,
-        uploaded: new Date,
-        httpMetadata: item.metadata ?? {},
-        customMetadata: {},
-        checksums: {},
-        storageClass: "Standard",
-        writeHttpMetadata(headers) {}
-      };
-    },
-    async delete(keys) {
-      const keyArray = Array.isArray(keys) ? keys : [keys];
-      for (const key of keyArray) {
-        store.delete(key);
-      }
-    },
-    async list(options) {
-      const objects = Array.from(store.entries()).map(([key, { content, metadata }]) => createR2Object(key, content, metadata));
-      return {
-        objects,
-        truncated: false,
-        delimitedPrefixes: []
-      };
-    },
-    async createMultipartUpload(key, options) {
-      throw new Error("Multipart upload not implemented in mock");
-    },
-    async resumeMultipartUpload(key, uploadId) {
-      throw new Error("Multipart upload not implemented in mock");
-    }
-  };
-}
-function createMockQueue() {
-  const messages = [];
-  return {
-    async send(message, options) {
-      messages.push({ body: message, options });
-    },
-    async sendBatch(batch) {
-      messages.push(...batch);
-    },
-    _getMessages() {
-      return messages;
-    }
-  };
-}
-function createMockEnv(options = {}) {
-  const env2 = {};
-  if (options.kv) {
-    for (const name of options.kv) {
-      env2[name] = createMockKV();
-    }
-  }
-  if (options.d1) {
-    for (const name of options.d1) {
-      env2[name] = createMockD1();
-    }
-  }
-  if (options.r2) {
-    for (const name of options.r2) {
-      env2[name] = createMockR2();
-    }
-  }
-  if (options.queues) {
-    for (const name of options.queues) {
-      env2[name] = createMockQueue();
-    }
-  }
-  if (options.vars) {
-    Object.assign(env2, options.vars);
-  }
-  if (options.secrets) {
-    Object.assign(env2, options.secrets);
-  }
-  if (options.custom) {
-    Object.assign(env2, options.custom);
-  }
-  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 };