devflare 1.0.0-next.4 → 1.0.0-next.41

package/dist/test/index.js

@@ -1,71 +1,4496 @@
-import {
-  cf,
-  clearBundleCache,
-  createBridgeTestContext,
-  createEntrypointScript,
-  createMockD1,
-  createMockEnv,
-  createMockKV,
-  createMockQueue,
-  createMockR2,
-  createMockTestContext,
-  createMultiWorkerContext,
-  createTestContext,
-  email,
-  env,
-  getBridgeTestContext,
-  hasCrossWorkerDOs,
-  hasServiceBindings,
-  isRemoteModeEnabled,
-  queue,
-  resolveDOBindings,
-  resolveServiceBindings,
-  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";
-export {
-  worker,
-  withTestContext,
-  testEnv,
-  tail,
-  stopBridgeTestContext,
-  shouldSkip,
-  scheduled,
-  resolveServiceBindings,
-  resolveDOBindings,
-  queue,
-  isRemoteModeEnabled,
-  hasServiceBindings,
-  hasCrossWorkerDOs,
-  getBridgeTestContext,
-  env,
-  email,
-  createTestContext,
-  createMultiWorkerContext,
-  createMockTestContext,
-  createMockR2,
-  createMockQueue,
-  createMockKV,
-  createMockEnv,
-  createMockD1,
-  createEntrypointScript,
-  createBridgeTestContext,
-  clearBundleCache,
-  cf
+import { d as resolveConfigEnvVars } from "../_chunks/preview-BhqDmq8I.js";
+import { i as resolveConfigPath, r as loadConfig } from "../_chunks/loader-DLXO60RO.js";
+import { c as normalizeHyperdriveBinding, d as normalizeMediaBinding, f as normalizeMtlsCertificateBinding, h as normalizeWorkflowBinding, i as normalizeArtifactsBinding, l as normalizeImagesBinding, m as normalizeSecretsStoreBinding, o as normalizeDOBinding, p as normalizePipelineBinding, s as normalizeDispatchNamespaceBinding, t as getLocalD1DatabaseIdentifier } from "../_chunks/schema-normalization-DWVleVxo.js";
+import { t as applyLocalDevVarsToConfig } from "../_chunks/local-dev-vars-CTSa-wvF.js";
+import { g as isAuthenticated, p as getApiToken } from "../_chunks/api-TzdliH-6.js";
+import { d as getPrimaryAccount, n as getEffectiveAccountId } from "../_chunks/preferences-BKp_7XJx.js";
+import { A as createTailEvent, D as createFetchEvent, E as createEmailEvent, F as BridgeClient, M as createEnvProxy, O as createQueueEvent, P as setBindingHints, _ as runWithContext, k as createScheduledEvent, v as runWithEventContext } from "../_chunks/context-CX50Y2Kb.js";
+import { createLocalSendEmailBinding, wrapEnvSendEmailBindings } from "../utils/send-email.js";
+import { n as __setTestContext, r as env, t as __clearTestContext } from "../_chunks/env-S0_nMVz1.js";
+import { d as invokeFetchModule, m as resolveFetchHandler, r as matchFetchRoute, t as createRouteResolve } from "../_chunks/runtime-FvXvfuZ2.js";
+import { i as extractBindingHints, n as createLocalWorkerLoaderBinding, r as disposeLocalWorkerLoaderBindings, t as createLocalHyperdrive } from "../_chunks/local-hyperdrive-CJ90j46O.js";
+import { a as hasServiceBindings, f as buildHyperdrivesConfig, i as hasCrossWorkerDOs, o as resolveDOBindings, r as clearBundleCache, s as resolveServiceBindings, t as discoverRoutes } from "../_chunks/routes-C3FqES2W.js";
+import { i as findFiles, t as DEFAULT_DO_PATTERN } from "../_chunks/glob-CmQOvunB.js";
+import { a as isRemoteModeActive, i as getRemoteModeStatus } from "../_chunks/remote-config-D39BY9ji.js";
+import { t as bundleWorkflowEntrypointScript } from "../_chunks/local-workflow-entrypoints-Wip3o1u8.js";
+import { a as resolveLocalSecretValuesForBindings, n as buildLocalSecretWrappedBindingConfig } from "../_chunks/local-secrets-DMmEOygL.js";
+import { t as buildLocalBindingShimServiceConfig } from "../_chunks/local-media-bindings-DsAW4AMF.js";
+import { t as canProceedWithTest } from "../_chunks/usage-BBTGzjon.js";
+import { existsSync } from "node:fs";
+import { stat } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { existsSync as existsSync$1, mkdirSync as mkdirSync$1, writeFileSync as writeFileSync$1 } from "fs";
+import { dirname as dirname$1, join as join$1, resolve as resolve$1 } from "path";
+import { readFile as readFile$1 } from "fs/promises";
+import { createServer } from "net";
+import { fileURLToPath } from "url";
+import { createHash, randomUUID } from "node:crypto";
+import { createConnection } from "node:net";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { execa } from "execa";
+//#region 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
+	};
+}
+//#endregion
+//#region 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 baseUrl = `https://gateway.ai.cloudflare.com/v1/${encodePathSegment(await cloudflare.getAccountId())}/${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;
+}
+/**
+* Creates a remote AI binding that calls Cloudflare's REST API.
+* Matches the Workers AI binding interface.
+*/
+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;
+}
+//#endregion
+//#region src/test/remote-vectorize.ts
+/**
+* Creates a remote Vectorize binding that calls Cloudflare's REST API.
+* Matches the Workers Vectorize binding interface.
+*/
+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) : void 0
+		});
+	}
+	async function ndjsonRequest(endpoint, vectors) {
+		const ndjson = vectors.map((v) => JSON.stringify(v)).join("\n");
+		return cloudflare.jsonRequest({
+			method: "POST",
+			path: `/vectorize/v2/indexes/${indexName}${endpoint}`,
+			serviceLabel: "Vectorize",
+			contentType: "application/x-ndjson",
+			body: ndjson
+		});
+	}
+	return {
+		async describe() {
+			return apiRequest("GET", "");
+		},
+		async query(vector, options) {
+			return apiRequest("POST", "/query", {
+				vector: Array.isArray(vector) ? vector : Array.from(vector),
+				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) {
+			return {
+				count: (await apiRequest("POST", "/delete-by-ids", { ids })).count,
+				ids
+			};
+		},
+		async getByIds(ids) {
+			return apiRequest("POST", "/get-by-ids", { ids });
+		}
+	};
+}
+//#endregion
+//#region src/test/utilities/context.ts
+/**
+* Creates a test context with mock ExecutionContext
+*
+* @example
+* ```ts
+* const ctx = createTestContext({
+*   env: { API_KEY: 'test' },
+*   request: new Request('https://test.com')
+* })
+* ```
+*/
+function createMockTestContext(options = {}) {
+	const waitUntilPromises = [];
+	return {
+		env: options.env ?? {},
+		ctx: {
+			waitUntil(promise) {
+				waitUntilPromises.push(promise);
+			},
+			passThroughOnException() {},
+			props: {}
+		},
+		request: options.request ?? null,
+		waitUntilPromises
+	};
+}
+/**
+* Runs a function within a test context
+*
+* @example
+* ```ts
+* const response = await withTestContext(
+*   { env: { DB: mockD1 } },
+*   async () => {
+*     // env, ctx, locals all work here
+*     return handler.fetch(new Request('https://test.com'))
+*   }
+* )
+* ```
+*/
+async function withTestContext(options, handler) {
+	const testCtx = createMockTestContext(options);
+	return runWithContext(testCtx.env, testCtx.ctx, options.request ?? null, handler, options.type ?? "fetch");
+}
+//#endregion
+//#region src/test/utilities/kv.ts
+/**
+* Creates a mock KVNamespace for testing
+*
+* @example
+* ```ts
+* const kv = createMockKV({ 'key': 'value' })
+* await kv.get('key') // 'value'
+* ```
+*/
+function createMockKV(initialData = {}) {
+	const store = /* @__PURE__ */ new Map();
+	const metadata = /* @__PURE__ */ 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) => {
+		return typeof options === "string" ? options : options?.type ?? "text";
+	};
+	return {
+		async get(key, options) {
+			const bytes = store.get(key);
+			if (bytes === void 0) 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 ?? 1e3;
+			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: void 0
+			};
+		},
+		async getWithMetadata(key, options) {
+			const bytes = store.get(key);
+			return {
+				value: bytes === void 0 ? null : decodeBytes(bytes, resolveType(options)),
+				metadata: metadata.get(key) ?? null
+			};
+		}
+	};
+}
+//#endregion
+//#region src/test/utilities/d1.ts
+const TABLE_NAME_RE = /(?:from|into|update)\s+["'`]?([a-zA-Z_][a-zA-Z0-9_]*)["'`]?/i;
+const extractTable = (sql) => {
+	const match = TABLE_NAME_RE.exec(sql);
+	return match ? match[1] : null;
 };
+const 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";
+};
+/**
+* Creates a mock D1Database for testing
+*
+* @example
+* ```ts
+* // Legacy: fixed results for all queries
+* const d1 = createMockD1([{ id: 1, name: 'Alice' }])
+*
+* // Preferred: per-table fixtures
+* const d1 = createMockD1({ fixtures: { users: [{ id: 1, name: 'Alice' }] } })
+* await d1.prepare('SELECT * FROM users').all() // returns users fixture
+* ```
+*/
+function createMockD1(mockResultsOrOptions = []) {
+	const options = Array.isArray(mockResultsOrOptions) ? { results: mockResultsOrOptions } : mockResultsOrOptions;
+	const tables = /* @__PURE__ */ 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) {
+					changes = (tables.get(table) ?? []).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 /* @__PURE__ */ new ArrayBuffer(0);
+		},
+		withSession(_constraintOrBookmark) {
+			return this;
+		}
+	};
+}
+//#endregion
+//#region src/test/utilities/r2.ts
+/**
+* Creates a mock R2Bucket for testing
+*
+* @example
+* ```ts
+* const r2 = createMockR2()
+* await r2.put('file.txt', 'content')
+* const obj = await r2.get('file.txt')
+* ```
+*/
+async function coerceToString(value) {
+	if (typeof value === "string") return value;
+	if (value === null) return "";
+	if (value instanceof ArrayBuffer) return new TextDecoder().decode(value);
+	if (ArrayBuffer.isView(value)) return new TextDecoder().decode(value);
+	if (value instanceof Blob) return await value.text();
+	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));
+	}
+	return chunks.join("");
+}
+function createMockR2() {
+	const store = /* @__PURE__ */ new Map();
+	const uploads = /* @__PURE__ */ new Map();
+	const createR2Object = (key, content, metadata) => {
+		const data = new TextEncoder().encode(content);
+		return {
+			key,
+			version: "1",
+			size: data.length,
+			etag: `"${key}-etag"`,
+			httpEtag: `"${key}-etag"`,
+			uploaded: /* @__PURE__ */ 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) {
+			const content = await coerceToString(value);
+			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: /* @__PURE__ */ 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) {
+			return {
+				objects: Array.from(store.entries()).map(([key, { content, metadata }]) => createR2Object(key, content, metadata)),
+				truncated: false,
+				delimitedPrefixes: []
+			};
+		},
+		async createMultipartUpload(key, options) {
+			const uploadId = crypto.randomUUID();
+			uploads.set(uploadId, {
+				key,
+				parts: /* @__PURE__ */ new Map(),
+				options
+			});
+			return createMultipart(key, uploadId);
+		},
+		resumeMultipartUpload(key, uploadId) {
+			if (!uploads.has(uploadId)) uploads.set(uploadId, {
+				key,
+				parts: /* @__PURE__ */ new Map()
+			});
+			return createMultipart(key, uploadId);
+		}
+	};
+	function createMultipart(key, uploadId) {
+		const requireEntry = () => {
+			const entry = uploads.get(uploadId);
+			if (!entry) throw new Error(`Mock R2 multipart upload "${uploadId}" for key "${key}" is not active (it was aborted or completed).`);
+			return entry;
+		};
+		return {
+			key,
+			uploadId,
+			async uploadPart(partNumber, value, _options) {
+				const entry = requireEntry();
+				const str = await coerceToString(value);
+				entry.parts.set(partNumber, str);
+				return {
+					partNumber,
+					etag: `"${key}-part-${partNumber}-etag"`
+				};
+			},
+			async abort() {
+				uploads.delete(uploadId);
+			},
+			async complete(uploadedParts) {
+				const entry = requireEntry();
+				const content = [...uploadedParts].sort((a, b) => a.partNumber - b.partNumber).map((part) => {
+					const chunk = entry.parts.get(part.partNumber);
+					if (chunk === void 0) throw new Error(`Mock R2 multipart complete() references part ${part.partNumber} that was never uploaded for upload "${uploadId}".`);
+					return chunk;
+				}).join("");
+				const metadata = entry.options?.customMetadata;
+				store.set(key, {
+					content,
+					metadata
+				});
+				uploads.delete(uploadId);
+				return createR2Object(key, content, metadata);
+			}
+		};
+	}
+}
+//#endregion
+//#region src/test/utilities/queue.ts
+/**
+* Creates a mock Queue for testing
+*/
+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;
+		}
+	};
+}
+//#endregion
+//#region src/test/utilities/platform.ts
+/**
+* Creates a local fixed-window RateLimit binding for testing.
+*/
+function createMockRateLimit(options = {}) {
+	const limit = options.limit ?? Number.MAX_SAFE_INTEGER;
+	const periodMs = (options.period ?? 60) * 1e3;
+	const windows = /* @__PURE__ */ 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"
+	};
+}
+/**
+* Creates a Secrets Store binding whose get() method returns a fixed value.
+*/
+function createMockSecretsStoreSecret(value) {
+	return { async get() {
+		return value;
+	} };
+}
+/**
+* Creates a Hyperdrive binding around a local database connection string.
+*
+* Connection fields are usable with any Node database client; the raw socket
+* `connect()` is a documented limitation that throws a clear, actionable error.
+*/
+function createMockHyperdrive(connectionString) {
+	return createLocalHyperdrive(connectionString);
+}
+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 cannot materialise a Durable Object class. getDurableObjectClass() returns an opaque facet-spawning reference that workerd only exposes inside the runtime. Pass createMockWorkerLoader({ stub }) to inject a stub, or use createTestContext() (a real Miniflare worker) for Durable Object behavior.");
+		}
+	};
+}
+/**
+* Creates a Worker Loader binding for pure unit tests.
+*/
+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.");
+}
+/**
+* Creates an mTLS certificate binding fetcher for pure unit tests.
+*/
+function createMockMTLSCertificate(handler = defaultMTLSCertificateHandler) {
+	return { async fetch(input, init) {
+		return handler(input, init);
+	} };
+}
+/**
+* Creates a Dispatch Namespace binding for pure unit tests.
+*/
+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;
+	} };
+}
+//#endregion
+//#region 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 = void 0;
+			output = void 0;
+		},
+		async status() {
+			return {
+				status,
+				...error && { error },
+				...output !== void 0 && { output }
+			};
+		},
+		async sendEvent(_event) {}
+	};
+}
+/**
+* Creates a Workflow binding for pure unit tests.
+*/
+function createMockWorkflow(options = {}) {
+	const instances = /* @__PURE__ */ 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(options) {
+			return createInstance(options?.id ?? `mock-workflow-${++sequence}`);
+		},
+		async createBatch(batch) {
+			return batch.map((options) => {
+				return createInstance(options.id ?? `mock-workflow-${++sequence}`);
+			});
+		}
+	};
+}
+/**
+* Creates a Pipeline binding for pure unit tests.
+*/
+function createMockPipeline() {
+	const records = [];
+	return {
+		async send(batch) {
+			records.push(...batch);
+		},
+		_getRecords() {
+			return [...records];
+		}
+	};
+}
+//#endregion
+//#region 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() {
+			return response.clone().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
+	};
+}
+/**
+* Creates an Images binding for pure unit tests.
+*/
+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() {
+			return response.clone().body ?? createEmptyMediaStream();
+		},
+		async response() {
+			return response.clone();
+		},
+		async contentType() {
+			return response.headers.get("Content-Type") ?? "video/mp4";
+		}
+	};
+}
+function createMockMediaTransformer(response) {
+	return {
+		transform(_transform) {
+			return { output(_output) {
+				return createMockMediaTransformationResult(response);
+			} };
+		},
+		output(_output) {
+			return createMockMediaTransformationResult(response);
+		}
+	};
+}
+/**
+* Creates a Media Transformations binding for pure unit tests.
+*/
+function createMockMediaBinding(options = {}) {
+	const response = options.response ?? new Response("", { headers: { "Content-Type": "video/mp4" } });
+	return { input(_media) {
+		return createMockMediaTransformer(response);
+	} };
+}
+//#endregion
+//#region src/test/utilities/artifacts.ts
+function createArtifactTimestamp() {
+	return (/* @__PURE__ */ 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$1(value) {
+	return typeof value.create === "function";
+}
+/**
+* Creates an in-memory Artifacts binding for pure unit tests.
+*/
+function createMockArtifacts(options = {}) {
+	const repos = /* @__PURE__ */ new Map();
+	const tokens = /* @__PURE__ */ 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 * 1e3).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 ?? void 0,
+				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);
+		}
+	};
+}
+//#endregion
+//#region src/test/utilities/env.ts
+/**
+* Creates a complete mock environment with specified bindings
+*
+* @example
+* ```ts
+* const env = createMockEnv({
+*   kv: ['CACHE'],
+*   d1: ['DB'],
+*   vars: { API_KEY: 'secret' }
+* })
+* ```
+*/
+function createMockEnv(options = {}) {
+	const env = {};
+	if (options.kv) for (const name of options.kv) env[name] = createMockKV();
+	if (options.d1) for (const name of options.d1) env[name] = createMockD1();
+	if (options.r2) for (const name of options.r2) env[name] = createMockR2();
+	if (options.queues) for (const name of options.queues) env[name] = createMockQueue();
+	if (options.rateLimits) for (const [name, rateLimitOptions] of Object.entries(options.rateLimits)) env[name] = createMockRateLimit(rateLimitOptions);
+	if (options.versionMetadata) env[options.versionMetadata] = createMockVersionMetadata();
+	if (options.hyperdrive) for (const [name, binding] of Object.entries(options.hyperdrive)) env[name] = typeof binding === "string" ? createMockHyperdrive(binding) : binding;
+	if (Array.isArray(options.workerLoaders)) for (const name of options.workerLoaders) env[name] = createMockWorkerLoader();
+	else if (options.workerLoaders) for (const [name, workerLoaderOptions] of Object.entries(options.workerLoaders)) env[name] = createMockWorkerLoader(workerLoaderOptions);
+	if (Array.isArray(options.mtlsCertificates)) for (const name of options.mtlsCertificates) env[name] = createMockMTLSCertificate();
+	else if (options.mtlsCertificates) for (const [name, handler] of Object.entries(options.mtlsCertificates)) env[name] = createMockMTLSCertificate(handler);
+	if (Array.isArray(options.dispatchNamespaces)) for (const name of options.dispatchNamespaces) env[name] = createMockDispatchNamespace();
+	else if (options.dispatchNamespaces) for (const [name, dispatchNamespaceOptions] of Object.entries(options.dispatchNamespaces)) env[name] = createMockDispatchNamespace(dispatchNamespaceOptions);
+	if (Array.isArray(options.workflows)) for (const name of options.workflows) env[name] = createMockWorkflow();
+	else if (options.workflows) for (const [name, workflowOptions] of Object.entries(options.workflows)) env[name] = "create" in workflowOptions ? workflowOptions : createMockWorkflow(workflowOptions);
+	if (Array.isArray(options.pipelines)) for (const name of options.pipelines) env[name] = createMockPipeline();
+	else if (options.pipelines) for (const [name, pipeline] of Object.entries(options.pipelines)) env[name] = pipeline;
+	if (typeof options.images === "string") env[options.images] = createMockImagesBinding();
+	else if (options.images) env.IMAGES = options.images;
+	if (typeof options.media === "string") env[options.media] = createMockMediaBinding();
+	else if (options.media) env.MEDIA = options.media;
+	if (Array.isArray(options.artifacts)) for (const name of options.artifacts) env[name] = createMockArtifacts();
+	else if (options.artifacts) for (const [name, artifactsOptions] of Object.entries(options.artifacts)) env[name] = isArtifactsBinding$1(artifactsOptions) ? artifactsOptions : createMockArtifacts(artifactsOptions);
+	if (options.secretsStore) for (const [name, value] of Object.entries(options.secretsStore)) env[name] = createMockSecretsStoreSecret(value);
+	if (options.vars) Object.assign(env, options.vars);
+	if (options.secrets) Object.assign(env, options.secrets);
+	if (options.custom) Object.assign(env, options.custom);
+	return env;
+}
+//#endregion
+//#region src/test/simple-context-bindings.ts
+/**
+* Build the initial remote/static binding map for a test context.
+*
+* - When `isRemoteModeActive()`, registers `RemoteAI` / `RemoteVectorize`
+*   proxies for every `bindings.ai` / `bindings.vectorize` entry. Otherwise
+*   those bindings are left to come from Miniflare (or remain absent).
+* - `config.vars` are always copied in as-is.
+* - `config.bindings.sendEmail` is always wired to the local SendEmail
+*   binding (so tests can intercept outgoing mail without remote setup).
+*/
+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;
+}
+//#endregion
+//#region src/test/simple-context-gateway-script.ts
+function buildGatewayScript(bundledCode, wrappers, nativeRpcBindingNames = []) {
+	return `
+// Bundled transport + DO classes
+${bundledCode}
+
+// DO Wrappers with RPC
+${wrappers}
+
+const __nativeRpcBindings = new Set(${JSON.stringify(nativeRpcBindingNames)})
+
+// 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))
+	}
+}
+`;
+}
+//#endregion
+//#region src/test/simple-context-paths.ts
+const DEFAULT_TRANSPORT_ENTRY_FILES = [
+	"src/transport.ts",
+	"src/transport.js",
+	"src/transport.mts",
+	"src/transport.mjs"
+];
+const CURRENT_PACKAGE_ROOT = findPackageRoot(dirname$1(fileURLToPath(import.meta.url)));
+/**
+* Access Bun global via globalThis to avoid shadowing richer @types/bun
+* when available. Returns undefined if not running in Bun.
+*/
+function getBunRuntime() {
+	const g = globalThis;
+	if (typeof g.Bun === "object" && g.Bun !== null) return g.Bun;
+}
+/**
+* Get the directory of the test file.
+* Prefers stack trace parsing so bun test hooks resolve the actual test file,
+* then falls back to the current working directory.
+*
+* We intentionally do not use Bun.main here because workspace consumers often
+* import the built devflare package from `packages/devflare/dist`, which would
+* incorrectly anchor autodiscovery inside the devflare package instead of the
+* calling project under test.
+*/
+function getCallerDirectory() {
+	const stackCallerDirectory = getStackCallerDirectory();
+	if (stackCallerDirectory) return stackCallerDirectory;
+	return process.cwd();
+}
+function getStackCallerDirectory() {
+	const originalPrepare = Error.prepareStackTrace;
+	Error.prepareStackTrace = (_, stack) => stack;
+	try {
+		const stack = (/* @__PURE__ */ new Error()).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$1(filename)) return dirname$1(filename);
+		}
+	} finally {
+		Error.prepareStackTrace = originalPrepare;
+	}
+	return null;
+}
+function findPackageRoot(startDir) {
+	let currentDir = startDir;
+	while (true) {
+		if (existsSync$1(join$1(currentDir, "package.json"))) return currentDir;
+		const parentDir = dirname$1(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}/`);
+}
+/**
+* Find the nearest supported devflare config by searching upward from startDir.
+*/
+async function findNearestConfig(startDir) {
+	let currentDir = startDir;
+	while (true) {
+		const configPath = await resolveConfigPath(currentDir);
+		if (configPath) return configPath;
+		const parentDir = dirname$1(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(/* @__PURE__ */ 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$1(join$1(configDir, defaultEntry))) return defaultEntry;
+	return null;
+}
+//#endregion
+//#region src/test/simple-context-durable-objects.ts
+/**
+* Find all exported class names in a TypeScript/JavaScript file.
+*/
+function findExportedClasses(code) {
+	const classes = [];
+	const classPattern = /export\s+class\s+(\w+)/g;
+	let match = classPattern.exec(code);
+	while (match !== null) {
+		classes.push(match[1]);
+		match = classPattern.exec(code);
+	}
+	return classes;
+}
+function classSupportsNativeDurableObjectRpc(code, className) {
+	return new RegExp(`export\\s+class\\s+${className}\\s+extends\\s+DurableObject\\b`).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 = /* @__PURE__ */ 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$1(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 = join$1(configDir, "src", doInfo.scriptName);
+			try {
+				nativeRpc = classSupportsNativeDurableObjectRpc(await readFile$1(scriptPath, "utf-8"), 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.\nEither:\n  1. Set files.durableObjects pattern in config (e.g., 'src/do.*.ts')\n  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("\n\n");
+}
+async function bundleDurableObjectModules(configDir, doInfos, transportFile) {
+	const virtualImports = [];
+	const virtualExports = [];
+	if (transportFile) {
+		const transportPath = join$1(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("\n");
+	const virtualPath = join$1(configDir, ".devflare", "__test_entry.ts");
+	mkdirSync$1(dirname$1(virtualPath), { recursive: true });
+	writeFileSync$1(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("\n")}`);
+	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);
+	return {
+		durableObjects: doConfig,
+		script: buildGatewayScript([workflowEntrypointScript, bundledCode].filter(Boolean).join("\n\n"), wrapperCode, doInfos.filter((info) => info.nativeRpc).map((info) => info.name))
+	};
+}
+//#endregion
+//#region src/test/email.ts
+let miniflarePort = 8787;
+let emailListeners = [];
+let sentEmails = [];
+let emailHandlerPath = null;
+let configDir$4 = null;
+let testEnvGetter$4 = null;
+/**
+* Configure the email test helper
+* @internal
+*/
+function configureEmail(options = {}) {
+	if (options.port) miniflarePort = options.port;
+	emailHandlerPath = options.handlerPath ?? emailHandlerPath;
+	configDir$4 = options.configDir ?? configDir$4;
+	testEnvGetter$4 = options.getEnv ?? testEnvGetter$4;
+}
+/**
+* Build a raw email string from options
+*/
+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 = (/* @__PURE__ */ 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\n");
+}
+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;
+}
+/**
+* Send an incoming email through the email test helper.
+*
+* When `createTestContext()` has configured an email handler, this imports and
+* invokes that handler directly and waits for queued `waitUntil()` work.
+* Otherwise it attempts the local `/cdn-cgi/handler/email` endpoint exposed by
+* compatible local runtimes.
+*/
+async function send$1(options) {
+	const raw = buildRawEmail(options);
+	if (emailHandlerPath && configDir$4 && testEnvGetter$4) {
+		const emailHandler = resolveEmailHandler(await import(join$1(configDir$4, emailHandlerPath)));
+		if (!emailHandler) throw new Error(`Email handler at "${emailHandlerPath}" must export a default function or named "email" export.\nExpected: export async function email(message) { ... }`);
+		const waitUntilPromises = [];
+		const ctx = {
+			waitUntil(promise) {
+				waitUntilPromises.push(promise);
+			},
+			passThroughOnException() {},
+			props: {}
+		};
+		const runtimeEnv = testEnvGetter$4();
+		const timestamp = /* @__PURE__ */ new Date();
+		const emailEvent = createEmailEvent({
+			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(message) {
+				recordSentEmail({
+					type: "reply",
+					from: message.from ?? options.to,
+					to: message.to ?? options.from,
+					raw: getRecordedRawContent(message.raw),
+					timestamp
+				});
+			}
+		}, 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);
+	return await fetch(url.toString(), {
+		method: "POST",
+		headers: { "Content-Type": "text/plain" },
+		body: raw
+	});
+}
+/**
+* Register a callback for outgoing emails.
+*
+* This only fires when the surrounding runtime wiring records outgoing emails.
+* @returns Unsubscribe function
+*/
+function onReceive(callback) {
+	emailListeners.push(callback);
+	return () => {
+		emailListeners = emailListeners.filter((cb) => cb !== callback);
+	};
+}
+/**
+* Get all recorded outgoing emails since test context was created
+*/
+function getSentEmails() {
+	return [...sentEmails];
+}
+/**
+* Clear recorded outgoing email history
+*/
+function clearSentEmails() {
+	sentEmails = [];
+}
+/**
+* Add a sent email to the history
+* @internal Called by helper paths that explicitly record outgoing email
+* (currently direct `forward()`/`reply()` test flows).
+*/
+function recordSentEmail(email) {
+	sentEmails.push(email);
+	for (const listener of emailListeners) try {
+		listener(email);
+	} catch (error) {
+		console.error("[devflare/test] Email listener error:", error);
+	}
+}
+/**
+* Reset email state
+* @internal Called when test context is disposed
+*/
+function resetEmailState() {
+	miniflarePort = 8787;
+	emailHandlerPath = null;
+	configDir$4 = null;
+	testEnvGetter$4 = null;
+	emailListeners = [];
+	sentEmails = [];
+}
+const email = {
+	send: send$1,
+	onReceive,
+	getSentEmails,
+	clearSentEmails
+};
+//#endregion
+//#region src/test/queue.ts
+let queueHandlerPath = null;
+let configDir$3 = null;
+let testEnvGetter$3 = null;
+/**
+* Configure the queue test helper
+* @internal Called by createTestContext to set up handler path and env
+*/
+function configureQueue(options) {
+	queueHandlerPath = options.handlerPath;
+	configDir$3 = options.configDir;
+	testEnvGetter$3 = options.getEnv;
+}
+/**
+* Reset queue helper state
+* @internal Called when test context is disposed
+*/
+function resetQueueState() {
+	queueHandlerPath = null;
+	configDir$3 = null;
+	testEnvGetter$3 = null;
+}
+const EMPTY_QUEUE_METADATA = { metrics: {
+	backlogCount: 0,
+	backlogBytes: 0
+} };
+/**
+* Create a mock Message object that tracks ack/retry/noRetry calls
+*/
+function createMessage(options) {
+	const id = options.id ?? crypto.randomUUID();
+	const timestamp = options.timestamp ?? /* @__PURE__ */ 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;
+		}
+	};
+}
+/**
+* Create a mock MessageBatch from an array of messages
+*/
+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();
+		}
+	};
+}
+/**
+* Trigger the queue handler with a batch of messages.
+* This directly invokes the queue handler function from your config.
+*
+* @param messages - Array of message options or bodies
+* @returns Result object with acked/retried/failed message IDs
+*
+* @example
+* ```ts
+* // Trigger with message bodies (IDs auto-generated)
+* const result = await cf.queue.trigger([
+*   { type: 'process', data: { x: 1 } },
+*   { type: 'cleanup', data: {} }
+* ])
+*
+* // Trigger with full message options
+* const result = await cf.queue.trigger([
+*   { id: 'msg-1', body: { type: 'process' }, attempts: 2 }
+* ])
+* ```
+*/
+async function trigger$2(messages) {
+	if (!queueHandlerPath) throw new Error("Queue handler not configured. Make sure your devflare.config.ts has files.queue set, and the file exists at the specified path (default: src/queue.ts)");
+	if (!configDir$3 || !testEnvGetter$3) throw new Error("Queue helper not initialized. Call createTestContext() before using cf.queue.trigger()");
+	const handlerModule = await import(join$1(configDir$3, queueHandlerPath));
+	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.\nExpected: export async function queue(event) { ... }`);
+	const mockMessages = messages.map((msg) => {
+		if (typeof msg === "object" && msg !== null && "body" in msg) return msg;
+		return { body: msg };
+	}).map((opts) => createMessage(opts));
+	const batch = createMessageBatch(mockMessages);
+	const waitUntilPromises = [];
+	const queueEvent = createQueueEvent(batch, testEnvGetter$3(), {
+		waitUntil(promise) {
+			waitUntilPromises.push(promise);
+		},
+		passThroughOnException() {},
+		props: {}
+	});
+	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
+	};
+}
+/**
+* Convenience method to trigger the queue handler with a single message.
+*
+* @param message - Message body or options
+* @returns Result object
+*
+* @example
+* ```ts
+* await cf.queue.send({ type: 'process', data: { x: 1 } })
+* ```
+*/
+async function send(message) {
+	return trigger$2([message]);
+}
+const queue = {
+	trigger: trigger$2,
+	send
+};
+//#endregion
+//#region src/test/scheduled.ts
+let scheduledHandlerPath = null;
+let configDir$2 = null;
+let testEnvGetter$2 = null;
+/**
+* Configure the scheduled test helper
+* @internal Called by createTestContext to set up handler path and env
+*/
+function configureScheduled(options) {
+	scheduledHandlerPath = options.handlerPath;
+	configDir$2 = options.configDir;
+	testEnvGetter$2 = options.getEnv;
+}
+/**
+* Reset scheduled helper state
+* @internal Called when test context is disposed
+*/
+function resetScheduledState() {
+	scheduledHandlerPath = null;
+	configDir$2 = null;
+	testEnvGetter$2 = null;
+}
+/**
+* Trigger the scheduled handler.
+* This directly invokes the scheduled handler function from your config.
+*
+* @param cronOrOptions - Cron expression string or options object
+* @returns Result object with success status
+*
+* @example
+* // Trigger with specific cron expression (every 6 hours)
+* await cf.scheduled.trigger('0 0,6,12,18 * * *')
+*
+* @example
+* // Trigger with options (Weekly Monday at midnight)
+* await cf.scheduled.trigger({
+*   cron: '0 0 * * 1',
+*   scheduledTime: new Date('2026-01-13T00:00:00Z')
+* })
+*
+* @example
+* // Trigger without cron (just scheduled time)
+* await cf.scheduled.trigger()
+*/
+async function trigger$1(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 (!configDir$2 || !testEnvGetter$2) 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 handlerModule = await import(join$1(configDir$2, scheduledHandlerPath));
+	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.\nExpected: export async function scheduled(event) { ... }`);
+	const controller = {
+		scheduledTime,
+		cron,
+		noRetry() {}
+	};
+	const waitUntilPromises = [];
+	const scheduledEvent = createScheduledEvent(controller, testEnvGetter$2(), {
+		waitUntil(promise) {
+			waitUntilPromises.push(promise);
+		},
+		passThroughOnException() {},
+		props: {}
+	});
+	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
+		};
+	}
+}
+const scheduled = { trigger: trigger$1 };
+//#endregion
+//#region src/test/tail.ts
+let tailHandlerPath = null;
+let configDir$1 = null;
+let testEnvGetter$1 = null;
+/**
+* Configure the tail test helper
+* @internal Called by createTestContext to set up handler path and env
+*/
+function configureTail(options) {
+	tailHandlerPath = options.handlerPath;
+	configDir$1 = options.configDir;
+	testEnvGetter$1 = options.getEnv;
+}
+/**
+* Reset tail helper state
+* @internal Called when test context is disposed
+*/
+function resetTailState() {
+	tailHandlerPath = null;
+	configDir$1 = null;
+	testEnvGetter$1 = null;
+}
+/**
+* Create a complete TraceItem from options
+*/
+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 ?? []
+	};
+}
+/**
+* Trigger the tail handler with trace items.
+* This directly invokes the auto-detected `src/tail.ts` handler, or another
+* tail handler that has already been configured internally.
+*
+* @param items - Array of trace items or trace item options
+* @returns Result object with success status
+*
+* @example
+* ```ts
+* // Trigger with full trace items
+* await cf.tail.trigger([
+*   {
+*     scriptName: 'my-worker',
+*     outcome: 'ok',
+*     logs: [{ level: 'log', message: ['Request processed'], timestamp: Date.now() }]
+*   }
+* ])
+*
+* // Trigger with minimal options (defaults applied)
+* await cf.tail.trigger([
+*   { logs: [{ level: 'error', message: ['Something failed'], timestamp: Date.now() }] }
+* ])
+* ```
+*/
+async function trigger(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 (!configDir$1 || !testEnvGetter$1) 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 handlerModule = await import(join$1(configDir$1, tailHandlerPath));
+	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.\nExpected: export async function tail(event) { ... } or export default { tail(events, env, ctx) { ... } }`);
+	const waitUntilPromises = [];
+	const ctx = {
+		waitUntil(promise) {
+			waitUntilPromises.push(promise);
+		},
+		passThroughOnException() {},
+		props: {}
+	};
+	const env = testEnvGetter$1();
+	const tailEvent = createTailEvent(traceItems, env, ctx);
+	try {
+		await runWithEventContext(tailEvent, () => tailHandler.length >= 2 ? tailHandler(traceItems, env, ctx) : tailHandler(tailEvent, env, 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
+		};
+	}
+}
+/**
+* Create a TraceItem with sensible defaults.
+* Useful for building test data.
+*
+* @param options - Partial trace item options
+* @returns Complete TraceItem
+*/
+function create(options = {}) {
+	return createTraceItem(options);
+}
+const tail = {
+	trigger,
+	create
+};
+//#endregion
+//#region src/test/worker.ts
+let fetchHandlerPath = null;
+let configDir = null;
+let testEnvGetter = null;
+let fileRoutes = [];
+/**
+* Configure the worker test helper
+* @internal Called by createTestContext to set up handler path and env
+*/
+function configureWorker(options) {
+	fetchHandlerPath = options.handlerPath;
+	fileRoutes = options.routes ?? [];
+	configDir = options.configDir;
+	testEnvGetter = options.getEnv;
+}
+/**
+* Reset worker helper state
+* @internal Called when test context is disposed
+*/
+function resetWorkerState() {
+	fetchHandlerPath = null;
+	fileRoutes = [];
+	configDir = null;
+	testEnvGetter = null;
+}
+/**
+* Trigger the fetch handler with a request.
+* This directly invokes the fetch handler function from your config.
+*
+* @param request - Request object or URL string
+* @param options - Optional fetch options (method, headers, body)
+* @returns Response from the handler
+*
+* @example
+* ```ts
+* // With Request object
+* const response = await cf.worker.fetch(new Request('http://localhost/api'))
+*
+* // With URL string
+* const response = await cf.worker.fetch('http://localhost/api')
+*
+* // With options
+* const response = await cf.worker.fetch('/api/users', {
+*   method: 'POST',
+*   body: { name: 'Alice' }
+* })
+* ```
+*/
+async function fetch$1(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 (!configDir || !testEnvGetter) throw new Error("Worker helper not initialized. Call createTestContext() before using cf.worker.fetch()");
+	const workerConfigDir = configDir;
+	const getEnv = testEnvGetter;
+	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 !== void 0) 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(join$1(workerConfigDir, fetchHandlerPath)) : {};
+	const routeModules = await Promise.all(fileRoutes.map(async (route) => {
+		return {
+			...route,
+			module: await import(join$1(workerConfigDir, route.filePath))
+		};
+	}));
+	const hasMethodHandler = [
+		"GET",
+		"HEAD",
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE",
+		"OPTIONS",
+		"ALL"
+	].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:\n- request-wide \"handle\" middleware\n- named \"fetch\"\n- default fetch handler\n- HTTP method exports such as \"GET\" or \"POST\"`);
+	const waitUntilPromises = [];
+	const ctx = {
+		waitUntil(promise) {
+			waitUntilPromises.push(promise);
+		},
+		passThroughOnException() {},
+		props: {}
+	};
+	const env = getEnv();
+	const initialRouteMatch = routeModules.length > 0 ? matchFetchRoute(routeModules, req) : null;
+	const fetchEvent = createFetchEvent(req, env, ctx, { params: initialRouteMatch?.params ?? {} });
+	return await runWithEventContext(fetchEvent, () => invokeFetchModule(handlerModule, fetchEvent, routeModules.length > 0 ? createRouteResolve(routeModules, fetchEvent) : void 0));
+}
+/**
+* Shorthand for GET requests
+*/
+async function get(path, headers) {
+	return fetch$1(path, {
+		method: "GET",
+		headers
+	});
+}
+/**
+* Shorthand for POST requests with JSON body
+*/
+async function post(path, body, headers) {
+	return fetch$1(path, {
+		method: "POST",
+		body,
+		headers
+	});
+}
+/**
+* Shorthand for PUT requests with JSON body
+*/
+async function put(path, body, headers) {
+	return fetch$1(path, {
+		method: "PUT",
+		body,
+		headers
+	});
+}
+/**
+* Shorthand for DELETE requests
+*/
+async function del(path, headers) {
+	return fetch$1(path, {
+		method: "DELETE",
+		headers
+	});
+}
+/**
+* Shorthand for PATCH requests with JSON body
+*/
+async function patch(path, body, headers) {
+	return fetch$1(path, {
+		method: "PATCH",
+		body,
+		headers
+	});
+}
+const worker = {
+	fetch: fetch$1,
+	get,
+	post,
+	put,
+	delete: del,
+	patch
+};
+//#endregion
+//#region src/test/simple-context-env.ts
+/**
+* Wire up every per-surface handler helper (queue / scheduled / worker /
+* tail / email) with the same `configDir` + `getEnv` accessor.
+*/
+function configureSurfaceHandlers(input) {
+	const { handlerPaths, configDir, activePort, getEnv } = input;
+	configureQueue({
+		handlerPath: handlerPaths.queue,
+		configDir,
+		getEnv
+	});
+	configureScheduled({
+		handlerPath: handlerPaths.scheduled,
+		configDir,
+		getEnv
+	});
+	configureWorker({
+		handlerPath: handlerPaths.fetch,
+		routes: handlerPaths.routes?.routes.map((route) => ({
+			filePath: route.filePath,
+			routePath: route.routePath,
+			segments: route.segments
+		})) ?? [],
+		configDir,
+		getEnv
+	});
+	configureTail({
+		handlerPath: handlerPaths.tail,
+		configDir,
+		getEnv
+	});
+	configureEmail({
+		port: activePort,
+		handlerPath: handlerPaths.email,
+		configDir,
+		getEnv
+	});
+}
+/**
+* Build the bridge-backed env accessor used by single-worker test contexts.
+*
+* Resolution order, given a property access:
+* 1. Remote bindings (AI/Vectorize/vars/sendEmail) registered up-front.
+* 2. For non-DO/non-service hints: Miniflare binding (raw KV/D1/R2/etc).
+* 3. Bridge env proxy (for everything else, including DOs and services).
+* 4. Final fallback: Miniflare binding (when the hint preferred bridge but
+*    the proxy did not surface it).
+*/
+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];
+		},
+		has(_, prop) {
+			return Boolean(state.remoteBindings && prop in state.remoteBindings || state.miniflareBindings && prop in state.miniflareBindings || state.envProxy !== null);
+		}
+	});
+}
+/**
+* Build the simpler env accessor used by multi-worker test contexts (no
+* bridge-backed proxy: services + DOs go through Miniflare's own bindings).
+*/
+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];
+		},
+		has(_, prop) {
+			return Boolean(state.remoteBindings && prop in state.remoteBindings || state.miniflareBindings && prop in state.miniflareBindings);
+		}
+	});
+}
+//#endregion
+//#region src/test/simple-context-handlers.ts
+const DEFAULT_FETCH_PATH = "src/fetch.ts";
+const DEFAULT_QUEUE_PATH = "src/queue.ts";
+const DEFAULT_SCHEDULED_PATH = "src/scheduled.ts";
+const DEFAULT_EMAIL_PATH = "src/email.ts";
+const DEFAULT_TAIL_PATH = "src/tail.ts";
+async function resolveHandlerPath(configDir, configValue, defaultPath) {
+	if (typeof configValue === "string") return configValue;
+	if (configValue === false) return null;
+	const defaultAbsolute = join$1(configDir, defaultPath);
+	try {
+		await (await import("fs/promises")).access(defaultAbsolute);
+		return defaultPath;
+	} catch {
+		return null;
+	}
+}
+async function resolveHandlerPaths(configDir, config) {
+	const [fetch, queue, scheduled, email, tail, routes] = await Promise.all([
+		resolveHandlerPath(configDir, config.files?.fetch, DEFAULT_FETCH_PATH),
+		resolveHandlerPath(configDir, config.files?.queue, DEFAULT_QUEUE_PATH),
+		resolveHandlerPath(configDir, config.files?.scheduled, DEFAULT_SCHEDULED_PATH),
+		resolveHandlerPath(configDir, config.files?.email, DEFAULT_EMAIL_PATH),
+		resolveHandlerPath(configDir, config.files?.tail, DEFAULT_TAIL_PATH),
+		discoverRoutes(configDir, config)
+	]);
+	return {
+		fetch,
+		queue,
+		scheduled,
+		email,
+		tail,
+		routes
+	};
+}
+//#endregion
+//#region src/test/containers.ts
+const realContainerCommandRunner = { async exec(command, args, options = {}) {
+	try {
+		const result = await execa(command, args, {
+			cwd: options.cwd,
+			env: options.env,
+			reject: false,
+			timeout: options.timeoutMs ?? 15e3
+		});
+		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 = {}) {
+	if (!isTruthyEnvFlag((options.env ?? process.env).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 = /* @__PURE__ */ 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 resolved = await resolveContainerStart(className, startOptions, options.cwd ?? getCallerDirectory());
+			const engine = getAvailableContainerEngine(await manager.detectEngine(), 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;
+}
+const defaultContainerManager = createContainerManager();
+const 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 ?? 2e4);
+	} 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 } = 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,
+		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 configDir = dirname(absolutePath);
+	return {
+		config: await applyLocalDevVarsToConfig(await resolveConfigEnvVars(await loadConfig({
+			cwd: configDir,
+			configFile: basename(absolutePath)
+		}), {
+			cwd: configDir,
+			configPath: absolutePath,
+			mode: "dev"
+		}), {
+			cwd: configDir,
+			configPath: absolutePath
+		}),
+		configDir
+	};
+}
+async function prepareImage(options) {
+	if (looksLikeLocalPath(options.image)) return { image: await buildLocalImage(options) };
+	if ((await options.runner.exec(options.engine, [
+		"image",
+		"inspect",
+		options.image
+	], { cwd: options.configDir })).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() ? join(imagePath, "Dockerfile") : imagePath;
+	const context = resolve(options.configDir, options.imageBuildContext ?? (imageStat.isDirectory() ? options.image : dirname(options.image)));
+	if (!existsSync(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,
+		context
+	];
+	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;
+}
+var LocalDevflareContainer = class {
+	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 sourceUrl = new URL(source.url);
+			const localUrl = new URL(`${sourceUrl.pathname}${sourceUrl.search}`, base);
+			return new Request(localUrl, {
+				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() + 5e3;
+	let lastError;
+	while (Date.now() < deadline) try {
+		return await fetchImpl(request.clone());
+	} catch (error) {
+		if (!isTransientContainerFetchError(error)) throw error;
+		lastError = error;
+		await setTimeout$1(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 setTimeout$1(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, configDir, image) {
+	const hash = createHash("sha256").update(`${configDir}:${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";
+}
+//#endregion
+//#region src/test/simple-context-lifecycle.ts
+/**
+* Resolve and load the devflare config for the test context.
+*
+* If `configPath` is given, it is interpreted relative to the caller's
+* directory (the file that invoked `createTestContext()`). Otherwise the
+* resolver walks upward from the caller's directory looking for a supported
+* `devflare.config.*` file.
+*/
+async function resolveTestContextConfig(configPath, callerDir = getCallerDirectory()) {
+	let absolutePath;
+	if (configPath) absolutePath = resolve$1(callerDir, configPath);
+	else {
+		const found = await findNearestConfig(callerDir);
+		if (!found) throw new Error(`Could not find a devflare config file. Searched upward from: ${callerDir}\nExpected one of: devflare.config.ts, devflare.config.mts, devflare.config.js, devflare.config.mjs\nEither create a config file or provide an explicit path: createTestContext('./path/to/config.ts')`);
+		absolutePath = found;
+	}
+	const configDir = dirname$1(absolutePath);
+	const config = await applyLocalDevVarsToConfig(await resolveConfigEnvVars(await loadConfig({
+		cwd: configDir,
+		configFile: absolutePath.split(/[/\\]/).pop()
+	}), {
+		cwd: configDir,
+		configPath: absolutePath,
+		mode: "dev"
+	}), {
+		cwd: configDir,
+		configPath: absolutePath
+	});
+	return {
+		absolutePath,
+		configDir,
+		config
+	};
+}
+/**
+* Build the dispose() function that tears down a test context. Disconnects
+* the bridge client, disposes Miniflare, clears per-handler global state,
+* and clears the registered test-context env accessor.
+*/
+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();
+	};
+}
+//#endregion
+//#region src/test/simple-context-mfconfig.ts
+/**
+* Build the seed Miniflare config for an inline (single-worker) bridge.
+* Pure: no I/O, no closures.
+*/
+function buildInlineBridgeMfConfig(config, options = {}) {
+	const localWorkerBindings = config.vars ?? {};
+	const localSecretWrappedBindingConfig = options.cwd ? buildLocalSecretWrappedBindingConfig(config, options.cwd) : void 0;
+	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]) => {
+		return [bindingName, { certificate_id: normalizeMtlsCertificateBinding(binding).certificateId }];
+	}));
+	if (config.bindings?.dispatchNamespaces) mfConfig.dispatchNamespaces = Object.fromEntries(Object.entries(config.bindings.dispatchNamespaces).map(([bindingName, binding]) => {
+		return [bindingName, { namespace: normalizeDispatchNamespaceBinding(binding).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;
+			mfConfig.images = { binding: normalizeImagesBinding(bindingName, binding).binding };
+		}
+	}
+	if (config.bindings?.media && localBindingShimServiceConfig.localBindingNames.length === 0) {
+		const [entry] = Object.entries(config.bindings.media);
+		if (entry) {
+			const [bindingName, binding] = entry;
+			mfConfig.media = { binding: normalizeMediaBinding(bindingName, binding).binding };
+		}
+	}
+	if (config.bindings?.artifacts) mfConfig.artifacts = Object.fromEntries(Object.entries(config.bindings.artifacts).map(([bindingName, binding]) => {
+		return [bindingName, { namespace: normalizeArtifactsBinding(binding).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;
+}
+//#endregion
+//#region src/test/simple-context-multi-worker.ts
+/**
+* Convert the in-progress single-worker `mfConfig` into a multi-worker
+* Miniflare config. Mutates `mfConfig` in place.
+*
+* The first worker (the "primary") inherits the bridge gateway script and the
+* KV/R2/D1/email/DO settings that were set on the top-level mfConfig;
+* additional workers come from `serviceBindingResolution.workers` and
+* `doBindingResolution.workers`, deduplicated by name.
+*/
+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 = /* @__PURE__ */ new Map();
+	for (const worker of additionalWorkers) {
+		if (!workersByName.has(worker.name)) {
+			workersByName.set(worker.name, worker);
+			continue;
+		}
+		const existing = workersByName.get(worker.name);
+		if (worker.durableObjects) existing.durableObjects = {
+			...existing.durableObjects || {},
+			...worker.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;
+}
+//#endregion
+//#region src/test/simple-context-startup.ts
+const TEST_CONTEXT_STARTUP_RETRY_ATTEMPTS = 3;
+const TEST_CONTEXT_STARTUP_RETRY_DELAY_MS = 75;
+const TEST_CONTEXT_BRIDGE_CONNECT_RETRY_ATTEMPTS = 8;
+const 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((resolve) => setTimeout(resolve, TEST_CONTEXT_STARTUP_RETRY_DELAY_MS));
+}
+async function waitForBridgeClientRetry() {
+	await new Promise((resolve) => setTimeout(resolve, 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 : /* @__PURE__ */ 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 !== void 0 && { 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.");
+}
+//#endregion
+//#region src/test/simple-context-runtime.ts
+/**
+* Boot the Miniflare runtime that backs `createTestContext()`.
+*
+* Two paths:
+* - **multi-worker**: when the caller has cross-worker DOs or service
+*   bindings, spin up Miniflare directly on a free port. No bridge client.
+* - **bridge-backed**: otherwise, defer to `startBridgeBackedTestContext()`,
+*   which also returns a connected `BridgeClient`.
+*/
+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;
+		return {
+			activePort,
+			miniflare,
+			miniflareBindings: wrapEnvSendEmailBindings(await miniflare.getBindings()),
+			client: null
+		};
+	}
+	const started = await startBridgeBackedTestContext(mfConfig);
+	return {
+		activePort: started.port,
+		miniflare: started.miniflare,
+		miniflareBindings: started.miniflareBindings,
+		client: started.client
+	};
+}
+//#endregion
+//#region src/test/simple-context-transport.ts
+/**
+* Load the user's transport module from disk and build a name -> decoder map.
+* Returns `null` if the module exists but does not export a `transport` object
+* (a warning is logged in that case).
+*/
+async function loadTransportDecoders(configDir, transportFile) {
+	const transportModule = await import(join$1(configDir, transportFile));
+	if (!transportModule.transport) {
+		console.warn(`[devflare] Warning: Transport file "${transportFile}" does not export a named "transport" object.\nExpected: export const transport = { ... }\nTransport encoding/decoding will be disabled.`);
+		return null;
+	}
+	const decoders = /* @__PURE__ */ new Map();
+	for (const [typeName, transporter] of Object.entries(transportModule.transport)) {
+		const t = transporter;
+		decoders.set(typeName, t.decode);
+	}
+	return decoders;
+}
+/**
+* Recursively walk `value`, replacing `{ __transport, value }` envelopes with
+* the result of the registered decoder. Returns `value` unchanged when
+* `decoders` is `null` or no envelope is present.
+*/
+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;
+}
+//#endregion
+//#region 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";
+}
+/**
+* Create a test context from a devflare config file.
+* This starts Miniflare with the configured bindings and sets up the bridge.
+*
+* @param configPath - Optional path to config file. If not provided, searches
+* upward from the test file for a supported devflare config.
+*/
+async function createTestContext(configPath) {
+	const state = createTestContextState();
+	const { configDir, 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);
+	let serviceBindingResolution = null;
+	let doBindingResolution = null;
+	if (needsMultiWorkerForServices) serviceBindingResolution = await resolveServiceBindings(config, configDir);
+	if (needsMultiWorkerForDOs) doBindingResolution = await resolveDOBindings(config, configDir);
+	const mfConfig = buildInlineBridgeMfConfig(config, { cwd: configDir });
+	const transportFile = resolveTransportFile(configDir, config.files?.transport);
+	if (transportFile) state.transportDecode = await loadTransportDecoders(configDir, transportFile);
+	const gateway = await buildDurableObjectGateway(config, configDir, 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];
+			},
+			has(_, prop) {
+				return Boolean(state.remoteBindings && prop in state.remoteBindings || state.miniflareBindings && prop in state.miniflareBindings || state.envProxy && prop in state.envProxy);
+			}
+		});
+	};
+	configureSurfaceHandlers({
+		handlerPaths: await resolveHandlerPaths(configDir, config),
+		configDir,
+		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);
+}
+//#endregion
+//#region src/test/cf.ts
+/**
+* Unified Cloudflare test helpers.
+*
+* Provides a consistent API for triggering the main Cloudflare Worker handler surfaces:
+* - `cf.email` — Email helper surface with a direct-handler path and a best-effort local endpoint fallback
+* - `cf.queue` — Queue consumer testing
+* - `cf.scheduled` — Cron/scheduled handler testing
+* - `cf.worker` — Fetch handler testing
+* - `cf.tail` — Tail helper surface (uses `files.tail`, or auto-detects `src/tail.ts` when present)
+*
+* The helpers use the real Miniflare-backed bindings created by `createTestContext()`,
+* but several helper surfaces still synthesize event/controller objects around those
+* bindings rather than replaying the full Cloudflare runtime dispatch path.
+* They still install the active Devflare event into AsyncLocalStorage before
+* invoking user code, so getters such as `getFetchEvent()` and `getQueueEvent()`
+* work inside the triggered handler.
+*
+* @example
+* ```ts
+* import { describe, test, expect, beforeAll, afterAll } from 'bun:test'
+* import { createTestContext, cf } from 'devflare/test'
+* import { env } from 'devflare'
+*
+* beforeAll(() => createTestContext())
+* afterAll(() => env.dispose())
+*
+* describe('My Worker', () => {
+*   test('fetch handler', async () => {
+*     const response = await cf.worker.get('/api/health')
+*     expect(response.status).toBe(200)
+*   })
+*
+*   test('queue handler', async () => {
+*     // Trigger queue handler with messages
+*     const result = await cf.queue.trigger([
+*       { type: 'process', data: { id: 1 } }
+*     ])
+*     expect(result.acked).toHaveLength(1)
+*
+*     // Verify side effects in real KV
+*     const stored = await env.RESULTS.get('result:1')
+*     expect(stored).toBeDefined()
+*   })
+*
+*   test('scheduled handler', async () => {
+*     await cf.scheduled.trigger('0 0 * * 1')  // Weekly Monday cron
+*
+*     // Verify scheduled job ran
+*     const report = await env.RESULTS.get('report:weekly')
+*     expect(report).toBeDefined()
+*   })
+* })
+* ```
+*/
+const cf = {
+	email,
+	queue,
+	scheduled,
+	worker,
+	tail
+};
+//#endregion
+//#region src/test/should-skip.ts
+/**
+* These services cannot be emulated locally — they ALWAYS require
+* a real connection to Cloudflare's infrastructure.
+*/
+const REMOTE_ONLY_SERVICES = new Set([
+	"ai",
+	"ai_search",
+	"ai_gateway",
+	"media",
+	"mtls_certificates",
+	"artifacts",
+	"builds",
+	"vectorize"
+]);
+/**
+* Cached skip results — computed once at module load
+* Each service gets a Promise<boolean> that resolves to true if should SKIP
+*/
+const skipResults = /* @__PURE__ */ new Map();
+let containerSkipResult = null;
+/**
+* Known operational error patterns that should cause skipping rather than failing.
+* These are expected errors from network issues, API problems, auth failures, etc.
+*/
+const EXPECTED_ERROR_PATTERNS = [
+	"ECONNREFUSED",
+	"ETIMEDOUT",
+	"ENOTFOUND",
+	"fetch failed",
+	"network",
+	"401",
+	"403",
+	"429",
+	"500",
+	"502",
+	"503",
+	"504",
+	"rate limit",
+	"unauthorized",
+	"forbidden",
+	"timeout"
+];
+/**
+* Check if an error is an expected operational error that should cause skipping.
+*/
+function isExpectedError(error) {
+	if (!(error instanceof Error)) return false;
+	const msg = error.message.toLowerCase();
+	return EXPECTED_ERROR_PATTERNS.some((pattern) => msg.includes(pattern.toLowerCase()));
+}
+/**
+* Compute whether to skip tests for a given service.
+* Returns true if tests should be SKIPPED.
+* Logs the reason to console.
+*
+* Rethrows unexpected errors (programming bugs) to fail tests loudly.
+*/
+async function computeSkip(service) {
+	try {
+		if (REMOTE_ONLY_SERVICES.has(service) && !isRemoteModeActive()) {
+			const status = getRemoteModeStatus();
+			console.log(`⏭️  ${service.toUpperCase()} tests skipped: Remote-only service.\n   Enable with: ${status.isEnabled ? "" : "devflare remote enable"}\n   Or set: DEVFLARE_REMOTE=1\n   See: https://github.com/ArthurvdVenne/devflare#remote-testing`);
+			return true;
+		}
+		if (!await isAuthenticated()) {
+			console.log(`⏭️  ${service.toUpperCase()} tests skipped: Not authenticated. Run: bunx wrangler login\n   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\n   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;
+	}
+}
+/**
+* Get or compute the skip result for a service
+*/
+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;
+}
+/**
+* Skip helper with property-based access for each service.
+* Each property returns a Promise<boolean> where true = SKIP the tests.
+*
+* Usage:
+* ```ts
+* import { shouldSkip } from 'devflare/test'
+*
+* describe.skipIf(shouldSkip.ai)('AI tests', () => {
+*   // These tests only run when authenticated and within limits
+* })
+* ```
+*/
+const 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();
+	}
+};
+//#endregion
+//#region src/test/ai-search.ts
+const 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;
+	return ("messages" in params ? params.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(.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("\n") ?? "";
+	const info = createItemInfo(fixture.id ?? `item-${sequence}`, 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$1(value) {
+	return typeof value.search === "function";
+}
+/**
+* Creates a deterministic AI Search instance binding for pure unit tests.
+*/
+function createMockAISearchInstance(options = {}) {
+	const instanceId = options.id ?? options.info?.id ?? "mock-ai-search";
+	const namespace = options.namespace ?? options.info?.namespace;
+	const items = /* @__PURE__ */ new Map();
+	const jobs = /* @__PURE__ */ 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("\n") || "No matching offline AI Search chunks.");
+			if (params.stream) return streamFromText(`data: ${JSON.stringify({
+				choices: [{ delta: { content } }],
+				chunks: search.chunks
+			})}\n\n`);
+			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));
+		}
+	};
+}
+/**
+* Creates a deterministic AI Search namespace binding for pure unit tests.
+*/
+function createMockAISearchNamespace(options = {}) {
+	const namespaceName = options.namespace ?? "default";
+	const instances = /* @__PURE__ */ new Map();
+	for (const [name, instanceOptions] of Object.entries(options.instances ?? {})) instances.set(name, isAISearchInstance$1(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("\n") || "No matching offline AI Search chunks.";
+			if (params.stream) return streamFromText(`data: ${JSON.stringify({ chunks: search.chunks })}\n\n`);
+			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());
+		}
+	};
+}
+//#endregion
+//#region src/test/offline-bindings.ts
+const 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 isArtifactsBinding(value) {
+	return typeof value?.create === "function";
+}
+function isAISearchInstance(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(env, config) {
+	if (config.vars) Object.assign(env, config.vars);
+}
+function addRateLimitBindings(env, bindings) {
+	for (const [name, binding] of Object.entries(bindings?.rateLimits ?? {})) env[name] = createMockRateLimit(binding.simple);
+}
+function addVersionMetadataBinding(env, bindings) {
+	if (bindings?.versionMetadata) env[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(env, bindings, fixtures, missingFixtures) {
+	for (const [name, binding] of Object.entries(bindings?.hyperdrive ?? {})) {
+		const fixture = fixtures.hyperdrive?.[name];
+		if (isHyperdriveBinding(fixture)) {
+			env[name] = fixture;
+			continue;
+		}
+		const connectionString = getHyperdriveConnectionString(name, binding, fixture);
+		if (connectionString) {
+			env[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(env, bindings, fixtures) {
+	for (const name of Object.keys(bindings?.workerLoaders ?? {})) env[name] = createMockWorkerLoader(fixtures.workerLoaders?.[name]);
+}
+function addMTLSCertificateBindings(env, bindings, fixtures) {
+	for (const name of Object.keys(bindings?.mtlsCertificates ?? {})) env[name] = createMockMTLSCertificate(fixtures.mtlsCertificates?.[name]);
+}
+function addDispatchNamespaceBindings(env, bindings, fixtures) {
+	for (const name of Object.keys(bindings?.dispatchNamespaces ?? {})) env[name] = createMockDispatchNamespace(fixtures.dispatchNamespaces?.[name]);
+}
+function addWorkflowBindings(env, bindings, fixtures) {
+	for (const name of Object.keys(bindings?.workflows ?? {})) {
+		const fixture = fixtures.workflows?.[name];
+		env[name] = fixture && isWorkflowBinding(fixture) ? fixture : createMockWorkflow(fixture);
+	}
+}
+function addPipelineBindings(env, bindings, fixtures) {
+	for (const name of Object.keys(bindings?.pipelines ?? {})) {
+		const fixture = fixtures.pipelines?.[name];
+		env[name] = isPipelineBinding(fixture) ? fixture : createMockPipeline();
+	}
+}
+function addImagesBindings(env, bindings, fixtures) {
+	for (const name of Object.keys(bindings?.images ?? {})) {
+		const fixture = fixtures.images?.[name];
+		env[name] = isImagesBinding(fixture) ? fixture : createMockImagesBinding(fixture);
+	}
+}
+function addMediaBindings(env, bindings, fixtures) {
+	for (const name of Object.keys(bindings?.media ?? {})) {
+		const fixture = fixtures.media?.[name];
+		env[name] = isMediaBinding(fixture) ? fixture : createMockMediaBinding(fixture);
+	}
+}
+function addArtifactsBindings(env, bindings, fixtures) {
+	for (const name of Object.keys(bindings?.artifacts ?? {})) {
+		const fixture = fixtures.artifacts?.[name];
+		env[name] = isArtifactsBinding(fixture) ? fixture : createMockArtifacts(fixture);
+	}
+}
+function addSecretsStoreBindings(env, bindings, fixtures, localSecretValues, missingFixtures) {
+	for (const name of Object.keys(bindings?.secretsStore ?? {})) {
+		const value = fixtures.secretsStore?.[name] ?? localSecretValues[name];
+		if (value === void 0) {
+			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.`
+			});
+			env[name] = createMissingSecret(name);
+		} else env[name] = createMockSecretsStoreSecret(value);
+	}
+}
+function addAISearchBindings(env, bindings, fixtures) {
+	for (const [name, binding] of Object.entries(bindings?.aiSearch ?? {})) {
+		const fixture = fixtures.aiSearch?.[name];
+		env[name] = isAISearchInstance(fixture) ? fixture : createMockAISearchInstance({
+			id: binding.instanceName,
+			...fixture
+		});
+	}
+}
+function addAISearchNamespaceBindings(env, bindings, fixtures) {
+	for (const [name, binding] of Object.entries(bindings?.aiSearchNamespaces ?? {})) {
+		const fixture = fixtures.aiSearchNamespaces?.[name];
+		env[name] = isAISearchNamespace(fixture) ? fixture : createMockAISearchNamespace({
+			namespace: binding.namespace,
+			...fixture
+		});
+	}
+}
+/**
+* Core storage and wiring bindings (kv/d1/r2/queues/durableObjects/services)
+* have no pure-offline fixture: they need a real Miniflare runtime, which only
+* `createTestContext()` provides. `createOfflineBindings()` therefore cannot
+* populate them, and leaving them silently absent from `env` is a surprise.
+* Surface each one in `missingFixtures` (with `env` left unset rather than a fake)
+* so callers see exactly which bindings require `createTestContext()` /
+* `createMock*()` instead of getting an `undefined` lookup at use time.
+*/
+const OFFLINE_UNAVAILABLE_STORAGE_BINDINGS = [
+	"kv",
+	"d1",
+	"r2",
+	"durableObjects",
+	"services"
+];
+function addUnsupportedStorageBindings(bindings, missingFixtures) {
+	for (const service of OFFLINE_UNAVAILABLE_STORAGE_BINDINGS) {
+		const group = bindings?.[service];
+		for (const name of Object.keys(group ?? {})) missingFixtures.push({
+			service,
+			binding: name,
+			reason: `${service} binding "${name}" needs a real Miniflare runtime and is not created by createOfflineBindings(); it will be undefined. Use createTestContext() (Miniflare-backed) or a createMock* helper for this binding.`
+		});
+	}
+	const queueProducers = (bindings?.queues)?.producers ?? {};
+	for (const name of Object.keys(queueProducers)) missingFixtures.push({
+		service: "queues",
+		binding: name,
+		reason: `queues producer binding "${name}" needs a real Miniflare runtime and is not created by createOfflineBindings(); it will be undefined. Use createTestContext() or createMockQueue() for this binding.`
+	});
+}
+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.");
+}
+/**
+* Builds a deterministic, pure-test env object from Devflare config.
+*
+* Covers the bindings that have a pure-offline simulator or fixture (rate
+* limits, version metadata, hyperdrive, worker loaders, mTLS, dispatch
+* namespaces, workflows, pipelines, images, media, artifacts, secrets store,
+* AI Search). It does **not** create the core storage/wiring bindings
+* (`kv`, `d1`, `r2`, `queues`, `durableObjects`, `services`) — those require a
+* real Miniflare runtime, which only `createTestContext()` provides. When such a
+* binding is present in config it is reported in the returned `missingFixtures`
+* (its `env` entry is left unset rather than silently faked); use
+* `createTestContext()` or a `createMock*()` helper for those bindings.
+*/
+function createOfflineBindings(config, fixtures = {}, options = {}) {
+	const env = {};
+	const remoteBoundaries = [];
+	const missingFixtures = [];
+	const bindings = config.bindings;
+	const localSecretValues = options.cwd && options.useLocalSecrets !== false ? resolveLocalSecretValuesForBindings(config, options.cwd) : {};
+	addStaticBindings(env, config);
+	addRateLimitBindings(env, bindings);
+	addVersionMetadataBinding(env, bindings);
+	addHyperdriveBindings(env, bindings, fixtures, missingFixtures);
+	addWorkerLoaderBindings(env, bindings, fixtures);
+	addMTLSCertificateBindings(env, bindings, fixtures);
+	addDispatchNamespaceBindings(env, bindings, fixtures);
+	addWorkflowBindings(env, bindings, fixtures);
+	addPipelineBindings(env, bindings, fixtures);
+	addImagesBindings(env, bindings, fixtures);
+	addMediaBindings(env, bindings, fixtures);
+	addArtifactsBindings(env, bindings, fixtures);
+	addSecretsStoreBindings(env, bindings, fixtures, localSecretValues, missingFixtures);
+	addAISearchBindings(env, bindings, fixtures);
+	addAISearchNamespaceBindings(env, bindings, fixtures);
+	addUnsupportedStorageBindings(bindings, missingFixtures);
+	addRemoteBoundaries(remoteBoundaries, bindings);
+	if (fixtures.custom) Object.assign(env, fixtures.custom);
+	return {
+		env,
+		support: getOfflineSupportMatrix(),
+		remoteBoundaries,
+		missingFixtures
+	};
+}
+/**
+* Convenience wrapper for callers that only need the derived env object.
+*
+* Note: the core storage/wiring bindings (`kv`, `d1`, `r2`, `queues`,
+* `durableObjects`, `services`) are **not** created here and will be
+* `undefined` in the returned env — they need a real Miniflare runtime. Use
+* `createTestContext()` or a `createMock*()` helper for them, or call
+* `createOfflineBindings()` to inspect `missingFixtures` for the exact list.
+*/
+function createOfflineEnv(config, fixtures = {}, options = {}) {
+	return createOfflineBindings(config, fixtures, options).env;
+}
+//#endregion
+export { cf, clearBundleCache, containers, createContainerManager, createMockAISearchInstance, createMockAISearchNamespace, createMockArtifacts, createMockD1, createMockDispatchNamespace, createMockEnv, createMockHyperdrive, createMockImagesBinding, createMockKV, createMockMTLSCertificate, createMockMediaBinding, createMockPipeline, createMockQueue, createMockR2, createMockRateLimit, createMockSecretsStoreSecret, createMockTestContext, createMockVersionMetadata, createMockWorkerLoader, createMockWorkflow, createOfflineBindings, createOfflineEnv, createTestContext, describeOfflineSupport, detectContainerEngine, email, env, getContainerSkipReason, getOfflineSupportMatrix, hasCrossWorkerDOs, hasServiceBindings, queue, resolveDOBindings, resolveServiceBindings, scheduled, shouldSkip, stopActiveContainers, tail, withTestContext, worker };