devflare 1.0.0-next.2 → 1.0.0-next.21

package/dist/test/index.js

@@ -1,71 +1,4623 @@
 import {
-  cf,
+  getRemoteModeStatus,
+  isRemoteModeActive
+} from "../index-d8bdkx2h.js";
+import {
+  canProceedWithTest
+} from "../index-15fpa5tx.js";
+import {
+  bundleWorkflowEntrypointScript
+} from "../index-bj5avaba.js";
+import"../index-666tdx14.js";
+import {
+  createRouteResolve,
+  invokeFetchModule,
+  matchFetchRoute,
+  resolveFetchHandler
+} from "../index-f1yshy4s.js";
+import {
+  __clearTestContext,
+  __setTestContext,
+  env
+} from "../index-nxkesg55.js";
+import"../index-a855bdsx.js";
+import {
+  buildHyperdrivesConfig,
   clearBundleCache,
-  createBridgeTestContext,
-  createEntrypointScript,
-  createMockD1,
-  createMockEnv,
-  createMockKV,
-  createMockQueue,
-  createMockR2,
-  createMockTestContext,
-  createMultiWorkerContext,
-  createTestContext,
-  email,
-  env,
-  getBridgeTestContext,
+  discoverRoutes,
   hasCrossWorkerDOs,
   hasServiceBindings,
-  isRemoteModeEnabled,
-  queue,
   resolveDOBindings,
-  resolveServiceBindings,
+  resolveServiceBindings
+} from "../index-p7q23nce.js";
+import"../index-3edvz3hs.js";
+import {
+  DEFAULT_DO_PATTERN,
+  findFiles
+} from "../index-qwgr4q7s.js";
+import"../index-aqrwyy57.js";
+import"../index-vhqww6tt.js";
+import {
+  createLocalWorkerLoaderBinding,
+  disposeLocalWorkerLoaderBindings,
+  extractBindingHints
+} from "../index-y59hnmd0.js";
+import {
+  buildLocalBindingShimServiceConfig
+} from "../index-dm9q84c7.js";
+import {
+  buildLocalSecretWrappedBindingConfig,
+  resolveLocalSecretValuesForBindings
+} from "../index-hn5nbxbt.js";
+import {
+  BridgeClient,
+  createEmailEvent,
+  createEnvProxy,
+  createFetchEvent,
+  createQueueEvent,
+  createScheduledEvent,
+  createTailEvent,
+  runWithContext,
+  runWithEventContext,
+  setBindingHints
+} from "../index-tknbyxzn.js";
+import {
+  createLocalSendEmailBinding,
+  wrapEnvSendEmailBindings
+} from "../index-hpwa6vsw.js";
+import {
+  applyLocalDevVarsToConfig
+} from "../index-c3nxftnp.js";
+import {
+  getLocalD1DatabaseIdentifier,
+  loadConfig,
+  normalizeArtifactsBinding,
+  normalizeDOBinding,
+  normalizeDispatchNamespaceBinding,
+  normalizeHyperdriveBinding,
+  normalizeImagesBinding,
+  normalizeMediaBinding,
+  normalizeMtlsCertificateBinding,
+  normalizePipelineBinding,
+  normalizeSecretsStoreBinding,
+  normalizeWorkflowBinding,
+  resolveConfigPath
+} from "../index-syscwrjp.js";
+import {
+  getEffectiveAccountId,
+  getPrimaryAccount
+} from "../index-1d4jg11n.js";
+import {
+  getApiToken,
+  isAuthenticated
+} from "../index-mg8vwqxf.js";
+import"../index-z40mjts9.js";
+import"../index-q8f4kawk.js";
+import {
+  __require
+} from "../index-37x76zdn.js";
+
+// src/test/simple-context-durable-objects.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { readFile } from "fs/promises";
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/test/simple-context-gateway-script.ts
+function buildGatewayScript(bundledCode, wrappers, nativeRpcBindingNames = []) {
+  const nativeRpcBindingsLiteral = JSON.stringify(nativeRpcBindingNames);
+  return `
+// Bundled transport + DO classes
+${bundledCode}
+
+// DO Wrappers with RPC
+${wrappers}
+
+const __nativeRpcBindings = new Set(${nativeRpcBindingsLiteral})
+
+// 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('.')
+	let op = rest.join('.')
+	const binding = env[bindingName]
+	const RAW_EMAIL = 'EmailMessage::raw'
+	if (!binding) throw new Error('Binding not found: ' + bindingName)
+
+	// Normalize namespaced op names (kv.*, r2.*, d1.*, do.*, queue.*, ai.*, var.*)
+	// down to the legacy verbs this dispatcher historically used. The bridge
+	// proxy always emits namespaced forms (see src/bridge/proxy.ts and B3 in
+	// REMAINING.md); this keeps the dispatcher backwards-compatible while the
+	// rest of the codebase converges on the namespaced convention.
+	if (op.indexOf('kv.') === 0) op = op.slice(3)
+	else if (op.indexOf('do.') === 0) {
+		const tail = op.slice(3)
+		if (tail === 'fetch') op = 'stub.fetch'
+		else if (tail === 'rpc') op = 'stub.rpc'
+		else op = tail
+	}
+	else if (op.indexOf('queue.') === 0) op = op.slice(6)
+	else if (op.indexOf('ai.') === 0) op = op.slice(3)
+	else if (op.indexOf('var.') === 0) op = op.slice(4)
+	else if (op.indexOf('d1.stmt.') === 0) op = 'prepare.' + op.slice('d1.stmt.'.length)
+	else if (op.indexOf('d1.') === 0) op = op.slice(3)
+	// r2.* and email.* keep their existing prefixes
+
+	// KV operations
+	if (op === 'get') return binding.get(params[0], params[1])
+	if (op === 'put') return binding.put(params[0], params[1], params[2])
+	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 === 'r2.head' || 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 (__nativeRpcBindings.has(bindingName) && 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 } from "fs";
+import { createServer } from "net";
+import { dirname, join } 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(dirname(fileURLToPath(import.meta.url)));
+function getBunRuntime() {
+  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("[") && existsSync(filename)) {
+        return dirname(filename);
+      }
+    }
+  } finally {
+    Error.prepareStackTrace = originalPrepare;
+  }
+  return null;
+}
+function findPackageRoot(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    if (existsSync(join(currentDir, "package.json"))) {
+      return currentDir;
+    }
+    const parentDir = dirname(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 = dirname(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 (existsSync(join(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.kind === "cross-worker" && doInfo.scriptName) {
+      scriptPath = join2(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 = join2(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 = join2(configDir, ".devflare", "__test_entry.ts");
+  mkdirSync(dirname2(virtualPath), { recursive: true });
+  writeFileSync(virtualPath, virtualEntry);
+  const bun = getBunRuntime();
+  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) {
+  const workflowEntrypointScript = await bundleWorkflowEntrypointScript(config, configDir);
+  if (!config.bindings?.durableObjects) {
+    return {
+      script: buildGatewayScript(workflowEntrypointScript, "")
+    };
+  }
+  const { doConfig, doInfos } = await resolveLocalDurableObjects(config, configDir);
+  const bundledCode = await bundleDurableObjectModules(configDir, doInfos, transportFile);
+  const wrapperCode = buildWrapperCode(doInfos);
+  const entrypointCode = [workflowEntrypointScript, bundledCode].filter(Boolean).join(`
+
+`);
+  const nativeRpcBindingNames = doInfos.filter((info) => info.nativeRpc).map((info) => info.name);
+  return {
+    durableObjects: doConfig,
+    script: buildGatewayScript(entrypointCode, wrapperCode, nativeRpcBindingNames)
+  };
+}
+
+// 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 encodePathSegment(value) {
+  return encodeURIComponent(value);
+}
+function applyExtraHeaders(headers, extraHeaders) {
+  if (!extraHeaders) {
+    return;
+  }
+  for (const [key, value] of Object.entries(extraHeaders)) {
+    headers.set(key, String(value));
+  }
+}
+function createRemoteAIGateway(cloudflare, gatewayId, owner) {
+  const encodedGatewayId = encodePathSegment(gatewayId);
+  const gateway = {
+    async patchLog(logId, data) {
+      await cloudflare.jsonRequest({
+        method: "PATCH",
+        path: `/ai-gateway/gateways/${encodedGatewayId}/logs/${encodePathSegment(logId)}`,
+        serviceLabel: "AI Gateway",
+        body: JSON.stringify(data)
+      });
+    },
+    async getLog(logId) {
+      return cloudflare.jsonRequest({
+        method: "GET",
+        path: `/ai-gateway/gateways/${encodedGatewayId}/logs/${encodePathSegment(logId)}`,
+        serviceLabel: "AI Gateway"
+      });
+    },
+    async getUrl(provider) {
+      const accountId = await cloudflare.getAccountId();
+      const baseUrl = `https://gateway.ai.cloudflare.com/v1/${encodePathSegment(accountId)}/${encodedGatewayId}`;
+      return provider ? `${baseUrl}/${encodePathSegment(provider)}` : `${baseUrl}/`;
+    },
+    async run(data, options) {
+      const [url, token] = await Promise.all([gateway.getUrl(), cloudflare.getToken()]);
+      const headers = new Headers({
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      });
+      applyExtraHeaders(headers, options?.extraHeaders);
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(data),
+        signal: options?.signal
+      });
+      const logId = response.headers.get("cf-aig-log-id") ?? response.headers.get("cf-ai-gateway-log-id");
+      if (logId) {
+        owner.aiGatewayLogId = logId;
+      }
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`AI Gateway API error (${response.status}): ${errorText}`);
+      }
+      return response;
+    }
+  };
+  return gateway;
+}
+function createRemoteAI(accountId) {
+  const cloudflare = createRemoteCloudflareClient(accountId);
+  const ai = {
+    aiGatewayLogId: null,
+    async run(model, inputs) {
+      return cloudflare.jsonRequest({
+        method: "POST",
+        path: `/ai/run/${model}`,
+        serviceLabel: "AI",
+        body: JSON.stringify(inputs)
+      });
+    },
+    gateway(gatewayId) {
+      return createRemoteAIGateway(cloudflare, gatewayId, 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/utilities/context.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");
+}
+// src/test/utilities/kv.ts
+function createMockKV(initialData = {}) {
+  const store = new Map;
+  const metadata = new Map;
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  for (const [key, value] of Object.entries(initialData)) {
+    store.set(key, encoder.encode(value));
+  }
+  const toBytes = async (value) => {
+    if (typeof value === "string") {
+      return encoder.encode(value);
+    }
+    if (value instanceof ArrayBuffer) {
+      return new Uint8Array(value.slice(0));
+    }
+    if (ArrayBuffer.isView(value)) {
+      const view = value;
+      const copy = new Uint8Array(view.byteLength);
+      copy.set(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+      return copy;
+    }
+    const reader = value.getReader();
+    const chunks = [];
+    let total = 0;
+    while (true) {
+      const result = await reader.read();
+      if (result.done)
+        break;
+      if (result.value) {
+        const chunk = result.value instanceof Uint8Array ? result.value : new Uint8Array(result.value);
+        chunks.push(chunk);
+        total += chunk.length;
+      }
+    }
+    const combined = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      combined.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return combined;
+  };
+  const decodeBytes = (bytes, type) => {
+    switch (type) {
+      case "json":
+        return JSON.parse(decoder.decode(bytes));
+      case "arrayBuffer": {
+        const copy = new Uint8Array(bytes.length);
+        copy.set(bytes);
+        return copy.buffer;
+      }
+      case "stream": {
+        const copy = new Uint8Array(bytes.length);
+        copy.set(bytes);
+        return new ReadableStream({
+          start(controller) {
+            controller.enqueue(copy);
+            controller.close();
+          }
+        });
+      }
+      default:
+        return decoder.decode(bytes);
+    }
+  };
+  const resolveType = (options) => {
+    const type = typeof options === "string" ? options : options?.type ?? "text";
+    return type;
+  };
+  return {
+    async get(key, options) {
+      const bytes = store.get(key);
+      if (bytes === undefined)
+        return null;
+      return decodeBytes(bytes, resolveType(options));
+    },
+    async put(key, value, _options) {
+      const bytes = await toBytes(value);
+      store.set(key, bytes);
+    },
+    async delete(key) {
+      store.delete(key);
+      metadata.delete(key);
+    },
+    async list(options) {
+      const prefix = options?.prefix ?? "";
+      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) {
+      const bytes = store.get(key);
+      return {
+        value: bytes === undefined ? null : decodeBytes(bytes, resolveType(options)),
+        metadata: metadata.get(key) ?? null
+      };
+    }
+  };
+}
+// src/test/utilities/d1.ts
+var TABLE_NAME_RE = /(?:from|into|update)\s+["'`]?([a-zA-Z_][a-zA-Z0-9_]*)["'`]?/i;
+var extractTable = (sql) => {
+  const match = TABLE_NAME_RE.exec(sql);
+  return match ? match[1] : null;
+};
+var detectOp = (sql) => {
+  const trimmed = sql.trimStart().toLowerCase();
+  if (trimmed.startsWith("select"))
+    return "select";
+  if (trimmed.startsWith("insert"))
+    return "insert";
+  if (trimmed.startsWith("update"))
+    return "update";
+  if (trimmed.startsWith("delete"))
+    return "delete";
+  return "other";
+};
+function createMockD1(mockResultsOrOptions = []) {
+  const options = Array.isArray(mockResultsOrOptions) ? { results: mockResultsOrOptions } : mockResultsOrOptions;
+  const tables = new Map;
+  for (const [name, rows] of Object.entries(options.fixtures ?? {})) {
+    tables.set(name, [...rows]);
+  }
+  const fallback = options.results ?? [];
+  const resolveRows = (sql) => {
+    const op = detectOp(sql);
+    const table = extractTable(sql);
+    if (table && tables.has(table)) {
+      return { rows: tables.get(table) ?? [], op, table };
+    }
+    return { rows: [...fallback], op, table };
+  };
+  const createStatement = (sql) => {
+    let boundValues = [];
+    const statement = {
+      bind(...values) {
+        boundValues = values;
+        return statement;
+      },
+      async first(column) {
+        const { rows } = resolveRows(sql);
+        const row = rows[0];
+        if (!row)
+          return null;
+        if (column)
+          return row[column];
+        return row;
+      },
+      async all() {
+        const { rows } = resolveRows(sql);
+        return {
+          results: rows,
+          success: true,
+          meta: { duration: 0, changes: 0, last_row_id: 0 }
+        };
+      },
+      async run() {
+        const { op, table } = resolveRows(sql);
+        let changes = 0;
+        let lastRowId = 0;
+        if (op === "insert" && table) {
+          const rows = tables.get(table) ?? [];
+          const bound = boundValues.length > 0 ? Object.fromEntries(boundValues.map((v, i) => [`col${i}`, v])) : {};
+          rows.push(bound);
+          tables.set(table, rows);
+          changes = 1;
+          lastRowId = rows.length;
+        } else if (op === "delete" && table) {
+          const rows = tables.get(table) ?? [];
+          changes = rows.length;
+          tables.set(table, []);
+        } else if (op === "update" && table) {
+          changes = (tables.get(table) ?? []).length;
+        }
+        return {
+          results: [],
+          success: true,
+          meta: { duration: 0, changes, last_row_id: lastRowId }
+        };
+      },
+      async raw(_options) {
+        const { rows } = resolveRows(sql);
+        return rows.map((row) => Object.values(row));
+      }
+    };
+    return statement;
+  };
+  return {
+    prepare(query) {
+      return createStatement(query);
+    },
+    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;
+    }
+  };
+}
+// src/test/utilities/r2.ts
+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");
+    }
+  };
+}
+// src/test/utilities/queue.ts
+function createMockQueue() {
+  const messages = [];
+  const metrics = {
+    backlogCount: 0,
+    backlogBytes: 0
+  };
+  const response = { metadata: { metrics } };
+  return {
+    async metrics() {
+      return metrics;
+    },
+    async send(message, options) {
+      messages.push({ body: message, options });
+      return response;
+    },
+    async sendBatch(batch, options) {
+      for (const message of batch) {
+        messages.push({
+          body: message.body,
+          options: {
+            contentType: message.contentType,
+            delaySeconds: message.delaySeconds ?? options?.delaySeconds
+          }
+        });
+      }
+      return response;
+    },
+    _getMessages() {
+      return messages;
+    }
+  };
+}
+// src/test/utilities/platform.ts
+function createMockRateLimit(options = {}) {
+  const limit = options.limit ?? Number.MAX_SAFE_INTEGER;
+  const periodMs = (options.period ?? 60) * 1000;
+  const windows = new Map;
+  return {
+    async limit({ key }) {
+      const now = Date.now();
+      const existing = windows.get(key);
+      if (!existing || existing.resetAt <= now) {
+        windows.set(key, { count: 1, resetAt: now + periodMs });
+        return { success: limit >= 1 };
+      }
+      existing.count += 1;
+      return { success: existing.count <= limit };
+    }
+  };
+}
+function createMockVersionMetadata(metadata = {}) {
+  return {
+    id: metadata.id ?? "devflare-local-version",
+    tag: metadata.tag ?? "local",
+    timestamp: metadata.timestamp ?? "1970-01-01T00:00:00.000Z"
+  };
+}
+function createMockSecretsStoreSecret(value) {
+  return {
+    async get() {
+      return value;
+    }
+  };
+}
+function defaultPortForDatabaseUrl(url) {
+  if (url.port) {
+    return Number(url.port);
+  }
+  return url.protocol === "mysql:" ? 3306 : 5432;
+}
+function createMockHyperdrive(connectionString) {
+  const url = new URL(connectionString);
+  return {
+    connectionString,
+    host: url.hostname,
+    port: defaultPortForDatabaseUrl(url),
+    user: decodeURIComponent(url.username),
+    password: decodeURIComponent(url.password),
+    database: decodeURIComponent(url.pathname.replace(/^\//, "")),
+    connect() {
+      throw new Error("Mock Hyperdrive connect() is not implemented. Use connectionString with your database client, or run a Miniflare-backed test for socket behavior.");
+    }
+  };
+}
+function createDefaultWorkerStub() {
+  return {
+    getEntrypoint() {
+      throw new Error("Mock WorkerLoader stub has no entrypoint. Pass createMockWorkerLoader({ stub }) for behavior.");
+    },
+    getDurableObjectClass() {
+      throw new Error("Mock WorkerLoader stub has no Durable Object class. Pass createMockWorkerLoader({ stub }) for behavior.");
+    }
+  };
+}
+function createMockWorkerLoader(options = {}) {
+  const stub = options.stub ?? createDefaultWorkerStub();
+  return {
+    get(_name, _getCode) {
+      return stub;
+    },
+    load(_code) {
+      return stub;
+    }
+  };
+}
+function defaultMTLSCertificateHandler() {
+  throw new Error("Mock mTLS Certificate Fetcher has no handler. Pass createMockMTLSCertificate(handler) for behavior.");
+}
+function createMockMTLSCertificate(handler = defaultMTLSCertificateHandler) {
+  return {
+    async fetch(input, init) {
+      return handler(input, init);
+    }
+  };
+}
+function createMockDispatchNamespace(options = {}) {
+  return {
+    get(name) {
+      const worker = options.workers?.[name];
+      if (!worker) {
+        throw new Error(`Mock DispatchNamespace has no worker named "${name}".`);
+      }
+      return typeof worker === "function" ? createMockMTLSCertificate(worker) : worker;
+    }
+  };
+}
+// src/test/utilities/workflows.ts
+function createMockWorkflowInstance(id, options = {}) {
+  let status = options.status ?? "queued";
+  let output = options.output;
+  let error = options.error;
+  return {
+    id,
+    async pause() {
+      status = "paused";
+    },
+    async resume() {
+      status = "running";
+    },
+    async terminate() {
+      status = "terminated";
+    },
+    async restart() {
+      status = "queued";
+      error = undefined;
+      output = undefined;
+    },
+    async status() {
+      return {
+        status,
+        ...error && { error },
+        ...output !== undefined && { output }
+      };
+    },
+    async sendEvent(_event) {}
+  };
+}
+function createMockWorkflow(options = {}) {
+  const instances = new Map;
+  let sequence = 0;
+  for (const [id, instanceOptions] of Object.entries(options.instances ?? {})) {
+    instances.set(id, createMockWorkflowInstance(id, instanceOptions));
+  }
+  const createInstance = (id) => {
+    if (instances.has(id)) {
+      throw new Error(`Mock Workflow already has an instance named "${id}".`);
+    }
+    const instance = createMockWorkflowInstance(id);
+    instances.set(id, instance);
+    return instance;
+  };
+  return {
+    async get(id) {
+      const instance = instances.get(id);
+      if (!instance) {
+        throw new Error(`Mock Workflow has no instance named "${id}".`);
+      }
+      return instance;
+    },
+    async create(options2) {
+      const id = options2?.id ?? `mock-workflow-${++sequence}`;
+      return createInstance(id);
+    },
+    async createBatch(batch) {
+      return batch.map((options2) => {
+        const id = options2.id ?? `mock-workflow-${++sequence}`;
+        return createInstance(id);
+      });
+    }
+  };
+}
+function createMockPipeline() {
+  const records = [];
+  return {
+    async send(batch) {
+      records.push(...batch);
+    },
+    _getRecords() {
+      return [...records];
+    }
+  };
+}
+// src/test/utilities/media.ts
+function createEmptyImageStream() {
+  return new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+}
+function createMockImageTransformationResult(response) {
+  return {
+    response() {
+      return response.clone();
+    },
+    contentType() {
+      return response.headers.get("Content-Type") ?? "image/png";
+    },
+    image() {
+      const cloned = response.clone();
+      return cloned.body ?? createEmptyImageStream();
+    }
+  };
+}
+function createMockImageTransformer(response) {
+  const transformer = {
+    transform(_transform) {
+      return transformer;
+    },
+    draw(_image, _options) {
+      return transformer;
+    },
+    async output(_options) {
+      return createMockImageTransformationResult(response);
+    }
+  };
+  return transformer;
+}
+function createMockHostedImagesBinding() {
+  const unsupported = () => {
+    throw new Error("Mock Images hosted API is not implemented. Pass a custom ImagesBinding through createMockEnv({ images }) if your test needs hosted image behavior.");
+  };
+  return {
+    image(_imageId) {
+      return {
+        details: unsupported,
+        bytes: unsupported,
+        update: unsupported,
+        delete: unsupported
+      };
+    },
+    upload: unsupported,
+    list: unsupported
+  };
+}
+function createMockImagesBinding(options = {}) {
+  const response = options.response ?? new Response("", {
+    headers: { "Content-Type": "image/png" }
+  });
+  const info = options.info ?? {
+    format: response.headers.get("Content-Type") ?? "image/png",
+    fileSize: 0,
+    width: 0,
+    height: 0
+  };
+  return {
+    async info(_stream, _options) {
+      return info;
+    },
+    input(_stream, _options) {
+      return createMockImageTransformer(response);
+    },
+    hosted: createMockHostedImagesBinding()
+  };
+}
+function createEmptyMediaStream() {
+  return new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+}
+function createMockMediaTransformationResult(response) {
+  return {
+    async media() {
+      const cloned = response.clone();
+      return cloned.body ?? createEmptyMediaStream();
+    },
+    async response() {
+      return response.clone();
+    },
+    async contentType() {
+      return response.headers.get("Content-Type") ?? "video/mp4";
+    }
+  };
+}
+function createMockMediaTransformer(response) {
+  const transformer = {
+    transform(_transform) {
+      return {
+        output(_output) {
+          return createMockMediaTransformationResult(response);
+        }
+      };
+    },
+    output(_output) {
+      return createMockMediaTransformationResult(response);
+    }
+  };
+  return transformer;
+}
+function createMockMediaBinding(options = {}) {
+  const response = options.response ?? new Response("", {
+    headers: { "Content-Type": "video/mp4" }
+  });
+  return {
+    input(_media) {
+      return createMockMediaTransformer(response);
+    }
+  };
+}
+// src/test/utilities/artifacts.ts
+function createArtifactTimestamp() {
+  return new Date("2026-04-26T00:00:00.000Z").toISOString();
+}
+function createArtifactsRepoInfo(name, options = {}) {
+  const now = createArtifactTimestamp();
+  return {
+    id: `repo-${name}`,
+    name,
+    description: options.description ?? null,
+    defaultBranch: options.defaultBranch ?? "main",
+    createdAt: now,
+    updatedAt: now,
+    lastPushAt: null,
+    source: options.source ?? null,
+    readOnly: options.readOnly ?? false,
+    remote: `https://example.com/artifacts/default/${name}.git`
+  };
+}
+function isArtifactsBinding(value) {
+  return typeof value.create === "function";
+}
+function createMockArtifacts(options = {}) {
+  const repos = new Map;
+  const tokens = new Map;
+  const addRepo = (info) => {
+    repos.set(info.name, info);
+    if (!tokens.has(info.name)) {
+      tokens.set(info.name, []);
+    }
+  };
+  for (const repo of options.repos ?? []) {
+    addRepo({
+      ...createArtifactsRepoInfo(repo.name),
+      ...repo
+    });
+  }
+  const createToken = (repoName, scope = "write", ttl = 86400) => {
+    const existing = tokens.get(repoName) ?? [];
+    const id = `token-${repoName}-${existing.length + 1}`;
+    const expiresAt = new Date(Date.parse(createArtifactTimestamp()) + ttl * 1000).toISOString();
+    const token = {
+      id,
+      scope,
+      state: "active",
+      createdAt: createArtifactTimestamp(),
+      expiresAt
+    };
+    tokens.set(repoName, [...existing, token]);
+    return {
+      id,
+      plaintext: `${id}-plaintext`,
+      scope,
+      expiresAt
+    };
+  };
+  const createRepoHandle = (info) => ({
+    ...info,
+    async createToken(scope, ttl) {
+      return createToken(info.name, scope, ttl);
+    },
+    async listTokens() {
+      const repoTokens = tokens.get(info.name) ?? [];
+      return {
+        tokens: repoTokens,
+        total: repoTokens.length
+      };
+    },
+    async revokeToken(tokenOrId) {
+      const repoTokens = tokens.get(info.name) ?? [];
+      const index = repoTokens.findIndex((token) => token.id === tokenOrId);
+      if (index === -1) {
+        return false;
+      }
+      repoTokens[index] = {
+        ...repoTokens[index],
+        state: "revoked"
+      };
+      tokens.set(info.name, repoTokens);
+      return true;
+    },
+    async fork(name, forkOptions) {
+      return createRepo(name, {
+        description: forkOptions?.description ?? info.description ?? undefined,
+        readOnly: forkOptions?.readOnly ?? info.readOnly,
+        setDefaultBranch: info.defaultBranch,
+        source: `artifacts:default/${info.name}`
+      });
+    }
+  });
+  const createRepo = async (name, createOptions = {}) => {
+    const info = createArtifactsRepoInfo(name, {
+      description: createOptions.description,
+      readOnly: createOptions.readOnly,
+      defaultBranch: createOptions.setDefaultBranch,
+      source: createOptions.source
+    });
+    addRepo(info);
+    const token = createToken(name);
+    return {
+      id: info.id,
+      name: info.name,
+      description: info.description,
+      defaultBranch: info.defaultBranch,
+      remote: info.remote,
+      token: token.plaintext,
+      tokenExpiresAt: token.expiresAt
+    };
+  };
+  return {
+    create: createRepo,
+    async get(name) {
+      const repo = repos.get(name);
+      return repo ? createRepoHandle(repo) : null;
+    },
+    async import(params) {
+      return createRepo(params.target.name, {
+        description: params.target.opts?.description,
+        readOnly: params.target.opts?.readOnly,
+        source: params.source.url
+      });
+    },
+    async list(opts) {
+      const limit = opts?.limit ?? 50;
+      const repoList = Array.from(repos.values()).slice(0, limit).map((repo) => {
+        const { remote: _remote, ...rest } = repo;
+        return rest;
+      });
+      return {
+        repos: repoList,
+        total: repos.size,
+        ...repos.size > repoList.length && { cursor: String(repoList.length) }
+      };
+    },
+    async delete(name) {
+      tokens.delete(name);
+      return repos.delete(name);
+    }
+  };
+}
+// src/test/utilities/env.ts
+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.rateLimits) {
+    for (const [name, rateLimitOptions] of Object.entries(options.rateLimits)) {
+      env2[name] = createMockRateLimit(rateLimitOptions);
+    }
+  }
+  if (options.versionMetadata) {
+    env2[options.versionMetadata] = createMockVersionMetadata();
+  }
+  if (options.hyperdrive) {
+    for (const [name, binding] of Object.entries(options.hyperdrive)) {
+      env2[name] = typeof binding === "string" ? createMockHyperdrive(binding) : binding;
+    }
+  }
+  if (Array.isArray(options.workerLoaders)) {
+    for (const name of options.workerLoaders) {
+      env2[name] = createMockWorkerLoader();
+    }
+  } else if (options.workerLoaders) {
+    for (const [name, workerLoaderOptions] of Object.entries(options.workerLoaders)) {
+      env2[name] = createMockWorkerLoader(workerLoaderOptions);
+    }
+  }
+  if (Array.isArray(options.mtlsCertificates)) {
+    for (const name of options.mtlsCertificates) {
+      env2[name] = createMockMTLSCertificate();
+    }
+  } else if (options.mtlsCertificates) {
+    for (const [name, handler] of Object.entries(options.mtlsCertificates)) {
+      env2[name] = createMockMTLSCertificate(handler);
+    }
+  }
+  if (Array.isArray(options.dispatchNamespaces)) {
+    for (const name of options.dispatchNamespaces) {
+      env2[name] = createMockDispatchNamespace();
+    }
+  } else if (options.dispatchNamespaces) {
+    for (const [name, dispatchNamespaceOptions] of Object.entries(options.dispatchNamespaces)) {
+      env2[name] = createMockDispatchNamespace(dispatchNamespaceOptions);
+    }
+  }
+  if (Array.isArray(options.workflows)) {
+    for (const name of options.workflows) {
+      env2[name] = createMockWorkflow();
+    }
+  } else if (options.workflows) {
+    for (const [name, workflowOptions] of Object.entries(options.workflows)) {
+      env2[name] = "create" in workflowOptions ? workflowOptions : createMockWorkflow(workflowOptions);
+    }
+  }
+  if (Array.isArray(options.pipelines)) {
+    for (const name of options.pipelines) {
+      env2[name] = createMockPipeline();
+    }
+  } else if (options.pipelines) {
+    for (const [name, pipeline] of Object.entries(options.pipelines)) {
+      env2[name] = pipeline;
+    }
+  }
+  if (typeof options.images === "string") {
+    env2[options.images] = createMockImagesBinding();
+  } else if (options.images) {
+    env2.IMAGES = options.images;
+  }
+  if (typeof options.media === "string") {
+    env2[options.media] = createMockMediaBinding();
+  } else if (options.media) {
+    env2.MEDIA = options.media;
+  }
+  if (Array.isArray(options.artifacts)) {
+    for (const name of options.artifacts) {
+      env2[name] = createMockArtifacts();
+    }
+  } else if (options.artifacts) {
+    for (const [name, artifactsOptions] of Object.entries(options.artifacts)) {
+      env2[name] = isArtifactsBinding(artifactsOptions) ? artifactsOptions : createMockArtifacts(artifactsOptions);
+    }
+  }
+  if (options.secretsStore) {
+    for (const [name, value] of Object.entries(options.secretsStore)) {
+      env2[name] = createMockSecretsStoreSecret(value);
+    }
+  }
+  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/simple-context-bindings.ts
+function buildRemoteAndStaticBindings(config) {
+  const remoteBindings = {};
+  if (isRemoteModeActive()) {
+    if (config.bindings?.ai) {
+      const aiBindingName = config.bindings.ai.binding || "AI";
+      remoteBindings[aiBindingName] = createRemoteAI(config.accountId);
+    }
+    if (config.bindings?.vectorize) {
+      for (const [name, vectorConfig] of Object.entries(config.bindings.vectorize)) {
+        remoteBindings[name] = createRemoteVectorize(vectorConfig.indexName, config.accountId);
+      }
+    }
+  }
+  if (config.vars) {
+    for (const [key, value] of Object.entries(config.vars)) {
+      remoteBindings[key] = value;
+    }
+  }
+  if (config.bindings?.sendEmail) {
+    for (const [name, binding] of Object.entries(config.bindings.sendEmail)) {
+      remoteBindings[name] = createLocalSendEmailBinding(binding);
+    }
+  }
+  if (config.bindings?.workerLoaders) {
+    for (const name of Object.keys(config.bindings.workerLoaders)) {
+      remoteBindings[name] = createLocalWorkerLoaderBinding();
+    }
+  }
+  if (config.bindings?.versionMetadata) {
+    remoteBindings[config.bindings.versionMetadata.binding] = createMockVersionMetadata();
+  }
+  return remoteBindings;
+}
+
+// src/test/email.ts
+import { join as join3 } 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 = join3(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 join4 } 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;
+}
+var EMPTY_QUEUE_METADATA = {
+  metrics: {
+    backlogCount: 0,
+    backlogBytes: 0
+  }
+};
+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",
+    metadata: EMPTY_QUEUE_METADATA,
+    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 = join4(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 env3 = testEnvGetter2();
+  const queueEvent = createQueueEvent(batch, env3, 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 queue2 = {
+  trigger,
+  send: send2
+};
+
+// src/test/scheduled.ts
+import { join as join5 } 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 = join5(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 env3 = testEnvGetter3();
+  const scheduledEvent = createScheduledEvent(controller, env3, 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 join6 } 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 = join6(configDir4, tailHandlerPath);
+  const handlerModule = await import(absolutePath);
+  const defaultExport = handlerModule.default;
+  const tailHandler = typeof defaultExport === "function" ? defaultExport : defaultExport && typeof defaultExport.tail === "function" ? defaultExport.tail.bind(defaultExport) : 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 env3 = testEnvGetter4();
+  const tailEvent = createTailEvent(traceItems, env3, ctx);
+  try {
+    await runWithEventContext(tailEvent, () => tailHandler.length >= 2 ? tailHandler(traceItems, env3, ctx) : tailHandler(tailEvent, env3, ctx));
+    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 join7 } 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(join7(workerConfigDir, fetchHandlerPath)) : {};
+  const routeModules = await Promise.all(fileRoutes.map(async (route) => {
+    return {
+      ...route,
+      module: await import(join7(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 env3 = getEnv();
+  const initialRouteMatch = routeModules.length > 0 ? matchFetchRoute(routeModules, req) : null;
+  const fetchEvent = createFetchEvent(req, env3, 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-env.ts
+function configureSurfaceHandlers(input) {
+  const { handlerPaths, configDir: configDir6, activePort, getEnv } = input;
+  configureQueue({
+    handlerPath: handlerPaths.queue,
+    configDir: configDir6,
+    getEnv
+  });
+  configureScheduled({
+    handlerPath: handlerPaths.scheduled,
+    configDir: configDir6,
+    getEnv
+  });
+  configureWorker({
+    handlerPath: handlerPaths.fetch,
+    routes: handlerPaths.routes?.routes.map((route) => ({
+      filePath: route.filePath,
+      routePath: route.routePath,
+      segments: route.segments
+    })) ?? [],
+    configDir: configDir6,
+    getEnv
+  });
+  configureTail({
+    handlerPath: handlerPaths.tail,
+    configDir: configDir6,
+    getEnv
+  });
+  configureEmail({
+    port: activePort,
+    handlerPath: handlerPaths.email,
+    configDir: configDir6,
+    getEnv
+  });
+}
+function createBridgeEnvAccessor(state, hints, shouldPreferBridgeBinding) {
+  return new Proxy({}, {
+    get(_, prop) {
+      const hint = hints[prop];
+      const prefersBridgeBinding = shouldPreferBridgeBinding(hint);
+      if (state.remoteBindings && prop in state.remoteBindings) {
+        return state.remoteBindings[prop];
+      }
+      if (!prefersBridgeBinding && state.miniflareBindings && prop in state.miniflareBindings) {
+        return state.miniflareBindings[prop];
+      }
+      if (state.envProxy) {
+        return state.envProxy[prop];
+      }
+      if (prefersBridgeBinding && state.miniflareBindings && prop in state.miniflareBindings) {
+        return state.miniflareBindings[prop];
+      }
+      return;
+    },
+    has(_, prop) {
+      return Boolean(state.remoteBindings && prop in state.remoteBindings || state.miniflareBindings && prop in state.miniflareBindings || state.envProxy !== null);
+    }
+  });
+}
+function createMultiWorkerEnvAccessor(state) {
+  return new Proxy({}, {
+    get(_, prop) {
+      if (state.remoteBindings && prop in state.remoteBindings) {
+        return state.remoteBindings[prop];
+      }
+      if (state.miniflareBindings && prop in state.miniflareBindings) {
+        return state.miniflareBindings[prop];
+      }
+      return;
+    },
+    has(_, prop) {
+      return Boolean(state.remoteBindings && prop in state.remoteBindings || state.miniflareBindings && prop in state.miniflareBindings);
+    }
+  });
+}
+
+// src/test/simple-context-handlers.ts
+import { join as join8 } from "path";
+var DEFAULT_FETCH_PATH = "src/fetch.ts";
+var DEFAULT_QUEUE_PATH = "src/queue.ts";
+var DEFAULT_SCHEDULED_PATH = "src/scheduled.ts";
+var DEFAULT_EMAIL_PATH = "src/email.ts";
+var DEFAULT_TAIL_PATH = "src/tail.ts";
+async function resolveHandlerPath(configDir6, configValue, defaultPath) {
+  if (typeof configValue === "string") {
+    return configValue;
+  }
+  if (configValue === false) {
+    return null;
+  }
+  const defaultAbsolute = join8(configDir6, defaultPath);
+  try {
+    const fs = await import("fs/promises");
+    await fs.access(defaultAbsolute);
+    return defaultPath;
+  } catch {
+    return null;
+  }
+}
+async function resolveHandlerPaths(configDir6, config) {
+  const [fetch3, queue3, scheduled2, email2, tail2, routes] = await Promise.all([
+    resolveHandlerPath(configDir6, config.files?.fetch, DEFAULT_FETCH_PATH),
+    resolveHandlerPath(configDir6, config.files?.queue, DEFAULT_QUEUE_PATH),
+    resolveHandlerPath(configDir6, config.files?.scheduled, DEFAULT_SCHEDULED_PATH),
+    resolveHandlerPath(configDir6, config.files?.email, DEFAULT_EMAIL_PATH),
+    resolveHandlerPath(configDir6, config.files?.tail, DEFAULT_TAIL_PATH),
+    discoverRoutes(configDir6, config)
+  ]);
+  return { fetch: fetch3, queue: queue3, scheduled: scheduled2, email: email2, tail: tail2, routes };
+}
+
+// src/test/simple-context-lifecycle.ts
+import { dirname as dirname4, resolve as resolve2 } from "path";
+
+// src/test/containers.ts
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync as existsSync2 } from "node:fs";
+import { stat } from "node:fs/promises";
+import { createConnection } from "node:net";
+import { basename, dirname as dirname3, isAbsolute, join as join9, resolve } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { execa } from "execa";
+var realContainerCommandRunner = {
+  async exec(command, args, options = {}) {
+    try {
+      const result = await execa(command, args, {
+        cwd: options.cwd,
+        env: options.env,
+        reject: false,
+        timeout: options.timeoutMs ?? 15000
+      });
+      return {
+        exitCode: result.exitCode ?? 0,
+        stdout: String(result.stdout ?? ""),
+        stderr: String(result.stderr ?? "")
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        exitCode: err.exitCode ?? 1,
+        stdout: String(err.stdout ?? ""),
+        stderr: String(err.stderr ?? err.message ?? "Container command failed")
+      };
+    }
+  }
+};
+async function detectContainerEngine(options = {}) {
+  const runner = options.runner ?? realContainerCommandRunner;
+  const candidates = options.engine && options.engine !== "auto" ? [options.engine] : ["docker", "podman"];
+  const checked = [];
+  for (const engine of candidates) {
+    let result;
+    try {
+      result = await runner.exec(engine, ["info"], { timeoutMs: 1e4 });
+    } catch (error) {
+      result = {
+        exitCode: 1,
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error)
+      };
+    }
+    if (result.exitCode === 0) {
+      checked.push({ engine, available: true });
+      return { available: true, engine, checked };
+    }
+    checked.push({
+      engine,
+      available: false,
+      reason: formatCommandFailure(result)
+    });
+  }
+  return {
+    available: false,
+    reason: checked.map((check) => `${check.engine}: ${check.reason ?? "not available"}`).join("; "),
+    checked
+  };
+}
+async function getContainerSkipReason(options = {}) {
+  const env3 = options.env ?? process.env;
+  if (!isTruthyEnvFlag(env3.DEVFLARE_CONTAINER_TESTS)) {
+    return "Container tests require DEVFLARE_CONTAINER_TESTS=1 because they launch local Docker/Podman containers.";
+  }
+  const status = await detectContainerEngine(options);
+  if (!status.available) {
+    return `No reachable Docker or Podman engine found: ${status.reason}`;
+  }
+  return null;
+}
+function createContainerManager(options = {}) {
+  const active = new Set;
+  const getRunner = () => options.runner ?? realContainerCommandRunner;
+  const manager = {
+    detectEngine(engineOptions = {}) {
+      return detectContainerEngine({
+        engine: engineOptions.engine ?? options.engine,
+        runner: engineOptions.runner ?? getRunner()
+      });
+    },
+    async start(className, startOptions) {
+      const cwd = options.cwd ?? getCallerDirectory();
+      const resolved = await resolveContainerStart(className, startOptions, cwd);
+      const status = await manager.detectEngine();
+      const engine = getAvailableContainerEngine(status, className);
+      const runner = getRunner();
+      const offline = startOptions.offline ?? true;
+      const prepared = await prepareImage({
+        engine,
+        runner,
+        image: resolved.image,
+        className,
+        configDir: resolved.configDir,
+        imageBuildContext: resolved.config?.imageBuildContext,
+        offline
+      });
+      const host = startOptions.host ?? "127.0.0.1";
+      const hostPort = startOptions.hostPort ?? await (options.allocatePort ?? getAvailablePort)();
+      const containerName = makeContainerName(className, startOptions.instance);
+      const runArgs = buildRunArgs({
+        name: containerName,
+        className,
+        image: prepared.image,
+        host,
+        hostPort,
+        containerPort: startOptions.port,
+        envVars: startOptions.envVars,
+        entrypoint: startOptions.entrypoint,
+        command: startOptions.command
+      });
+      const runResult = await runner.exec(engine, runArgs, {
+        cwd: resolved.configDir,
+        env: options.env ?? process.env
+      });
+      if (runResult.exitCode !== 0) {
+        throw new Error(`Failed to start Devflare container "${className}": ${formatCommandFailure(runResult)}`);
+      }
+      const instance = new LocalDevflareContainer({
+        id: runResult.stdout.trim() || containerName,
+        name: containerName,
+        className,
+        engine,
+        host,
+        hostPort,
+        port: startOptions.port,
+        runner,
+        fetchImpl: options.fetch ?? fetch,
+        onDispose: (container) => active.delete(container)
+      });
+      active.add(instance);
+      await waitForContainerReadiness(instance, startOptions, options.waitForPort ?? waitForTcpPort);
+      return instance;
+    },
+    async stopAll() {
+      await Promise.all([...active].map((container) => container.stop()));
+    }
+  };
+  return manager;
+}
+var defaultContainerManager = createContainerManager();
+var containers = defaultContainerManager;
+async function stopActiveContainers() {
+  await defaultContainerManager.stopAll();
+}
+function getAvailableContainerEngine(status, className) {
+  if (!status.available) {
+    throw new Error(`Cannot start Devflare container "${className}": ${status.reason}`);
+  }
+  return status.engine;
+}
+async function waitForContainerReadiness(instance, options, waitForPort) {
+  if (!(options.waitForReady ?? true)) {
+    return;
+  }
+  try {
+    await waitForPort(instance.host, instance.hostPort, options.readyTimeoutMs ?? 20000);
+  } catch (error) {
+    await instance.destroy();
+    throw error;
+  }
+}
+async function resolveContainerStart(className, options, cwd) {
+  if (options.image) {
+    return {
+      configDir: cwd,
+      image: options.image
+    };
+  }
+  const { config, configDir: configDir6 } = await loadContainerConfig(options.configPath, cwd);
+  const container = config.containers?.find((candidate) => candidate.className === className || candidate.name === className);
+  if (!container) {
+    throw new Error(`Container "${className}" was not found in devflare config.`);
+  }
+  return {
+    configDir: configDir6,
+    image: container.image,
+    config: container
+  };
+}
+async function loadContainerConfig(configPath, cwd) {
+  const absolutePath = configPath ? resolve(cwd, configPath) : await findNearestConfig(cwd);
+  if (!absolutePath) {
+    throw new Error(`Could not find a devflare config file for container lookup. Searched upward from: ${cwd}`);
+  }
+  const configDir6 = dirname3(absolutePath);
+  const loadedConfig = await loadConfig({
+    cwd: configDir6,
+    configFile: basename(absolutePath)
+  });
+  const config = await applyLocalDevVarsToConfig(loadedConfig, {
+    cwd: configDir6,
+    configPath: absolutePath
+  });
+  return { config, configDir: configDir6 };
+}
+async function prepareImage(options) {
+  if (looksLikeLocalPath(options.image)) {
+    return {
+      image: await buildLocalImage(options)
+    };
+  }
+  const inspect = await options.runner.exec(options.engine, ["image", "inspect", options.image], {
+    cwd: options.configDir
+  });
+  if (inspect.exitCode === 0) {
+    return { image: options.image };
+  }
+  if (options.offline) {
+    throw new Error(`Container image "${options.image}" is not present locally. Devflare container tests are offline-first; pull/build the image ahead of time or pass offline: false.`);
+  }
+  const pull = await options.runner.exec(options.engine, ["pull", options.image], {
+    cwd: options.configDir
+  });
+  if (pull.exitCode !== 0) {
+    throw new Error(`Failed to pull container image "${options.image}": ${formatCommandFailure(pull)}`);
+  }
+  return { image: options.image };
+}
+async function buildLocalImage(options) {
+  const imagePath = resolve(options.configDir, options.image);
+  const imageStat = await stat(imagePath);
+  const dockerfile = imageStat.isDirectory() ? join9(imagePath, "Dockerfile") : imagePath;
+  const context2 = resolve(options.configDir, options.imageBuildContext ?? (imageStat.isDirectory() ? options.image : dirname3(options.image)));
+  if (!existsSync2(dockerfile)) {
+    throw new Error(`Container Dockerfile does not exist: ${dockerfile}`);
+  }
+  const tag = makeLocalImageTag(options.className, options.configDir, options.image);
+  const args = [
+    "build",
+    ...options.offline ? [getOfflineBuildPullArg(options.engine)] : [],
+    "-t",
+    tag,
+    "-f",
+    dockerfile,
+    context2
+  ];
+  const result = await options.runner.exec(options.engine, args, {
+    cwd: options.configDir
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to build local container image "${options.image}": ${formatCommandFailure(result)}`);
+  }
+  return tag;
+}
+function buildRunArgs(options) {
+  const args = [
+    "run",
+    "-d",
+    "--name",
+    options.name,
+    "--label",
+    "devflare.managed=true",
+    "--label",
+    `devflare.container.class=${options.className}`,
+    "-p",
+    `${options.host}:${options.hostPort}:${options.containerPort}`
+  ];
+  for (const [key, value] of Object.entries(options.envVars ?? {})) {
+    args.push("-e", `${key}=${value}`);
+  }
+  const command = [...options.command ?? []];
+  if (options.entrypoint && options.entrypoint.length > 0) {
+    args.push("--entrypoint", options.entrypoint[0]);
+    command.unshift(...options.entrypoint.slice(1));
+  }
+  args.push(options.image, ...command);
+  return args;
+}
+
+class LocalDevflareContainer {
+  id;
+  name;
+  className;
+  engine;
+  host;
+  hostPort;
+  port;
+  runner;
+  fetchImpl;
+  onDispose;
+  disposed = false;
+  constructor(options) {
+    this.id = options.id;
+    this.name = options.name;
+    this.className = options.className;
+    this.engine = options.engine;
+    this.host = options.host;
+    this.hostPort = options.hostPort;
+    this.port = options.port;
+    this.runner = options.runner;
+    this.fetchImpl = options.fetchImpl;
+    this.onDispose = options.onDispose;
+  }
+  fetch(input, init) {
+    return fetchWithStartupRetries(this.fetchImpl, this.toLocalRequest(input, init));
+  }
+  async logs() {
+    const result = await this.runner.exec(this.engine, ["logs", this.name]);
+    if (result.exitCode !== 0) {
+      throw new Error(`Failed to read logs for Devflare container "${this.name}": ${formatCommandFailure(result)}`);
+    }
+    return result.stdout;
+  }
+  async getState() {
+    const result = await this.runner.exec(this.engine, [
+      "inspect",
+      "--format",
+      "{{json .State}}",
+      this.name
+    ]);
+    if (result.exitCode !== 0) {
+      throw new Error(`Failed to inspect Devflare container "${this.name}": ${formatCommandFailure(result)}`);
+    }
+    const parsed = JSON.parse(result.stdout || "{}");
+    return {
+      status: parsed.Status ?? (parsed.Running ? "running" : "stopped"),
+      running: Boolean(parsed.Running),
+      ...typeof parsed.ExitCode === "number" && { exitCode: parsed.ExitCode }
+    };
+  }
+  async stop() {
+    if (this.disposed)
+      return;
+    try {
+      await this.runner.exec(this.engine, ["stop", this.name]);
+    } finally {
+      await this.runner.exec(this.engine, ["rm", "-f", this.name]);
+      this.disposed = true;
+      this.onDispose(this);
+    }
+  }
+  async destroy() {
+    if (this.disposed)
+      return;
+    await this.runner.exec(this.engine, ["rm", "-f", this.name]);
+    this.disposed = true;
+    this.onDispose(this);
+  }
+  toLocalRequest(input, init) {
+    const base = `http://${this.host}:${this.hostPort}/`;
+    if (input instanceof Request) {
+      const source = init ? new Request(input, init) : input;
+      const sourceUrl2 = new URL(source.url);
+      const localUrl2 = new URL(`${sourceUrl2.pathname}${sourceUrl2.search}`, base);
+      return new Request(localUrl2, {
+        method: source.method,
+        headers: source.headers,
+        body: source.body,
+        redirect: source.redirect,
+        signal: source.signal
+      });
+    }
+    const sourceUrl = new URL(String(input), base);
+    const localUrl = new URL(`${sourceUrl.pathname}${sourceUrl.search}`, base);
+    return new Request(localUrl, init);
+  }
+}
+async function fetchWithStartupRetries(fetchImpl, request) {
+  if (!canRetryRequest(request)) {
+    return fetchImpl(request);
+  }
+  const deadline = Date.now() + 5000;
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      return await fetchImpl(request.clone());
+    } catch (error) {
+      if (!isTransientContainerFetchError(error)) {
+        throw error;
+      }
+      lastError = error;
+      await delay(100);
+    }
+  }
+  throw lastError;
+}
+function canRetryRequest(request) {
+  return (request.method === "GET" || request.method === "HEAD") && request.body === null;
+}
+function isTransientContainerFetchError(error) {
+  const value = error;
+  const code = value.code ?? value.cause?.code;
+  if (code === "ECONNRESET" || code === "ECONNREFUSED" || code === "EPIPE" || code === "UND_ERR_SOCKET") {
+    return true;
+  }
+  return typeof value.message === "string" && (value.message.includes("socket connection was closed") || value.message.includes("fetch failed"));
+}
+async function waitForTcpPort(host, port, timeoutMs) {
+  const start = Date.now();
+  let lastError;
+  while (Date.now() - start < timeoutMs) {
+    try {
+      await connectOnce(host, port);
+      return;
+    } catch (error) {
+      lastError = error;
+      await delay(100);
+    }
+  }
+  const message = lastError instanceof Error ? lastError.message : "timed out";
+  throw new Error(`Timed out waiting for container port ${host}:${port}: ${message}`);
+}
+function connectOnce(host, port) {
+  return new Promise((resolveConnection, rejectConnection) => {
+    const socket = createConnection({ host, port });
+    socket.once("connect", () => {
+      socket.destroy();
+      resolveConnection();
+    });
+    socket.once("error", rejectConnection);
+  });
+}
+function looksLikeLocalPath(image) {
+  return image === "Dockerfile" || image.startsWith(".") || image.startsWith("/") || image.startsWith("\\") || isAbsolute(image) || image.endsWith("/Dockerfile") || image.endsWith("\\Dockerfile");
+}
+function getOfflineBuildPullArg(engine) {
+  return engine === "podman" ? "--pull=never" : "--pull=false";
+}
+function makeLocalImageTag(className, configDir6, image) {
+  const hash = createHash("sha256").update(`${configDir6}:${image}`).digest("hex").slice(0, 12);
+  return `devflare-local-${sanitizeName(className)}:${hash}`;
+}
+function makeContainerName(className, instance) {
+  return `devflare-${sanitizeName(className)}-${sanitizeName(instance ?? "default")}-${randomUUID().slice(0, 8)}`;
+}
+function sanitizeName(value) {
+  return value.toLowerCase().replace(/[^a-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "") || "container";
+}
+function formatCommandFailure(result) {
+  return (result.stderr || result.stdout || `exit code ${result.exitCode}`).trim();
+}
+function isTruthyEnvFlag(value) {
+  return value === "1" || value?.toLowerCase() === "true" || value?.toLowerCase() === "yes";
+}
+
+// src/test/simple-context-lifecycle.ts
+async function resolveTestContextConfig(configPath, callerDir = getCallerDirectory()) {
+  let absolutePath;
+  if (configPath) {
+    absolutePath = resolve2(callerDir, configPath);
+  } else {
+    const found = await findNearestConfig(callerDir);
+    if (!found) {
+      throw new Error(`Could not find a devflare config file. Searched upward from: ${callerDir}
+` + `Expected one of: devflare.config.ts, devflare.config.mts, devflare.config.js, devflare.config.mjs
+` + `Either create a config file or provide an explicit path: createTestContext('./path/to/config.ts')`);
+    }
+    absolutePath = found;
+  }
+  const configDir6 = dirname4(absolutePath);
+  const loadedConfig = await loadConfig({
+    cwd: configDir6,
+    configFile: absolutePath.split(/[/\\]/).pop()
+  });
+  const config = await applyLocalDevVarsToConfig(loadedConfig, {
+    cwd: configDir6,
+    configPath: absolutePath
+  });
+  return { absolutePath, configDir: configDir6, config };
+}
+function createDisposeContext(state) {
+  return async () => {
+    if (state.client) {
+      await state.client.disconnect();
+      state.client = null;
+    }
+    if (state.miniflare) {
+      await state.miniflare.dispose();
+      state.miniflare = null;
+    }
+    await disposeLocalWorkerLoaderBindings();
+    await stopActiveContainers();
+    state.envProxy = null;
+    state.transportDecode = null;
+    state.remoteBindings = null;
+    state.miniflareBindings = null;
+    resetQueueState();
+    resetScheduledState();
+    resetWorkerState();
+    resetTailState();
+    resetEmailState();
+    __clearTestContext();
+  };
+}
+
+// src/test/simple-context-startup.ts
+var TEST_CONTEXT_STARTUP_RETRY_ATTEMPTS = 3;
+var TEST_CONTEXT_STARTUP_RETRY_DELAY_MS = 75;
+var TEST_CONTEXT_BRIDGE_CONNECT_RETRY_ATTEMPTS = 8;
+var TEST_CONTEXT_BRIDGE_CONNECT_RETRY_DELAY_MS = 150;
+function isRetriableTestContextStartupError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message.toLowerCase();
+  return message.includes("websocket connection failed") || message.includes("connection timeout: ws://") || message.includes("econnrefused") || message.includes("eaddrinuse") || message.includes("address already in use");
+}
+async function waitForTestContextStartupRetry() {
+  await new Promise((resolve3) => setTimeout(resolve3, TEST_CONTEXT_STARTUP_RETRY_DELAY_MS));
+}
+async function waitForBridgeClientRetry() {
+  await new Promise((resolve3) => setTimeout(resolve3, TEST_CONTEXT_BRIDGE_CONNECT_RETRY_DELAY_MS));
+}
+async function connectBridgeClientWithRetry(url) {
+  let lastError;
+  for (let attempt = 1;attempt <= TEST_CONTEXT_BRIDGE_CONNECT_RETRY_ATTEMPTS; attempt++) {
+    const client = new BridgeClient({ url });
+    try {
+      await client.connect();
+      return client;
+    } catch (error) {
+      lastError = error;
+      client.disconnect();
+      if (attempt >= TEST_CONTEXT_BRIDGE_CONNECT_RETRY_ATTEMPTS || !isRetriableTestContextStartupError(error)) {
+        throw error;
+      }
+      await waitForBridgeClientRetry();
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error("Bridge-backed test context could not connect to the WebSocket gateway.");
+}
+function expandLocalBindingWorkers(mfConfig) {
+  const auxiliaryWorkers = [
+    ...mfConfig.__devflareLocalSecretWorkers ?? [],
+    ...mfConfig.__devflareLocalBindingWorkers ?? []
+  ];
+  if (!Array.isArray(auxiliaryWorkers) || auxiliaryWorkers.length === 0) {
+    return mfConfig;
+  }
+  const {
+    __devflareLocalSecretWorkers,
+    __devflareLocalBindingWorkers,
+    port,
+    host,
+    log,
+    kvPersist,
+    r2Persist,
+    d1Persist,
+    durableObjectsPersist,
+    workflowsPersist,
+    imagesPersist,
+    ...primaryWorker
+  } = mfConfig;
+  const primaryWorkerName = typeof primaryWorker.name === "string" ? primaryWorker.name : "primary";
+  return {
+    ...port !== undefined && { port },
+    ...host && { host },
+    ...log && { log },
+    ...kvPersist && { kvPersist },
+    ...r2Persist && { r2Persist },
+    ...d1Persist && { d1Persist },
+    ...durableObjectsPersist && { durableObjectsPersist },
+    ...workflowsPersist && { workflowsPersist },
+    ...imagesPersist && { imagesPersist },
+    workers: [
+      {
+        ...primaryWorker,
+        name: primaryWorkerName
+      },
+      ...auxiliaryWorkers
+    ]
+  };
+}
+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(expandLocalBindingWorkers({
+        ...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.");
+}
+
+// src/test/simple-context-runtime.ts
+async function bootTestRuntime(mfConfig, usesMultiWorker) {
+  if (usesMultiWorker) {
+    const { Miniflare } = await import("miniflare");
+    const activePort = await getAvailablePort();
+    const miniflare = new Miniflare({
+      ...mfConfig,
+      port: activePort
+    });
+    await miniflare.ready;
+    const miniflareBindings = wrapEnvSendEmailBindings(await miniflare.getBindings());
+    return { activePort, miniflare, miniflareBindings, client: null };
+  }
+  const started = await startBridgeBackedTestContext(mfConfig);
+  return {
+    activePort: started.port,
+    miniflare: started.miniflare,
+    miniflareBindings: started.miniflareBindings,
+    client: started.client
+  };
+}
+
+// src/test/simple-context-transport.ts
+import { join as join10 } from "path";
+async function loadTransportDecoders(configDir6, transportFile) {
+  const transportPath = join10(configDir6, transportFile);
+  const transportModule = await import(transportPath);
+  if (!transportModule.transport) {
+    console.warn(`[devflare] Warning: Transport file "${transportFile}" does not export a named "transport" object.
+Expected: export const transport = { ... }
+Transport encoding/decoding will be disabled.`);
+    return null;
+  }
+  const decoders = new Map;
+  for (const [typeName, transporter] of Object.entries(transportModule.transport)) {
+    const t = transporter;
+    decoders.set(typeName, t.decode);
+  }
+  return decoders;
+}
+function decodeTransportValue(decoders, value) {
+  if (!decoders || value === null || typeof value !== "object") {
+    return value;
+  }
+  if ("__transport" in value) {
+    const encoded = value;
+    const decoder = decoders.get(encoded.__transport);
+    if (decoder) {
+      return decoder(encoded.value);
+    }
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => decodeTransportValue(decoders, item));
+  }
+  const result = {};
+  for (const [k, v] of Object.entries(value)) {
+    result[k] = decodeTransportValue(decoders, v);
+  }
+  return result;
+}
+
+// src/test/simple-context-multi-worker.ts
+function applyMultiWorkerConfig(mfConfig, config, serviceBindingResolution, doBindingResolution) {
+  const primaryDurableObjects = {
+    ...mfConfig.durableObjects || {},
+    ...doBindingResolution?.crossWorkerDOBindings || {}
+  };
+  const primaryWorker = {
+    name: config.name ?? "primary",
+    modules: true,
+    script: mfConfig.script,
+    compatibilityDate: config.compatibilityDate ?? "2025-01-01",
+    ...mfConfig.kvNamespaces && { kvNamespaces: mfConfig.kvNamespaces },
+    ...mfConfig.r2Buckets && { r2Buckets: mfConfig.r2Buckets },
+    ...mfConfig.d1Databases && { d1Databases: mfConfig.d1Databases },
+    ...mfConfig.ratelimits && { ratelimits: mfConfig.ratelimits },
+    ...mfConfig.versionMetadata && { versionMetadata: mfConfig.versionMetadata },
+    ...mfConfig.workerLoaders && { workerLoaders: mfConfig.workerLoaders },
+    ...mfConfig.mtlsCertificates && { mtlsCertificates: mfConfig.mtlsCertificates },
+    ...mfConfig.dispatchNamespaces && { dispatchNamespaces: mfConfig.dispatchNamespaces },
+    ...mfConfig.workflows && { workflows: mfConfig.workflows },
+    ...mfConfig.pipelines && { pipelines: mfConfig.pipelines },
+    ...mfConfig.images && { images: mfConfig.images },
+    ...mfConfig.media && { media: mfConfig.media },
+    ...mfConfig.artifacts && { artifacts: mfConfig.artifacts },
+    ...mfConfig.secretsStoreSecrets && { secretsStoreSecrets: mfConfig.secretsStoreSecrets },
+    ...mfConfig.wrappedBindings && { wrappedBindings: mfConfig.wrappedBindings },
+    ...mfConfig.email && { email: mfConfig.email },
+    ...Object.keys(primaryDurableObjects).length > 0 && { durableObjects: primaryDurableObjects },
+    ...mfConfig.serviceBindings || serviceBindingResolution?.primaryServiceBindings ? {
+      serviceBindings: {
+        ...mfConfig.serviceBindings ?? {},
+        ...serviceBindingResolution?.primaryServiceBindings ?? {}
+      }
+    } : {}
+  };
+  const additionalWorkers = [
+    ...serviceBindingResolution?.workers || [],
+    ...doBindingResolution?.workers || [],
+    ...mfConfig.__devflareLocalSecretWorkers || [],
+    ...mfConfig.__devflareLocalBindingWorkers || []
+  ];
+  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.ratelimits;
+  delete mfConfig.versionMetadata;
+  delete mfConfig.workerLoaders;
+  delete mfConfig.mtlsCertificates;
+  delete mfConfig.dispatchNamespaces;
+  delete mfConfig.workflows;
+  delete mfConfig.pipelines;
+  delete mfConfig.images;
+  delete mfConfig.media;
+  delete mfConfig.artifacts;
+  delete mfConfig.secretsStoreSecrets;
+  delete mfConfig.wrappedBindings;
+  delete mfConfig.serviceBindings;
+  delete mfConfig.__devflareLocalSecretWorkers;
+  delete mfConfig.__devflareLocalBindingWorkers;
+  delete mfConfig.durableObjects;
+  mfConfig.workers = workers;
+}
+
+// src/test/simple-context-mfconfig.ts
+function buildInlineBridgeMfConfig(config, options = {}) {
+  const localWorkerBindings = config.vars ?? {};
+  const localSecretWrappedBindingConfig = options.cwd ? buildLocalSecretWrappedBindingConfig(config, options.cwd) : undefined;
+  const localBindingShimServiceConfig = buildLocalBindingShimServiceConfig(config);
+  const localSecretBindingNames = new Set(localSecretWrappedBindingConfig?.localBindingNames ?? []);
+  const mfConfig = {
+    modules: true,
+    compatibilityDate: config.compatibilityDate ?? "2025-01-01",
+    ...config.compatibilityFlags && { compatibilityFlags: config.compatibilityFlags }
+  };
+  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)];
+    }));
+  }
+  const hyperdrivesConfig = buildHyperdrivesConfig(config.bindings ?? {});
+  if (hyperdrivesConfig) {
+    mfConfig.hyperdrives = hyperdrivesConfig;
+  }
+  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 (config.bindings?.rateLimits) {
+    mfConfig.ratelimits = Object.fromEntries(Object.entries(config.bindings.rateLimits).map(([bindingName, binding]) => [
+      bindingName,
+      {
+        simple: {
+          limit: binding.simple.limit,
+          period: binding.simple.period
+        }
+      }
+    ]));
+  }
+  if (config.bindings?.versionMetadata) {
+    mfConfig.versionMetadata = config.bindings.versionMetadata.binding;
+  }
+  if (config.bindings?.workerLoaders) {
+    mfConfig.workerLoaders = Object.fromEntries(Object.keys(config.bindings.workerLoaders).map((bindingName) => [bindingName, {}]));
+  }
+  if (config.bindings?.mtlsCertificates) {
+    mfConfig.mtlsCertificates = Object.fromEntries(Object.entries(config.bindings.mtlsCertificates).map(([bindingName, binding]) => {
+      const normalized = normalizeMtlsCertificateBinding(binding);
+      return [
+        bindingName,
+        {
+          certificate_id: normalized.certificateId
+        }
+      ];
+    }));
+  }
+  if (config.bindings?.dispatchNamespaces) {
+    mfConfig.dispatchNamespaces = Object.fromEntries(Object.entries(config.bindings.dispatchNamespaces).map(([bindingName, binding]) => {
+      const normalized = normalizeDispatchNamespaceBinding(binding);
+      return [
+        bindingName,
+        {
+          namespace: normalized.namespace
+        }
+      ];
+    }));
+  }
+  if (config.bindings?.workflows) {
+    mfConfig.workflows = Object.fromEntries(Object.entries(config.bindings.workflows).map(([bindingName, binding]) => {
+      const normalized = normalizeWorkflowBinding(binding);
+      return [
+        bindingName,
+        {
+          name: normalized.name,
+          className: normalized.className,
+          ...normalized.scriptName && { scriptName: normalized.scriptName },
+          ...normalized.limits && { stepLimit: normalized.limits.steps }
+        }
+      ];
+    }));
+  }
+  if (config.bindings?.pipelines) {
+    mfConfig.pipelines = Object.fromEntries(Object.entries(config.bindings.pipelines).map(([bindingName, binding]) => {
+      const normalized = normalizePipelineBinding(binding);
+      return [
+        bindingName,
+        typeof binding === "string" ? normalized.pipeline : { pipeline: normalized.pipeline }
+      ];
+    }));
+  }
+  if (config.bindings?.images && localBindingShimServiceConfig.localBindingNames.length === 0) {
+    const [entry] = Object.entries(config.bindings.images);
+    if (entry) {
+      const [bindingName, binding] = entry;
+      const normalized = normalizeImagesBinding(bindingName, binding);
+      mfConfig.images = {
+        binding: normalized.binding
+      };
+    }
+  }
+  if (config.bindings?.media && localBindingShimServiceConfig.localBindingNames.length === 0) {
+    const [entry] = Object.entries(config.bindings.media);
+    if (entry) {
+      const [bindingName, binding] = entry;
+      const normalized = normalizeMediaBinding(bindingName, binding);
+      mfConfig.media = {
+        binding: normalized.binding
+      };
+    }
+  }
+  if (config.bindings?.artifacts) {
+    mfConfig.artifacts = Object.fromEntries(Object.entries(config.bindings.artifacts).map(([bindingName, binding]) => {
+      const normalized = normalizeArtifactsBinding(binding);
+      return [
+        bindingName,
+        {
+          namespace: normalized.namespace
+        }
+      ];
+    }));
+  }
+  if (config.bindings?.aiSearchNamespaces) {
+    mfConfig.aiSearchNamespaces = Object.fromEntries(Object.entries(config.bindings.aiSearchNamespaces).map(([bindingName, binding]) => [
+      bindingName,
+      {
+        namespace: binding.namespace
+      }
+    ]));
+  }
+  if (config.bindings?.aiSearch) {
+    mfConfig.aiSearchInstances = Object.fromEntries(Object.entries(config.bindings.aiSearch).map(([bindingName, binding]) => [
+      bindingName,
+      {
+        instance_name: binding.instanceName
+      }
+    ]));
+  }
+  if (config.bindings?.secretsStore) {
+    const secretsStoreEntries = Object.entries(config.bindings.secretsStore).flatMap(([bindingName, binding]) => {
+      if (localSecretBindingNames.has(bindingName)) {
+        return [];
+      }
+      const normalized = normalizeSecretsStoreBinding(binding, config.secretsStoreId, bindingName);
+      return [[
+        bindingName,
+        {
+          store_id: normalized.storeId,
+          secret_name: normalized.secretName
+        }
+      ]];
+    });
+    if (secretsStoreEntries.length > 0) {
+      mfConfig.secretsStoreSecrets = Object.fromEntries(secretsStoreEntries);
+    }
+  }
+  const wrappedBindings = {
+    ...localSecretWrappedBindingConfig?.wrappedBindings ?? {}
+  };
+  const localBindingWorkers = [
+    ...localSecretWrappedBindingConfig?.workers ?? [],
+    ...localBindingShimServiceConfig.workers
+  ];
+  if (Object.keys(wrappedBindings).length > 0) {
+    mfConfig.wrappedBindings = wrappedBindings;
+  }
+  if (localBindingShimServiceConfig.localBindingNames.length > 0) {
+    mfConfig.serviceBindings = {
+      ...mfConfig.serviceBindings ?? {},
+      ...localBindingShimServiceConfig.serviceBindings
+    };
+  }
+  if (localBindingWorkers.length > 0) {
+    mfConfig.__devflareLocalBindingWorkers = localBindingWorkers;
+  }
+  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
+        }
+      }))
+    };
+  }
+  return mfConfig;
+}
+
+// src/test/simple-context.ts
+function createTestContextState() {
+  return {
+    client: null,
+    miniflare: null,
+    envProxy: null,
+    transportDecode: null,
+    remoteBindings: null,
+    miniflareBindings: null
+  };
+}
+function shouldPreferBridgeBinding(hint) {
+  return hint === "do" || hint === "service";
+}
+async function createTestContext(configPath) {
+  const state = createTestContextState();
+  const { configDir: configDir6, config } = await resolveTestContextConfig(configPath);
+  state.remoteBindings = buildRemoteAndStaticBindings(config);
+  const hints = extractBindingHints(config);
+  const decodeTransport = (value) => decodeTransportValue(state.transportDecode, value);
+  const needsMultiWorkerForServices = hasServiceBindings(config);
+  const needsMultiWorkerForDOs = hasCrossWorkerDOs(config);
+  const needsMultiWorker = needsMultiWorkerForServices || needsMultiWorkerForDOs;
+  let serviceBindingResolution = null;
+  let doBindingResolution = null;
+  if (needsMultiWorkerForServices) {
+    serviceBindingResolution = await resolveServiceBindings(config, configDir6);
+  }
+  if (needsMultiWorkerForDOs) {
+    doBindingResolution = await resolveDOBindings(config, configDir6);
+  }
+  const mfConfig = buildInlineBridgeMfConfig(config, { cwd: configDir6 });
+  const transportFile = resolveTransportFile(configDir6, config.files?.transport);
+  if (transportFile) {
+    state.transportDecode = await loadTransportDecoders(configDir6, transportFile);
+  }
+  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) {
+    applyMultiWorkerConfig(mfConfig, config, serviceBindingResolution, doBindingResolution);
+  }
+  const usesMultiWorker = Boolean(hasMultiWorkerServices || hasMultiWorkerDOs);
+  const runtime = await bootTestRuntime(mfConfig, usesMultiWorker);
+  const activePort = runtime.activePort;
+  state.miniflare = runtime.miniflare;
+  state.miniflareBindings = runtime.miniflareBindings;
+  state.client = runtime.client;
+  const disposeContext = createDisposeContext(state);
+  const getTestEnv = () => {
+    return new Proxy({}, {
+      get(_, prop) {
+        if (state.remoteBindings && prop in state.remoteBindings) {
+          return state.remoteBindings[prop];
+        }
+        if (hints[prop] === "sendEmail" && state.envProxy && prop in state.envProxy) {
+          return state.envProxy[prop];
+        }
+        if (state.miniflareBindings && prop in state.miniflareBindings) {
+          return state.miniflareBindings[prop];
+        }
+        if (state.envProxy && prop in state.envProxy) {
+          return state.envProxy[prop];
+        }
+        return;
+      },
+      has(_, prop) {
+        return Boolean(state.remoteBindings && prop in state.remoteBindings || state.miniflareBindings && prop in state.miniflareBindings || state.envProxy && prop in state.envProxy);
+      }
+    });
+  };
+  const handlerPaths = await resolveHandlerPaths(configDir6, config);
+  configureSurfaceHandlers({
+    handlerPaths,
+    configDir: configDir6,
+    activePort,
+    getEnv: getTestEnv
+  });
+  if (usesMultiWorker) {
+    setBindingHints(hints);
+    __setTestContext(createMultiWorkerEnvAccessor(state), disposeContext);
+    return;
+  }
+  const bridgeClient = state.client;
+  if (!bridgeClient) {
+    throw new Error("Bridge-backed test context did not initialize a client.");
+  }
+  setBindingHints(hints);
+  state.envProxy = createEnvProxy({
+    client: bridgeClient,
+    transformResult: (result) => decodeTransport(result)
+  });
+  __setTestContext(createBridgeEnvAccessor(state, hints, shouldPreferBridgeBinding), disposeContext);
+}
+// src/test/cf.ts
+var cf = {
+  email,
+  queue: queue2,
   scheduled,
-  shouldSkip,
-  stopBridgeTestContext,
-  tail,
-  testEnv,
-  withTestContext,
-  worker
-} from "../index-ep3445yc.js";
-import"../index-z14anrqp.js";
-import"../index-tk6ej9dj.js";
-import"../index-d8bdkx2h.js";
-import"../index-rbht7m9r.js";
-import"../index-gz1gndna.js";
-import"../index-pf5s73n9.js";
-import"../index-07q6yxyc.js";
-import"../index-67qcae0f.js";
-import"../index-hcex3rgh.js";
-import"../index-tfyxa77h.js";
-import"../index-37x76zdn.js";
+  worker,
+  tail
+};
+// src/test/should-skip.ts
+var REMOTE_ONLY_SERVICES = new Set([
+  "ai",
+  "ai_search",
+  "ai_gateway",
+  "media",
+  "mtls_certificates",
+  "artifacts",
+  "builds",
+  "vectorize"
+]);
+var skipResults = new Map;
+var containerSkipResult = null;
+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;
+}
+function getContainerSkipResult() {
+  if (!containerSkipResult) {
+    containerSkipResult = getContainerSkipReason().then((reason) => {
+      if (reason) {
+        console.log(`CONTAINERS tests skipped: ${reason}`);
+        return true;
+      }
+      return false;
+    });
+  }
+  return containerSkipResult;
+}
+var shouldSkip = {
+  get ai() {
+    return getSkipResult("ai");
+  },
+  get aiSearch() {
+    return getSkipResult("ai_search");
+  },
+  get aiGateway() {
+    return getSkipResult("ai_gateway");
+  },
+  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");
+  },
+  get media() {
+    return getSkipResult("media");
+  },
+  get mtlsCertificates() {
+    return getSkipResult("mtls_certificates");
+  },
+  get artifacts() {
+    return getSkipResult("artifacts");
+  },
+  get builds() {
+    return getSkipResult("builds");
+  },
+  get containers() {
+    return getContainerSkipResult();
+  }
+};
+// src/test/ai-search.ts
+var MOCK_TIMESTAMP = "2026-04-26T00:00:00.000Z";
+function cloneInfo(value) {
+  return { ...value };
+}
+function extractSearchQuery(params) {
+  if ("query" in params && typeof params.query === "string") {
+    return params.query;
+  }
+  const messages = "messages" in params ? params.messages : [];
+  return messages.filter((message) => message.role === "user" && message.content).map((message) => message.content).join(" ");
+}
+function tokenize(value) {
+  return value.toLowerCase().split(/[^a-z0-9_]+/).filter((token) => token.length > 2);
+}
+function scoreText(query, text) {
+  const tokens = tokenize(query);
+  if (tokens.length === 0) {
+    return 1;
+  }
+  const haystack = text.toLowerCase();
+  const matches = tokens.filter((token) => haystack.includes(token)).length;
+  return matches === 0 ? 0 : Math.max(0.1, matches / tokens.length);
+}
+function streamFromText(text) {
+  const encoded = new TextEncoder().encode(text);
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoded);
+      controller.close();
+    }
+  });
+}
+async function contentToText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (content instanceof Blob) {
+    return content.text();
+  }
+  return new Response(content).text();
+}
+function createItemInfo(id, key, content, options = {}) {
+  return {
+    id,
+    key,
+    status: options.status ?? "completed",
+    next_action: null,
+    namespace: options.namespace,
+    chunks_count: content.length > 0 ? 1 : 0,
+    file_size: new TextEncoder().encode(content).byteLength,
+    source_id: options.sourceId ?? null,
+    last_seen_at: MOCK_TIMESTAMP,
+    created_at: MOCK_TIMESTAMP,
+    metadata: options.metadata
+  };
+}
+function createItemChunks(item, chunks) {
+  let offset = 0;
+  return chunks.map((text, index) => {
+    const start = offset;
+    const end = start + new TextEncoder().encode(text).byteLength;
+    offset = end;
+    return {
+      id: `${item.id}:chunk-${index + 1}`,
+      text,
+      start_byte: start,
+      end_byte: end,
+      item: {
+        timestamp: Date.parse(MOCK_TIMESTAMP),
+        key: item.key,
+        metadata: item.metadata
+      }
+    };
+  });
+}
+function createStoredItem(sequence, fixture, namespace) {
+  const content = fixture.content ?? fixture.chunks?.join(`
+`) ?? "";
+  const id = fixture.id ?? `item-${sequence}`;
+  const info = createItemInfo(id, fixture.key, content, {
+    metadata: fixture.metadata,
+    status: fixture.status,
+    namespace
+  });
+  const chunks = createItemChunks(info, fixture.chunks ?? [content]);
+  return {
+    info,
+    content,
+    contentType: fixture.contentType ?? "text/plain",
+    chunks,
+    logs: [
+      {
+        timestamp: MOCK_TIMESTAMP,
+        action: "index",
+        message: `Indexed ${fixture.key}`,
+        fileKey: fixture.key,
+        chunkCount: chunks.length,
+        processingTimeMs: 0
+      }
+    ]
+  };
+}
+function isAISearchInstance(value) {
+  return typeof value.search === "function";
+}
+function createMockAISearchInstance(options = {}) {
+  const instanceId = options.id ?? options.info?.id ?? "mock-ai-search";
+  const namespace = options.namespace ?? options.info?.namespace;
+  const items = new Map;
+  const jobs = new Map;
+  const searches = [];
+  let itemSequence = 0;
+  let jobSequence = 0;
+  let info = {
+    id: instanceId,
+    type: "builtin",
+    namespace,
+    status: "ready",
+    created_at: MOCK_TIMESTAMP,
+    modified_at: MOCK_TIMESTAMP,
+    index_method: {
+      vector: true,
+      keyword: true
+    },
+    fusion_method: "rrf",
+    ...options.info
+  };
+  for (const fixture of options.items ?? []) {
+    const stored = createStoredItem(++itemSequence, fixture, namespace);
+    items.set(stored.info.id, stored);
+  }
+  const findMatches = (params) => {
+    searches.push(params);
+    const query = extractSearchQuery(params);
+    const maxResults = params.ai_search_options?.retrieval?.max_num_results ?? 10;
+    const chunks = [];
+    for (const item of items.values()) {
+      for (const chunk of item.chunks) {
+        const score = scoreText(query, `${item.info.key} ${chunk.text}`);
+        if (score === 0) {
+          continue;
+        }
+        chunks.push({
+          id: chunk.id,
+          type: "text",
+          score,
+          text: chunk.text,
+          item: {
+            timestamp: Date.parse(MOCK_TIMESTAMP),
+            key: item.info.key,
+            metadata: item.info.metadata
+          },
+          scoring_details: {
+            keyword_score: score,
+            vector_score: score,
+            keyword_rank: chunks.length + 1,
+            vector_rank: chunks.length + 1,
+            fusion_method: "rrf"
+          }
+        });
+      }
+    }
+    return {
+      search_query: query,
+      chunks: chunks.slice(0, maxResults)
+    };
+  };
+  const createItemHandle = (itemId) => ({
+    async info() {
+      const item = items.get(itemId);
+      if (!item) {
+        throw new Error(`Mock AI Search item "${itemId}" was not found.`);
+      }
+      return cloneInfo(item.info);
+    },
+    async download() {
+      const item = items.get(itemId);
+      if (!item) {
+        throw new Error(`Mock AI Search item "${itemId}" was not found.`);
+      }
+      return {
+        body: streamFromText(item.content),
+        contentType: item.contentType,
+        filename: item.info.key,
+        size: new TextEncoder().encode(item.content).byteLength
+      };
+    },
+    async sync() {
+      const item = items.get(itemId);
+      if (!item) {
+        throw new Error(`Mock AI Search item "${itemId}" was not found.`);
+      }
+      item.info.status = "completed";
+      item.info.last_seen_at = MOCK_TIMESTAMP;
+      return cloneInfo(item.info);
+    },
+    async logs(params) {
+      const item = items.get(itemId);
+      if (!item) {
+        throw new Error(`Mock AI Search item "${itemId}" was not found.`);
+      }
+      const limit = params?.limit ?? 50;
+      const result = item.logs.slice(0, limit);
+      return {
+        result,
+        result_info: {
+          count: result.length,
+          per_page: limit,
+          cursor: null,
+          truncated: item.logs.length > result.length
+        }
+      };
+    },
+    async chunks(params) {
+      const item = items.get(itemId);
+      if (!item) {
+        throw new Error(`Mock AI Search item "${itemId}" was not found.`);
+      }
+      const offset = params?.offset ?? 0;
+      const limit = params?.limit ?? 20;
+      const result = item.chunks.slice(offset, offset + limit);
+      return {
+        result,
+        result_info: {
+          count: result.length,
+          total: item.chunks.length,
+          limit,
+          offset
+        }
+      };
+    }
+  });
+  const uploadItem = async (name, content, uploadOptions) => {
+    const text = await contentToText(content);
+    const existing = Array.from(items.values()).find((item) => item.info.key === name);
+    const stored = createStoredItem(existing ? Number(existing.info.id.replace(/^item-/, "")) || ++itemSequence : ++itemSequence, {
+      id: existing?.info.id,
+      key: name,
+      content: text,
+      metadata: uploadOptions?.metadata
+    }, namespace);
+    items.set(stored.info.id, stored);
+    return cloneInfo(stored.info);
+  };
+  const itemsApi = {
+    async list(params) {
+      let result = Array.from(items.values()).map((item) => cloneInfo(item.info));
+      if (params?.search) {
+        const search = params.search.toLowerCase();
+        result = result.filter((item) => item.key.toLowerCase().includes(search));
+      }
+      if (params?.status) {
+        result = result.filter((item) => item.status === params.status);
+      }
+      const page = params?.page ?? 1;
+      const perPage = (params?.per_page ?? result.length) || 50;
+      const start = (page - 1) * perPage;
+      const paged = result.slice(start, start + perPage);
+      return {
+        result: paged,
+        result_info: {
+          count: paged.length,
+          page,
+          per_page: perPage,
+          total_count: result.length
+        }
+      };
+    },
+    upload: uploadItem,
+    async uploadAndPoll(name, content, uploadOptions) {
+      return uploadItem(name, content, uploadOptions);
+    },
+    get(itemId) {
+      return createItemHandle(itemId);
+    },
+    async delete(itemId) {
+      items.delete(itemId);
+    }
+  };
+  const createJobHandle = (jobId) => ({
+    async info() {
+      const job = jobs.get(jobId);
+      if (!job) {
+        throw new Error(`Mock AI Search job "${jobId}" was not found.`);
+      }
+      return cloneInfo(job);
+    },
+    async logs(params) {
+      const perPage = params?.per_page ?? 50;
+      return {
+        result: [
+          {
+            id: 1,
+            message: `Mock job ${jobId}`,
+            message_type: 0,
+            created_at: Date.parse(MOCK_TIMESTAMP)
+          }
+        ].slice(0, perPage),
+        result_info: {
+          count: 1,
+          page: params?.page ?? 1,
+          per_page: perPage,
+          total_count: 1
+        }
+      };
+    },
+    async cancel() {
+      const job = jobs.get(jobId);
+      if (!job) {
+        throw new Error(`Mock AI Search job "${jobId}" was not found.`);
+      }
+      const updated = {
+        ...job,
+        ended_at: MOCK_TIMESTAMP,
+        end_reason: "cancelled"
+      };
+      jobs.set(jobId, updated);
+      return cloneInfo(updated);
+    }
+  });
+  const jobsApi = {
+    async list(params) {
+      const allJobs = Array.from(jobs.values()).map((job) => cloneInfo(job));
+      const page = params?.page ?? 1;
+      const perPage = (params?.per_page ?? allJobs.length) || 50;
+      const start = (page - 1) * perPage;
+      const result = allJobs.slice(start, start + perPage);
+      return {
+        result,
+        result_info: {
+          count: result.length,
+          page,
+          per_page: perPage,
+          total_count: allJobs.length
+        }
+      };
+    },
+    async create(params) {
+      const id = `job-${++jobSequence}`;
+      const job = {
+        id,
+        source: "user",
+        description: params?.description,
+        started_at: MOCK_TIMESTAMP
+      };
+      jobs.set(id, job);
+      return cloneInfo(job);
+    },
+    get(jobId) {
+      return createJobHandle(jobId);
+    }
+  };
+  return {
+    async search(params) {
+      return findMatches(params);
+    },
+    async chatCompletions(params) {
+      const search = findMatches({
+        messages: params.messages,
+        ai_search_options: params.ai_search_options
+      });
+      const content = typeof options.chatMessage === "function" ? options.chatMessage(search.chunks, params) : options.chatMessage ?? (search.chunks.map((chunk) => chunk.text).join(`
+`) || "No matching offline AI Search chunks.");
+      if (params.stream) {
+        const payload = JSON.stringify({
+          choices: [{ delta: { content } }],
+          chunks: search.chunks
+        });
+        return streamFromText(`data: ${payload}
+
+`);
+      }
+      return {
+        id: "mock-ai-search-chat",
+        object: "chat.completion",
+        model: params.model ?? "mock-ai-search",
+        choices: [
+          {
+            index: 0,
+            message: {
+              role: "assistant",
+              content
+            }
+          }
+        ],
+        chunks: search.chunks
+      };
+    },
+    async update(config) {
+      info = {
+        ...info,
+        ...config,
+        modified_at: MOCK_TIMESTAMP
+      };
+      return cloneInfo(info);
+    },
+    async info() {
+      return cloneInfo(info);
+    },
+    async stats() {
+      const stats = {
+        queued: 0,
+        running: 0,
+        completed: 0,
+        error: 0,
+        skipped: 0,
+        outdated: 0,
+        last_activity: MOCK_TIMESTAMP,
+        engine: {
+          vectorize: {
+            vectorsCount: items.size,
+            dimensions: 0
+          },
+          r2: {
+            payloadSizeBytes: Array.from(items.values()).reduce((sum, item) => sum + item.info.file_size, 0),
+            metadataSizeBytes: 0,
+            objectCount: items.size
+          }
+        }
+      };
+      for (const item of items.values()) {
+        stats[item.info.status] = (stats[item.info.status] ?? 0) + 1;
+      }
+      return stats;
+    },
+    get items() {
+      return itemsApi;
+    },
+    get jobs() {
+      return jobsApi;
+    },
+    _getSearches() {
+      return [...searches];
+    },
+    _getItems() {
+      return Array.from(items.values()).map((item) => cloneInfo(item.info));
+    },
+    _getJobs() {
+      return Array.from(jobs.values()).map((job) => cloneInfo(job));
+    }
+  };
+}
+function createMockAISearchNamespace(options = {}) {
+  const namespaceName = options.namespace ?? "default";
+  const instances = new Map;
+  for (const [name, instanceOptions] of Object.entries(options.instances ?? {})) {
+    instances.set(name, isAISearchInstance(instanceOptions) ? instanceOptions : createMockAISearchInstance({
+      id: name,
+      namespace: namespaceName,
+      ...instanceOptions
+    }));
+  }
+  const getInstance = (name) => {
+    const instance = instances.get(name);
+    if (!instance) {
+      throw new Error(`Mock AI Search namespace has no instance named "${name}".`);
+    }
+    return instance;
+  };
+  return {
+    get(name) {
+      return getInstance(name);
+    },
+    async list(params) {
+      let result = await Promise.all(Array.from(instances.entries()).map(async ([name, instance]) => ({
+        ...await instance.info(),
+        namespace: namespaceName,
+        id: name
+      })));
+      if (params?.search) {
+        const search = params.search.toLowerCase();
+        result = result.filter((instance) => instance.id.toLowerCase().includes(search));
+      }
+      const page = params?.page ?? 1;
+      const perPage = (params?.per_page ?? result.length) || 50;
+      const start = (page - 1) * perPage;
+      const paged = result.slice(start, start + perPage);
+      return {
+        result: paged,
+        result_info: {
+          count: paged.length,
+          page,
+          per_page: perPage,
+          total_count: result.length
+        }
+      };
+    },
+    async create(config) {
+      const instance = createMockAISearchInstance({
+        id: config.id,
+        namespace: namespaceName,
+        info: config
+      });
+      instances.set(config.id, instance);
+      return instance;
+    },
+    async delete(name) {
+      instances.delete(name);
+    },
+    async search(params) {
+      const query = extractSearchQuery(params);
+      const chunks = [];
+      const errors = [];
+      for (const instanceId of params.ai_search_options.instance_ids) {
+        const instance = instances.get(instanceId);
+        if (!instance) {
+          errors.push({
+            instance_id: instanceId,
+            message: `Mock AI Search namespace has no instance named "${instanceId}".`
+          });
+          continue;
+        }
+        const response = "query" in params ? await instance.search({ query, ai_search_options: params.ai_search_options }) : await instance.search({
+          messages: params.messages,
+          ai_search_options: params.ai_search_options
+        });
+        chunks.push(...response.chunks.map((chunk) => ({
+          ...chunk,
+          instance_id: instanceId
+        })));
+      }
+      return {
+        search_query: query,
+        chunks,
+        ...errors.length > 0 && { errors }
+      };
+    },
+    async chatCompletions(params) {
+      const search = await this.search({
+        messages: params.messages,
+        ai_search_options: params.ai_search_options
+      });
+      const content = search.chunks.map((chunk) => chunk.text).join(`
+`) || "No matching offline AI Search chunks.";
+      if (params.stream) {
+        return streamFromText(`data: ${JSON.stringify({ chunks: search.chunks })}
+
+`);
+      }
+      return {
+        id: "mock-ai-search-namespace-chat",
+        object: "chat.completion",
+        model: params.model ?? "mock-ai-search",
+        choices: [
+          {
+            index: 0,
+            message: {
+              role: "assistant",
+              content
+            }
+          }
+        ],
+        chunks: search.chunks,
+        errors: search.errors
+      };
+    },
+    _getInstances() {
+      return Array.from(instances.keys());
+    }
+  };
+}
+
+// src/test/offline-bindings.ts
+var SUPPORT_MATRIX = {
+  rateLimits: {
+    service: "rateLimits",
+    tier: "offline-native",
+    reason: "Miniflare and devflare/test can simulate fixed-window RateLimit bindings locally.",
+    recommendation: "Use createOfflineEnv() or createMockRateLimit() for pure tests; use createTestContext() for Miniflare-backed tests."
+  },
+  versionMetadata: {
+    service: "versionMetadata",
+    tier: "offline-native",
+    reason: "Version metadata can be deterministic in tests without Cloudflare state.",
+    recommendation: "Use createOfflineEnv() or createMockVersionMetadata() when asserting version-aware code."
+  },
+  secretsStore: {
+    service: "secretsStore",
+    tier: "offline-native",
+    reason: "Secrets Store binding shape is local-testable with local secret-store values or fixed fixtures.",
+    recommendation: "Use devflare secrets --local for dev/test values, or pass fixtures.secretsStore values for pure tests."
+  },
+  hyperdrive: {
+    service: "hyperdrive",
+    tier: "offline-native",
+    reason: "Hyperdrive can run locally through Miniflare when Devflare has a local connection string or test fixture for the target database.",
+    recommendation: "Use bindings.hyperdrive.*.localConnectionString, CLOUDFLARE_HYPERDRIVE_LOCAL_CONNECTION_STRING_<BINDING>, or fixtures.hyperdrive for offline tests."
+  },
+  workerLoaders: {
+    service: "workerLoaders",
+    tier: "offline-native",
+    reason: "Worker Loader bindings run locally through Miniflare and can use explicit Worker stubs for pure tests.",
+    recommendation: "Use createTestContext() for local WorkerLoader execution; pass fixtures.workerLoaders with a WorkerStub for pure tests."
+  },
+  mtlsCertificates: {
+    service: "mtlsCertificates",
+    tier: "offline-fixture",
+    reason: "Fetcher call paths can be tested locally, but real certificate presentation is Cloudflare/Wrangler remote behavior.",
+    recommendation: "Pass fixtures.mtlsCertificates handlers for unit tests; use remote/deployed tests for certificate presentation."
+  },
+  dispatchNamespaces: {
+    service: "dispatchNamespaces",
+    tier: "offline-fixture",
+    reason: "Tenant dispatch can be backed by explicit test fetchers, but namespace uploads and lifecycle are Cloudflare-managed.",
+    recommendation: "Pass fixtures.dispatchNamespaces workers for deterministic tenant routing tests."
+  },
+  workflows: {
+    service: "workflows",
+    tier: "offline-native",
+    reason: "Workflow binding calls can run through Miniflare or a deterministic local Workflow mock for app-level tests.",
+    recommendation: "Use createOfflineEnv() for pure tests and createTestContext() when Miniflare execution semantics matter."
+  },
+  pipelines: {
+    service: "pipelines",
+    tier: "offline-native",
+    reason: "Pipeline sends can be recorded locally; Cloudflare owns production batching and sinks.",
+    recommendation: "Use createOfflineEnv() or createMockPipeline() to assert records sent by application code."
+  },
+  images: {
+    service: "images",
+    tier: "offline-native",
+    reason: "Images has local development support and Devflare provides a low-fidelity deterministic pure mock.",
+    recommendation: "Use createOfflineEnv() for chain-shape tests; use Cloudflare for hosted image APIs and transform fidelity."
+  },
+  media: {
+    service: "media",
+    tier: "offline-native",
+    reason: "Media Transformations can run through Miniflare wiring locally, and Devflare provides a deterministic pure mock for app-level chain tests.",
+    recommendation: "Use createTestContext() for local Worker binding tests and createMockMediaBinding() for pure tests; use Cloudflare for codec/output fidelity."
+  },
+  artifacts: {
+    service: "artifacts",
+    tier: "offline-fixture",
+    reason: "Artifacts repo metadata and token flows can be modeled in memory; real Git remotes are Cloudflare-managed.",
+    recommendation: "Use createMockArtifacts() for unit tests; use Cloudflare for Git protocol and namespace access."
+  },
+  aiSearch: {
+    service: "aiSearch",
+    tier: "offline-fixture",
+    reason: "AI Search application flows can use deterministic in-memory instances and namespaces, but indexing/ranking/crawling are hosted Cloudflare behavior.",
+    recommendation: "Use createMockAISearchInstance(), createMockAISearchNamespace(), or createOfflineEnv(); use remote tests for real relevance behavior."
+  },
+  aiSearchNamespaces: {
+    service: "aiSearchNamespaces",
+    tier: "offline-fixture",
+    reason: "AI Search namespace management can be backed by an explicit in-memory instance registry for tests.",
+    recommendation: "Use fixtures.aiSearchNamespaces to model tenant instances and multi-instance searches."
+  },
+  containers: {
+    service: "containers",
+    tier: "offline-native",
+    reason: "Devflare can launch local Docker/Podman containers in explicit tests when an engine and cached images are available.",
+    recommendation: "Use devflare/test containers helpers and shouldSkip.containers; keep ordinary unit tests engine-free."
+  },
+  browser: {
+    service: "browser",
+    tier: "offline-native",
+    reason: "Cloudflare lists Browser Run as locally simulatable, while live view, HITL, recordings, and external CDP remain hosted features.",
+    recommendation: "Use Cloudflare/Wrangler Browser local development for browser execution and remote/deployed tests for hosted-only features."
+  },
+  ai: {
+    service: "ai",
+    tier: "remote-boundary",
+    reason: "Workers AI inference has no local simulation in Cloudflare local development.",
+    recommendation: "Use DEVFLARE_REMOTE=1/devflare remote enable for real calls, or inject a custom fake for pure tests."
+  },
+  aiGateway: {
+    service: "aiGateway",
+    tier: "remote-boundary",
+    reason: "AI Gateway routing and logs are Cloudflare account resources reached through the Workers AI binding.",
+    recommendation: "Use remote-mode AI Gateway helpers for integration tests and custom fakes for offline unit tests."
+  },
+  vectorize: {
+    service: "vectorize",
+    tier: "remote-boundary",
+    reason: "Cloudflare lists Vectorize with no local simulation.",
+    recommendation: "Use DEVFLARE_REMOTE=1/devflare remote enable for real indexes, or inject a fake Vectorize binding for pure tests."
+  },
+  builds: {
+    service: "builds",
+    tier: "remote-boundary",
+    reason: "Cloudflare Builds/Git-connected Workers are CI/CD orchestration, not a Worker runtime binding.",
+    recommendation: "Run Devflare commands inside your CI; validate Cloudflare build integration with Cloudflare/Wrangler tests."
+  }
+};
+function copySupport(entry) {
+  return { ...entry };
+}
+function getOfflineSupportMatrix() {
+  return Object.fromEntries(Object.entries(SUPPORT_MATRIX).map(([service, entry]) => [service, copySupport(entry)]));
+}
+function describeOfflineSupport(service) {
+  const entry = SUPPORT_MATRIX[service];
+  if (entry) {
+    return copySupport(entry);
+  }
+  return {
+    service,
+    tier: "remote-boundary",
+    reason: `No offline support classification exists for "${service}".`,
+    recommendation: "Treat this as a remote Cloudflare boundary until Devflare documents a local simulator or fixture."
+  };
+}
+function createMissingSecret(binding) {
+  return {
+    async get() {
+      throw new Error(`Offline Secrets Store binding "${binding}" has no value. Pass fixtures.secretsStore.${binding} or write a local secret with devflare secrets --local.`);
+    }
+  };
+}
+function isWorkflowBinding(value) {
+  return typeof value.create === "function";
+}
+function isPipelineBinding(value) {
+  return typeof value?.send === "function";
+}
+function isImagesBinding(value) {
+  return typeof value?.input === "function";
+}
+function isHyperdriveBinding(value) {
+  return typeof value?.connectionString === "string";
+}
+function isMediaBinding(value) {
+  return typeof value?.input === "function";
+}
+function isArtifactsBinding2(value) {
+  return typeof value?.create === "function";
+}
+function isAISearchInstance2(value) {
+  return typeof value?.search === "function";
+}
+function isAISearchNamespace(value) {
+  return typeof value?.get === "function";
+}
+function addBoundary(remoteBoundaries, service, binding, reason) {
+  remoteBoundaries.push({
+    service,
+    binding,
+    reason,
+    recommendation: describeOfflineSupport(service).recommendation
+  });
+}
+function addStaticBindings(env3, config) {
+  if (config.vars) {
+    Object.assign(env3, config.vars);
+  }
+}
+function addRateLimitBindings(env3, bindings) {
+  for (const [name, binding] of Object.entries(bindings?.rateLimits ?? {})) {
+    env3[name] = createMockRateLimit(binding.simple);
+  }
+}
+function addVersionMetadataBinding(env3, bindings) {
+  if (bindings?.versionMetadata) {
+    env3[bindings.versionMetadata.binding] = createMockVersionMetadata();
+  }
+}
+function getHyperdriveConnectionString(name, binding, fixture) {
+  if (typeof fixture === "string") {
+    return fixture;
+  }
+  const envValue = process.env[`CLOUDFLARE_HYPERDRIVE_LOCAL_CONNECTION_STRING_${name}`] ?? process.env[`WRANGLER_HYPERDRIVE_LOCAL_CONNECTION_STRING_${name}`];
+  if (envValue?.trim()) {
+    return envValue;
+  }
+  return normalizeHyperdriveBinding(binding).localConnectionString;
+}
+function addHyperdriveBindings(env3, bindings, fixtures, missingFixtures) {
+  for (const [name, binding] of Object.entries(bindings?.hyperdrive ?? {})) {
+    const fixture = fixtures.hyperdrive?.[name];
+    if (isHyperdriveBinding(fixture)) {
+      env3[name] = fixture;
+      continue;
+    }
+    const connectionString = getHyperdriveConnectionString(name, binding, fixture);
+    if (connectionString) {
+      env3[name] = createMockHyperdrive(connectionString);
+      continue;
+    }
+    missingFixtures.push({
+      service: "hyperdrive",
+      binding: name,
+      reason: `Hyperdrive binding "${name}" has no local connection string. Configure bindings.hyperdrive.${name}.localConnectionString or pass fixtures.hyperdrive.${name}.`
+    });
+  }
+}
+function addWorkerLoaderBindings(env3, bindings, fixtures) {
+  for (const name of Object.keys(bindings?.workerLoaders ?? {})) {
+    env3[name] = createMockWorkerLoader(fixtures.workerLoaders?.[name]);
+  }
+}
+function addMTLSCertificateBindings(env3, bindings, fixtures) {
+  for (const name of Object.keys(bindings?.mtlsCertificates ?? {})) {
+    env3[name] = createMockMTLSCertificate(fixtures.mtlsCertificates?.[name]);
+  }
+}
+function addDispatchNamespaceBindings(env3, bindings, fixtures) {
+  for (const name of Object.keys(bindings?.dispatchNamespaces ?? {})) {
+    env3[name] = createMockDispatchNamespace(fixtures.dispatchNamespaces?.[name]);
+  }
+}
+function addWorkflowBindings(env3, bindings, fixtures) {
+  for (const name of Object.keys(bindings?.workflows ?? {})) {
+    const fixture = fixtures.workflows?.[name];
+    env3[name] = fixture && isWorkflowBinding(fixture) ? fixture : createMockWorkflow(fixture);
+  }
+}
+function addPipelineBindings(env3, bindings, fixtures) {
+  for (const name of Object.keys(bindings?.pipelines ?? {})) {
+    const fixture = fixtures.pipelines?.[name];
+    env3[name] = isPipelineBinding(fixture) ? fixture : createMockPipeline();
+  }
+}
+function addImagesBindings(env3, bindings, fixtures) {
+  for (const name of Object.keys(bindings?.images ?? {})) {
+    const fixture = fixtures.images?.[name];
+    env3[name] = isImagesBinding(fixture) ? fixture : createMockImagesBinding(fixture);
+  }
+}
+function addMediaBindings(env3, bindings, fixtures) {
+  for (const name of Object.keys(bindings?.media ?? {})) {
+    const fixture = fixtures.media?.[name];
+    env3[name] = isMediaBinding(fixture) ? fixture : createMockMediaBinding(fixture);
+  }
+}
+function addArtifactsBindings(env3, bindings, fixtures) {
+  for (const name of Object.keys(bindings?.artifacts ?? {})) {
+    const fixture = fixtures.artifacts?.[name];
+    env3[name] = isArtifactsBinding2(fixture) ? fixture : createMockArtifacts(fixture);
+  }
+}
+function addSecretsStoreBindings(env3, bindings, fixtures, localSecretValues, missingFixtures) {
+  for (const name of Object.keys(bindings?.secretsStore ?? {})) {
+    const value = fixtures.secretsStore?.[name] ?? localSecretValues[name];
+    if (value === undefined) {
+      missingFixtures.push({
+        service: "secretsStore",
+        binding: name,
+        reason: `Secrets Store values are not present in fixtures or the local secret store; pass fixtures.secretsStore.${name} or run devflare secrets --local.`
+      });
+      env3[name] = createMissingSecret(name);
+    } else {
+      env3[name] = createMockSecretsStoreSecret(value);
+    }
+  }
+}
+function addAISearchBindings(env3, bindings, fixtures) {
+  for (const [name, binding] of Object.entries(bindings?.aiSearch ?? {})) {
+    const fixture = fixtures.aiSearch?.[name];
+    env3[name] = isAISearchInstance2(fixture) ? fixture : createMockAISearchInstance({
+      id: binding.instanceName,
+      ...fixture
+    });
+  }
+}
+function addAISearchNamespaceBindings(env3, bindings, fixtures) {
+  for (const [name, binding] of Object.entries(bindings?.aiSearchNamespaces ?? {})) {
+    const fixture = fixtures.aiSearchNamespaces?.[name];
+    env3[name] = isAISearchNamespace(fixture) ? fixture : createMockAISearchNamespace({
+      namespace: binding.namespace,
+      ...fixture
+    });
+  }
+}
+function addRemoteBoundaries(remoteBoundaries, bindings) {
+  if (bindings?.ai) {
+    addBoundary(remoteBoundaries, "ai", bindings.ai.binding || "AI", "Workers AI inference is not available in offline local simulations.");
+  }
+  for (const name of Object.keys(bindings?.vectorize ?? {})) {
+    addBoundary(remoteBoundaries, "vectorize", name, "Vectorize has no offline local simulation in Cloudflare local development.");
+  }
+}
+function createOfflineBindings(config, fixtures = {}, options = {}) {
+  const env3 = {};
+  const remoteBoundaries = [];
+  const missingFixtures = [];
+  const bindings = config.bindings;
+  const localSecretValues = options.cwd && options.useLocalSecrets !== false ? resolveLocalSecretValuesForBindings(config, options.cwd) : {};
+  addStaticBindings(env3, config);
+  addRateLimitBindings(env3, bindings);
+  addVersionMetadataBinding(env3, bindings);
+  addHyperdriveBindings(env3, bindings, fixtures, missingFixtures);
+  addWorkerLoaderBindings(env3, bindings, fixtures);
+  addMTLSCertificateBindings(env3, bindings, fixtures);
+  addDispatchNamespaceBindings(env3, bindings, fixtures);
+  addWorkflowBindings(env3, bindings, fixtures);
+  addPipelineBindings(env3, bindings, fixtures);
+  addImagesBindings(env3, bindings, fixtures);
+  addMediaBindings(env3, bindings, fixtures);
+  addArtifactsBindings(env3, bindings, fixtures);
+  addSecretsStoreBindings(env3, bindings, fixtures, localSecretValues, missingFixtures);
+  addAISearchBindings(env3, bindings, fixtures);
+  addAISearchNamespaceBindings(env3, bindings, fixtures);
+  addRemoteBoundaries(remoteBoundaries, bindings);
+  if (fixtures.custom) {
+    Object.assign(env3, fixtures.custom);
+  }
+  return {
+    env: env3,
+    support: getOfflineSupportMatrix(),
+    remoteBoundaries,
+    missingFixtures
+  };
+}
+function createOfflineEnv(config, fixtures = {}, options = {}) {
+  return createOfflineBindings(config, fixtures, options).env;
+}
 export {
   worker,
   withTestContext,
-  testEnv,
   tail,
-  stopBridgeTestContext,
+  stopActiveContainers,
   shouldSkip,
   scheduled,
   resolveServiceBindings,
   resolveDOBindings,
-  queue,
-  isRemoteModeEnabled,
+  queue2 as queue,
   hasServiceBindings,
   hasCrossWorkerDOs,
-  getBridgeTestContext,
+  getOfflineSupportMatrix,
+  getContainerSkipReason,
   env,
   email,
+  detectContainerEngine,
+  describeOfflineSupport,
   createTestContext,
-  createMultiWorkerContext,
+  createOfflineEnv,
+  createOfflineBindings,
+  createMockWorkflow,
+  createMockWorkerLoader,
+  createMockVersionMetadata,
   createMockTestContext,
+  createMockSecretsStoreSecret,
+  createMockRateLimit,
   createMockR2,
   createMockQueue,
+  createMockPipeline,
+  createMockMediaBinding,
+  createMockMTLSCertificate,
   createMockKV,
+  createMockImagesBinding,
+  createMockHyperdrive,
   createMockEnv,
+  createMockDispatchNamespace,
   createMockD1,
-  createEntrypointScript,
-  createBridgeTestContext,
+  createMockArtifacts,
+  createMockAISearchNamespace,
+  createMockAISearchInstance,
+  createContainerManager,
+  containers,
   clearBundleCache,
   cf
 };