devflare 1.0.0-next.19 → 1.0.0-next.20

package/dist/test/index.js

@@ -4,7 +4,7 @@ import {
 } from "../index-d8bdkx2h.js";
 import {
   discoverEntrypointsSync
-} from "../index-zt22fe2j.js";
+} from "../index-gj5qh491.js";
 import {
   resolvePackageSpecifier
 } from "../index-t4fhcx1n.js";
@@ -14,56 +14,81 @@ import {
 import {
   transformWorkerEntrypoint
 } from "../index-7k278fgz.js";
+import {
+  buildHyperdrivesConfig,
+  bundleWorkflowEntrypointScript
+} from "../index-01kehw41.js";
+import"../index-gq39t0rx.js";
 import {
   createRouteResolve,
   invokeFetchModule,
   matchFetchRoute,
   resolveFetchHandler
-} from "../index-tt4fsv91.js";
+} from "../index-fnk0tkw7.js";
 import {
   __clearTestContext,
   __setTestContext,
-  createEmailEvent,
-  createFetchEvent,
-  createQueueEvent,
-  createScheduledEvent,
-  createTailEvent,
-  env,
-  runWithContext,
-  runWithEventContext
-} from "../index-esjrgt3y.js";
+  env
+} from "../index-0wa0ebm1.js";
 import"../index-a855bdsx.js";
 import {
   discoverRoutes
-} from "../index-3e7by9sy.js";
+} from "../index-qf2dkqxh.js";
 import {
   DEFAULT_DO_PATTERN,
   findFiles,
   findFilesSync
-} from "../index-rbht7m9r.js";
+} from "../index-qwgr4q7s.js";
 import"../index-65e7xx1a.js";
 import {
   findDurableObjectClasses
 } from "../index-vhqww6tt.js";
 import {
+  createLocalWorkerLoaderBinding,
+  disposeLocalWorkerLoaderBindings,
   extractBindingHints
-} from "../index-xskax7r3.js";
+} from "../index-y59hnmd0.js";
+import {
+  buildLocalBindingShimServiceConfig
+} from "../index-dm9q84c7.js";
+import {
+  buildLocalSecretWrappedBindingConfig,
+  resolveLocalSecretValuesForBindings
+} from "../index-hn5nbxbt.js";
 import {
   BridgeClient,
+  createEmailEvent,
   createEnvProxy,
+  createFetchEvent,
+  createQueueEvent,
+  createScheduledEvent,
+  createTailEvent,
+  runWithContext,
+  runWithEventContext,
   setBindingHints
-} from "../index-a75ejnvt.js";
+} from "../index-vrps1gky.js";
 import {
   createLocalSendEmailBinding,
   wrapEnvSendEmailBindings
-} from "../index-124e9t4t.js";
-import"../index-kawa49m8.js";
+} from "../index-kgstnk6g.js";
+import {
+  applyLocalDevVarsToConfig
+} from "../index-c3nxftnp.js";
 import {
   getLocalD1DatabaseIdentifier,
   loadConfig,
+  normalizeArtifactsBinding,
   normalizeDOBinding,
+  normalizeDispatchNamespaceBinding,
+  normalizeHyperdriveBinding,
+  normalizeImagesBinding,
+  normalizeMediaBinding,
+  normalizeMtlsCertificateBinding,
+  normalizePipelineBinding,
+  normalizeSecretsStoreBinding,
+  normalizeWorkflowBinding,
   resolveConfigPath
-} from "../index-5vzcszr2.js";
+} from "../index-syscwrjp.js";
 import {
   getEffectiveAccountId,
   getPrimaryAccount
@@ -72,7 +97,7 @@ import {
   getApiToken,
   isAuthenticated
 } from "../index-mg8vwqxf.js";
-import"../index-c0whkev9.js";
+import"../index-z40mjts9.js";
 import"../index-q8f4kawk.js";
 import {
   __require
@@ -456,7 +481,8 @@ import { readFile } from "fs/promises";
 import { dirname as dirname3, join as join3 } from "path";
 
 // src/test/simple-context-gateway-script.ts
-function buildGatewayScript(bundledCode, wrappers) {
+function buildGatewayScript(bundledCode, wrappers, nativeRpcBindingNames = []) {
+  const nativeRpcBindingsLiteral = JSON.stringify(nativeRpcBindingNames);
   return `
 // Bundled transport + DO classes
 ${bundledCode}
@@ -464,6 +490,8 @@ ${bundledCode}
 // DO Wrappers with RPC
 ${wrappers}
 
+const __nativeRpcBindings = new Set(${nativeRpcBindingsLiteral})
+
 // Transport encoding helper
 const __transportEncoders = typeof transport !== 'undefined' ? transport : {}
 
@@ -584,7 +612,7 @@ async function executeRpc(env, method, params) {
 		const [, idSerialized, rpcMethod, rpcParams] = params
 		const stub = binding.get(binding.idFromString(idSerialized.hex))
 
-		if (typeof stub[rpcMethod] === 'function') {
+		if (__nativeRpcBindings.has(bindingName) && typeof stub[rpcMethod] === 'function') {
 			let result = await stub[rpcMethod](...(rpcParams || []))
 			result = __encodeTransport(result)
 			return result
@@ -949,17 +977,22 @@ async function bundleDurableObjectModules(configDir, doInfos, transportFile) {
   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("", "")
+      script: buildGatewayScript(workflowEntrypointScript, "")
     };
   }
   const { doConfig, doInfos } = await resolveLocalDurableObjects(config, configDir);
   const bundledCode = await bundleDurableObjectModules(configDir, doInfos, transportFile);
   const wrapperCode = buildWrapperCode(doInfos);
+  const entrypointCode = [workflowEntrypointScript, bundledCode].filter(Boolean).join(`
+
+`);
+  const nativeRpcBindingNames = doInfos.filter((info) => info.nativeRpc).map((info) => info.name);
   return {
     durableObjects: doConfig,
-    script: buildGatewayScript(bundledCode, wrapperCode)
+    script: buildGatewayScript(entrypointCode, wrapperCode, nativeRpcBindingNames)
   };
 }
 
@@ -1017,9 +1050,70 @@ function createRemoteCloudflareClient(accountId) {
 }
 
 // src/test/remote-ai.ts
+function encodePathSegment(value) {
+  return encodeURIComponent(value);
+}
+function applyExtraHeaders(headers, extraHeaders) {
+  if (!extraHeaders) {
+    return;
+  }
+  for (const [key, value] of Object.entries(extraHeaders)) {
+    headers.set(key, String(value));
+  }
+}
+function createRemoteAIGateway(cloudflare, gatewayId, owner) {
+  const encodedGatewayId = encodePathSegment(gatewayId);
+  const gateway = {
+    async patchLog(logId, data) {
+      await cloudflare.jsonRequest({
+        method: "PATCH",
+        path: `/ai-gateway/gateways/${encodedGatewayId}/logs/${encodePathSegment(logId)}`,
+        serviceLabel: "AI Gateway",
+        body: JSON.stringify(data)
+      });
+    },
+    async getLog(logId) {
+      return cloudflare.jsonRequest({
+        method: "GET",
+        path: `/ai-gateway/gateways/${encodedGatewayId}/logs/${encodePathSegment(logId)}`,
+        serviceLabel: "AI Gateway"
+      });
+    },
+    async getUrl(provider) {
+      const accountId = await cloudflare.getAccountId();
+      const baseUrl = `https://gateway.ai.cloudflare.com/v1/${encodePathSegment(accountId)}/${encodedGatewayId}`;
+      return provider ? `${baseUrl}/${encodePathSegment(provider)}` : `${baseUrl}/`;
+    },
+    async run(data, options) {
+      const [url, token] = await Promise.all([gateway.getUrl(), cloudflare.getToken()]);
+      const headers = new Headers({
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      });
+      applyExtraHeaders(headers, options?.extraHeaders);
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(data),
+        signal: options?.signal
+      });
+      const logId = response.headers.get("cf-aig-log-id") ?? response.headers.get("cf-ai-gateway-log-id");
+      if (logId) {
+        owner.aiGatewayLogId = logId;
+      }
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`AI Gateway API error (${response.status}): ${errorText}`);
+      }
+      return response;
+    }
+  };
+  return gateway;
+}
 function createRemoteAI(accountId) {
   const cloudflare = createRemoteCloudflareClient(accountId);
   const ai = {
+    aiGatewayLogId: null,
     async run(model, inputs) {
       return cloudflare.jsonRequest({
         method: "POST",
@@ -1028,9 +1122,8 @@ function createRemoteAI(accountId) {
         body: JSON.stringify(inputs)
       });
     },
-    gateway(_gatewayId) {
-      console.warn("AI Gateway is not supported in remote test mode");
-      return ai;
+    gateway(gatewayId) {
+      return createRemoteAIGateway(cloudflare, gatewayId, ai);
     }
   };
   return ai;
@@ -1101,169 +1194,1106 @@ function createRemoteVectorize(indexName, accountId) {
   return vectorize;
 }
 
-// src/test/simple-context-bindings.ts
-function buildRemoteAndStaticBindings(config) {
-  const remoteBindings = {};
-  if (isRemoteModeActive()) {
-    if (config.bindings?.ai) {
-      const aiBindingName = config.bindings.ai.binding || "AI";
-      remoteBindings[aiBindingName] = createRemoteAI(config.accountId);
-    }
-    if (config.bindings?.vectorize) {
-      for (const [name, vectorConfig] of Object.entries(config.bindings.vectorize)) {
-        remoteBindings[name] = createRemoteVectorize(vectorConfig.indexName, config.accountId);
-      }
-    }
-  }
-  if (config.vars) {
-    for (const [key, value] of Object.entries(config.vars)) {
-      remoteBindings[key] = value;
-    }
-  }
-  if (config.bindings?.sendEmail) {
-    for (const [name, binding] of Object.entries(config.bindings.sendEmail)) {
-      remoteBindings[name] = createLocalSendEmailBinding(binding);
-    }
-  }
-  return remoteBindings;
+// src/test/utilities/context.ts
+function createMockTestContext(options = {}) {
+  const waitUntilPromises = [];
+  const ctx = {
+    waitUntil(promise) {
+      waitUntilPromises.push(promise);
+    },
+    passThroughOnException() {},
+    props: {}
+  };
+  return {
+    env: options.env ?? {},
+    ctx,
+    request: options.request ?? null,
+    waitUntilPromises
+  };
 }
-
-// src/test/email.ts
-import { join as join4 } from "path";
-var miniflarePort = 8787;
-var emailListeners = [];
-var sentEmails = [];
-var emailHandlerPath = null;
-var configDir = null;
-var testEnvGetter = null;
-function configureEmail(options = {}) {
-  if (options.port) {
-    miniflarePort = options.port;
-  }
-  emailHandlerPath = options.handlerPath ?? emailHandlerPath;
-  configDir = options.configDir ?? configDir;
-  testEnvGetter = options.getEnv ?? testEnvGetter;
+async function withTestContext(options, handler) {
+  const testCtx = createMockTestContext(options);
+  return runWithContext(testCtx.env, testCtx.ctx, options.request ?? null, handler, options.type ?? "fetch");
 }
-function buildRawEmail(options) {
-  if (options.raw) {
-    return options.raw;
-  }
-  const lines = [];
-  const messageId = `<${Date.now()}-${Math.random().toString(36).slice(2)}@devflare.dev>`;
-  const date = new Date().toUTCString();
-  lines.push(`From: ${options.from}`);
-  lines.push(`To: ${options.to}`);
-  lines.push(`Date: ${date}`);
-  lines.push(`Message-ID: ${messageId}`);
-  if (options.subject) {
-    lines.push(`Subject: ${options.subject}`);
+// src/test/utilities/kv.ts
+function createMockKV(initialData = {}) {
+  const store = new Map;
+  const metadata = new Map;
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  for (const [key, value] of Object.entries(initialData)) {
+    store.set(key, encoder.encode(value));
   }
-  if (options.headers) {
-    for (const [key, value] of Object.entries(options.headers)) {
-      lines.push(`${key}: ${value}`);
+  const toBytes = async (value) => {
+    if (typeof value === "string") {
+      return encoder.encode(value);
     }
-  }
-  lines.push("MIME-Version: 1.0");
-  lines.push("Content-Type: text/plain; charset=UTF-8");
-  lines.push("");
-  lines.push(options.body ?? "");
-  return lines.join(`\r
-`);
-}
-function createEmailHeaders(rawEmail) {
-  const headers = new Headers;
-  const lines = rawEmail.split(/\r?\n/);
-  for (const line of lines) {
-    if (!line.trim()) {
-      break;
+    if (value instanceof ArrayBuffer) {
+      return new Uint8Array(value.slice(0));
     }
-    const colonIndex = line.indexOf(":");
-    if (colonIndex <= 0) {
-      continue;
+    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;
     }
-    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();
+    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;
+      }
     }
-  });
-}
-function resolveEmailHandler(module) {
-  if (typeof module.default === "function") {
-    return module.default;
-  }
-  if (module.default && typeof module.default.email === "function") {
-    return module.default.email.bind(module.default);
-  }
-  if (typeof module.email === "function") {
-    return module.email;
-  }
-  return null;
-}
-function getRecordedRawContent(raw) {
-  if (typeof raw === "string") {
-    return raw;
-  }
-  return;
-}
-async function send(options) {
-  const raw = buildRawEmail(options);
-  if (emailHandlerPath && configDir && testEnvGetter) {
-    const absolutePath = join4(configDir, emailHandlerPath);
-    const handlerModule = await import(absolutePath);
-    const emailHandler = resolveEmailHandler(handlerModule);
-    if (!emailHandler) {
-      throw new Error(`Email handler at "${emailHandlerPath}" must export a default function or named "email" export.
-NaN`);
+    const combined = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      combined.set(chunk, offset);
+      offset += chunk.length;
     }
-    const waitUntilPromises = [];
-    const ctx = {
-      waitUntil(promise) {
-        waitUntilPromises.push(promise);
-      },
-      passThroughOnException() {},
-      props: {}
-    };
-    const runtimeEnv = testEnvGetter();
-    const timestamp = new Date;
-    const message = {
-      from: options.from,
-      to: options.to,
-      headers: createEmailHeaders(raw),
-      raw: createRawEmailStream(raw),
-      rawSize: raw.length,
-      setReject(reason) {
-        throw new Error(`Email rejected: ${reason}`);
-      },
-      async forward(rcptTo) {
-        recordSentEmail({
-          type: "forward",
-          from: options.from,
-          to: rcptTo,
-          raw,
-          timestamp
-        });
-      },
-      async reply(message2) {
-        recordSentEmail({
-          type: "reply",
-          from: message2.from ?? options.to,
-          to: message2.to ?? options.from,
-          raw: getRecordedRawContent(message2.raw),
-          timestamp
-        });
+    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;
       }
-    };
-    const emailEvent = createEmailEvent(message, runtimeEnv, ctx);
-    await runWithEventContext(emailEvent, () => emailHandler(emailEvent));
-    await Promise.all(waitUntilPromises);
-    return new Response(JSON.stringify({ ok: true, from: options.from, to: options.to }), {
-      headers: { "Content-Type": "application/json" }
+      case "stream": {
+        const copy = new Uint8Array(bytes.length);
+        copy.set(bytes);
+        return new ReadableStream({
+          start(controller) {
+            controller.enqueue(copy);
+            controller.close();
+          }
+        });
+      }
+      default:
+        return decoder.decode(bytes);
+    }
+  };
+  const resolveType = (options) => {
+    const type = typeof options === "string" ? options : options?.type ?? "text";
+    return type;
+  };
+  return {
+    async get(key, options) {
+      const bytes = store.get(key);
+      if (bytes === undefined)
+        return null;
+      return decodeBytes(bytes, resolveType(options));
+    },
+    async put(key, value, _options) {
+      const bytes = await toBytes(value);
+      store.set(key, bytes);
+    },
+    async delete(key) {
+      store.delete(key);
+      metadata.delete(key);
+    },
+    async list(options) {
+      const prefix = options?.prefix ?? "";
+      const limit = options?.limit ?? 1000;
+      const keys = Array.from(store.keys()).filter((key) => key.startsWith(prefix)).slice(0, limit).map((name) => ({ name }));
+      return {
+        keys,
+        list_complete: keys.length < limit,
+        cursor: undefined
+      };
+    },
+    async getWithMetadata(key, options) {
+      const bytes = store.get(key);
+      return {
+        value: bytes === undefined ? null : decodeBytes(bytes, resolveType(options)),
+        metadata: metadata.get(key) ?? null
+      };
+    }
+  };
+}
+// src/test/utilities/d1.ts
+var TABLE_NAME_RE = /(?:from|into|update)\s+["'`]?([a-zA-Z_][a-zA-Z0-9_]*)["'`]?/i;
+var extractTable = (sql) => {
+  const match = TABLE_NAME_RE.exec(sql);
+  return match ? match[1] : null;
+};
+var detectOp = (sql) => {
+  const trimmed = sql.trimStart().toLowerCase();
+  if (trimmed.startsWith("select"))
+    return "select";
+  if (trimmed.startsWith("insert"))
+    return "insert";
+  if (trimmed.startsWith("update"))
+    return "update";
+  if (trimmed.startsWith("delete"))
+    return "delete";
+  return "other";
+};
+function createMockD1(mockResultsOrOptions = []) {
+  const options = Array.isArray(mockResultsOrOptions) ? { results: mockResultsOrOptions } : mockResultsOrOptions;
+  const tables = new Map;
+  for (const [name, rows] of Object.entries(options.fixtures ?? {})) {
+    tables.set(name, [...rows]);
+  }
+  const fallback = options.results ?? [];
+  const resolveRows = (sql) => {
+    const op = detectOp(sql);
+    const table = extractTable(sql);
+    if (table && tables.has(table)) {
+      return { rows: tables.get(table) ?? [], op, table };
+    }
+    return { rows: [...fallback], op, table };
+  };
+  const createStatement = (sql) => {
+    let boundValues = [];
+    const statement = {
+      bind(...values) {
+        boundValues = values;
+        return statement;
+      },
+      async first(column) {
+        const { rows } = resolveRows(sql);
+        const row = rows[0];
+        if (!row)
+          return null;
+        if (column)
+          return row[column];
+        return row;
+      },
+      async all() {
+        const { rows } = resolveRows(sql);
+        return {
+          results: rows,
+          success: true,
+          meta: { duration: 0, changes: 0, last_row_id: 0 }
+        };
+      },
+      async run() {
+        const { op, table } = resolveRows(sql);
+        let changes = 0;
+        let lastRowId = 0;
+        if (op === "insert" && table) {
+          const rows = tables.get(table) ?? [];
+          const bound = boundValues.length > 0 ? Object.fromEntries(boundValues.map((v, i) => [`col${i}`, v])) : {};
+          rows.push(bound);
+          tables.set(table, rows);
+          changes = 1;
+          lastRowId = rows.length;
+        } else if (op === "delete" && table) {
+          const rows = tables.get(table) ?? [];
+          changes = rows.length;
+          tables.set(table, []);
+        } else if (op === "update" && table) {
+          changes = (tables.get(table) ?? []).length;
+        }
+        return {
+          results: [],
+          success: true,
+          meta: { duration: 0, changes, last_row_id: lastRowId }
+        };
+      },
+      async raw(_options) {
+        const { rows } = resolveRows(sql);
+        return rows.map((row) => Object.values(row));
+      }
+    };
+    return statement;
+  };
+  return {
+    prepare(query) {
+      return createStatement(query);
+    },
+    async exec(_query) {
+      return {
+        results: [],
+        success: true,
+        meta: { duration: 0, changes: 0, last_row_id: 0 }
+      };
+    },
+    async batch(statements) {
+      return statements.map(() => ({
+        results: [],
+        success: true,
+        meta: { duration: 0, changes: 0, last_row_id: 0 }
+      }));
+    },
+    async dump() {
+      return new ArrayBuffer(0);
+    },
+    withSession(_constraintOrBookmark) {
+      return this;
+    }
+  };
+}
+// src/test/utilities/r2.ts
+function createMockR2() {
+  const store = new Map;
+  const createR2Object = (key, content, metadata) => {
+    const encoder = new TextEncoder;
+    const data = encoder.encode(content);
+    return {
+      key,
+      version: "1",
+      size: data.length,
+      etag: `"${key}-etag"`,
+      httpEtag: `"${key}-etag"`,
+      uploaded: new Date,
+      httpMetadata: metadata ?? {},
+      customMetadata: {},
+      checksums: {},
+      storageClass: "Standard",
+      body: new ReadableStream({
+        start(controller) {
+          controller.enqueue(data);
+          controller.close();
+        }
+      }),
+      bodyUsed: false,
+      async arrayBuffer() {
+        return new Uint8Array(data).buffer;
+      },
+      async text() {
+        return content;
+      },
+      async json() {
+        return JSON.parse(content);
+      },
+      async blob() {
+        return new Blob([data]);
+      },
+      writeHttpMetadata(headers) {}
+    };
+  };
+  return {
+    async put(key, value, options) {
+      let content;
+      if (typeof value === "string") {
+        content = value;
+      } else if (value instanceof ArrayBuffer) {
+        content = new TextDecoder().decode(value);
+      } else if (value instanceof Blob) {
+        content = await value.text();
+      } else if (value === null) {
+        content = "";
+      } else {
+        const reader = value.getReader();
+        const chunks = [];
+        let done = false;
+        while (!done) {
+          const result = await reader.read();
+          done = result.done;
+          if (result.value) {
+            chunks.push(new TextDecoder().decode(result.value));
+          }
+        }
+        content = chunks.join("");
+      }
+      store.set(key, { content });
+      return createR2Object(key, content);
+    },
+    async get(key, options) {
+      const item = store.get(key);
+      if (!item)
+        return null;
+      return createR2Object(key, item.content, item.metadata);
+    },
+    async head(key) {
+      const item = store.get(key);
+      if (!item)
+        return null;
+      return {
+        key,
+        version: "1",
+        size: new TextEncoder().encode(item.content).length,
+        etag: `"${key}-etag"`,
+        httpEtag: `"${key}-etag"`,
+        uploaded: new Date,
+        httpMetadata: item.metadata ?? {},
+        customMetadata: {},
+        checksums: {},
+        storageClass: "Standard",
+        writeHttpMetadata(headers) {}
+      };
+    },
+    async delete(keys) {
+      const keyArray = Array.isArray(keys) ? keys : [keys];
+      for (const key of keyArray) {
+        store.delete(key);
+      }
+    },
+    async list(options) {
+      const objects = Array.from(store.entries()).map(([key, { content, metadata }]) => createR2Object(key, content, metadata));
+      return {
+        objects,
+        truncated: false,
+        delimitedPrefixes: []
+      };
+    },
+    async createMultipartUpload(key, options) {
+      throw new Error("Multipart upload not implemented in mock");
+    },
+    async resumeMultipartUpload(key, uploadId) {
+      throw new Error("Multipart upload not implemented in mock");
+    }
+  };
+}
+// src/test/utilities/queue.ts
+function createMockQueue() {
+  const messages = [];
+  const metrics = {
+    backlogCount: 0,
+    backlogBytes: 0
+  };
+  const response = { metadata: { metrics } };
+  return {
+    async metrics() {
+      return metrics;
+    },
+    async send(message, options) {
+      messages.push({ body: message, options });
+      return response;
+    },
+    async sendBatch(batch, options) {
+      for (const message of batch) {
+        messages.push({
+          body: message.body,
+          options: {
+            contentType: message.contentType,
+            delaySeconds: message.delaySeconds ?? options?.delaySeconds
+          }
+        });
+      }
+      return response;
+    },
+    _getMessages() {
+      return messages;
+    }
+  };
+}
+// src/test/utilities/platform.ts
+function createMockRateLimit(options = {}) {
+  const limit = options.limit ?? Number.MAX_SAFE_INTEGER;
+  const periodMs = (options.period ?? 60) * 1000;
+  const windows = new Map;
+  return {
+    async limit({ key }) {
+      const now = Date.now();
+      const existing = windows.get(key);
+      if (!existing || existing.resetAt <= now) {
+        windows.set(key, { count: 1, resetAt: now + periodMs });
+        return { success: limit >= 1 };
+      }
+      existing.count += 1;
+      return { success: existing.count <= limit };
+    }
+  };
+}
+function createMockVersionMetadata(metadata = {}) {
+  return {
+    id: metadata.id ?? "devflare-local-version",
+    tag: metadata.tag ?? "local",
+    timestamp: metadata.timestamp ?? "1970-01-01T00:00:00.000Z"
+  };
+}
+function createMockSecretsStoreSecret(value) {
+  return {
+    async get() {
+      return value;
+    }
+  };
+}
+function defaultPortForDatabaseUrl(url) {
+  if (url.port) {
+    return Number(url.port);
+  }
+  return url.protocol === "mysql:" ? 3306 : 5432;
+}
+function createMockHyperdrive(connectionString) {
+  const url = new URL(connectionString);
+  return {
+    connectionString,
+    host: url.hostname,
+    port: defaultPortForDatabaseUrl(url),
+    user: decodeURIComponent(url.username),
+    password: decodeURIComponent(url.password),
+    database: decodeURIComponent(url.pathname.replace(/^\//, "")),
+    connect() {
+      throw new Error("Mock Hyperdrive connect() is not implemented. Use connectionString with your database client, or run a Miniflare-backed test for socket behavior.");
+    }
+  };
+}
+function createDefaultWorkerStub() {
+  return {
+    getEntrypoint() {
+      throw new Error("Mock WorkerLoader stub has no entrypoint. Pass createMockWorkerLoader({ stub }) for behavior.");
+    },
+    getDurableObjectClass() {
+      throw new Error("Mock WorkerLoader stub has no Durable Object class. Pass createMockWorkerLoader({ stub }) for behavior.");
+    }
+  };
+}
+function createMockWorkerLoader(options = {}) {
+  const stub = options.stub ?? createDefaultWorkerStub();
+  return {
+    get(_name, _getCode) {
+      return stub;
+    },
+    load(_code) {
+      return stub;
+    }
+  };
+}
+function defaultMTLSCertificateHandler() {
+  throw new Error("Mock mTLS Certificate Fetcher has no handler. Pass createMockMTLSCertificate(handler) for behavior.");
+}
+function createMockMTLSCertificate(handler = defaultMTLSCertificateHandler) {
+  return {
+    async fetch(input, init) {
+      return handler(input, init);
+    }
+  };
+}
+function createMockDispatchNamespace(options = {}) {
+  return {
+    get(name) {
+      const worker = options.workers?.[name];
+      if (!worker) {
+        throw new Error(`Mock DispatchNamespace has no worker named "${name}".`);
+      }
+      return typeof worker === "function" ? createMockMTLSCertificate(worker) : worker;
+    }
+  };
+}
+// src/test/utilities/workflows.ts
+function createMockWorkflowInstance(id, options = {}) {
+  let status = options.status ?? "queued";
+  let output = options.output;
+  let error = options.error;
+  return {
+    id,
+    async pause() {
+      status = "paused";
+    },
+    async resume() {
+      status = "running";
+    },
+    async terminate() {
+      status = "terminated";
+    },
+    async restart() {
+      status = "queued";
+      error = undefined;
+      output = undefined;
+    },
+    async status() {
+      return {
+        status,
+        ...error && { error },
+        ...output !== undefined && { output }
+      };
+    },
+    async sendEvent(_event) {}
+  };
+}
+function createMockWorkflow(options = {}) {
+  const instances = new Map;
+  let sequence = 0;
+  for (const [id, instanceOptions] of Object.entries(options.instances ?? {})) {
+    instances.set(id, createMockWorkflowInstance(id, instanceOptions));
+  }
+  const createInstance = (id) => {
+    if (instances.has(id)) {
+      throw new Error(`Mock Workflow already has an instance named "${id}".`);
+    }
+    const instance = createMockWorkflowInstance(id);
+    instances.set(id, instance);
+    return instance;
+  };
+  return {
+    async get(id) {
+      const instance = instances.get(id);
+      if (!instance) {
+        throw new Error(`Mock Workflow has no instance named "${id}".`);
+      }
+      return instance;
+    },
+    async create(options2) {
+      const id = options2?.id ?? `mock-workflow-${++sequence}`;
+      return createInstance(id);
+    },
+    async createBatch(batch) {
+      return batch.map((options2) => {
+        const id = options2.id ?? `mock-workflow-${++sequence}`;
+        return createInstance(id);
+      });
+    }
+  };
+}
+function createMockPipeline() {
+  const records = [];
+  return {
+    async send(batch) {
+      records.push(...batch);
+    },
+    _getRecords() {
+      return [...records];
+    }
+  };
+}
+// src/test/utilities/media.ts
+function createEmptyImageStream() {
+  return new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+}
+function createMockImageTransformationResult(response) {
+  return {
+    response() {
+      return response.clone();
+    },
+    contentType() {
+      return response.headers.get("Content-Type") ?? "image/png";
+    },
+    image() {
+      const cloned = response.clone();
+      return cloned.body ?? createEmptyImageStream();
+    }
+  };
+}
+function createMockImageTransformer(response) {
+  const transformer = {
+    transform(_transform) {
+      return transformer;
+    },
+    draw(_image, _options) {
+      return transformer;
+    },
+    async output(_options) {
+      return createMockImageTransformationResult(response);
+    }
+  };
+  return transformer;
+}
+function createMockHostedImagesBinding() {
+  const unsupported = () => {
+    throw new Error("Mock Images hosted API is not implemented. Pass a custom ImagesBinding through createMockEnv({ images }) if your test needs hosted image behavior.");
+  };
+  return {
+    image(_imageId) {
+      return {
+        details: unsupported,
+        bytes: unsupported,
+        update: unsupported,
+        delete: unsupported
+      };
+    },
+    upload: unsupported,
+    list: unsupported
+  };
+}
+function createMockImagesBinding(options = {}) {
+  const response = options.response ?? new Response("", {
+    headers: { "Content-Type": "image/png" }
+  });
+  const info = options.info ?? {
+    format: response.headers.get("Content-Type") ?? "image/png",
+    fileSize: 0,
+    width: 0,
+    height: 0
+  };
+  return {
+    async info(_stream, _options) {
+      return info;
+    },
+    input(_stream, _options) {
+      return createMockImageTransformer(response);
+    },
+    hosted: createMockHostedImagesBinding()
+  };
+}
+function createEmptyMediaStream() {
+  return new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+}
+function createMockMediaTransformationResult(response) {
+  return {
+    async media() {
+      const cloned = response.clone();
+      return cloned.body ?? createEmptyMediaStream();
+    },
+    async response() {
+      return response.clone();
+    },
+    async contentType() {
+      return response.headers.get("Content-Type") ?? "video/mp4";
+    }
+  };
+}
+function createMockMediaTransformer(response) {
+  const transformer = {
+    transform(_transform) {
+      return {
+        output(_output) {
+          return createMockMediaTransformationResult(response);
+        }
+      };
+    },
+    output(_output) {
+      return createMockMediaTransformationResult(response);
+    }
+  };
+  return transformer;
+}
+function createMockMediaBinding(options = {}) {
+  const response = options.response ?? new Response("", {
+    headers: { "Content-Type": "video/mp4" }
+  });
+  return {
+    input(_media) {
+      return createMockMediaTransformer(response);
+    }
+  };
+}
+// src/test/utilities/artifacts.ts
+function createArtifactTimestamp() {
+  return new Date("2026-04-26T00:00:00.000Z").toISOString();
+}
+function createArtifactsRepoInfo(name, options = {}) {
+  const now = createArtifactTimestamp();
+  return {
+    id: `repo-${name}`,
+    name,
+    description: options.description ?? null,
+    defaultBranch: options.defaultBranch ?? "main",
+    createdAt: now,
+    updatedAt: now,
+    lastPushAt: null,
+    source: options.source ?? null,
+    readOnly: options.readOnly ?? false,
+    remote: `https://example.com/artifacts/default/${name}.git`
+  };
+}
+function isArtifactsBinding(value) {
+  return typeof value.create === "function";
+}
+function createMockArtifacts(options = {}) {
+  const repos = new Map;
+  const tokens = new Map;
+  const addRepo = (info) => {
+    repos.set(info.name, info);
+    if (!tokens.has(info.name)) {
+      tokens.set(info.name, []);
+    }
+  };
+  for (const repo of options.repos ?? []) {
+    addRepo({
+      ...createArtifactsRepoInfo(repo.name),
+      ...repo
+    });
+  }
+  const createToken = (repoName, scope = "write", ttl = 86400) => {
+    const existing = tokens.get(repoName) ?? [];
+    const id = `token-${repoName}-${existing.length + 1}`;
+    const expiresAt = new Date(Date.parse(createArtifactTimestamp()) + ttl * 1000).toISOString();
+    const token = {
+      id,
+      scope,
+      state: "active",
+      createdAt: createArtifactTimestamp(),
+      expiresAt
+    };
+    tokens.set(repoName, [...existing, token]);
+    return {
+      id,
+      plaintext: `${id}-plaintext`,
+      scope,
+      expiresAt
+    };
+  };
+  const createRepoHandle = (info) => ({
+    ...info,
+    async createToken(scope, ttl) {
+      return createToken(info.name, scope, ttl);
+    },
+    async listTokens() {
+      const repoTokens = tokens.get(info.name) ?? [];
+      return {
+        tokens: repoTokens,
+        total: repoTokens.length
+      };
+    },
+    async revokeToken(tokenOrId) {
+      const repoTokens = tokens.get(info.name) ?? [];
+      const index = repoTokens.findIndex((token) => token.id === tokenOrId);
+      if (index === -1) {
+        return false;
+      }
+      repoTokens[index] = {
+        ...repoTokens[index],
+        state: "revoked"
+      };
+      tokens.set(info.name, repoTokens);
+      return true;
+    },
+    async fork(name, forkOptions) {
+      return createRepo(name, {
+        description: forkOptions?.description ?? info.description ?? undefined,
+        readOnly: forkOptions?.readOnly ?? info.readOnly,
+        setDefaultBranch: info.defaultBranch,
+        source: `artifacts:default/${info.name}`
+      });
+    }
+  });
+  const createRepo = async (name, createOptions = {}) => {
+    const info = createArtifactsRepoInfo(name, {
+      description: createOptions.description,
+      readOnly: createOptions.readOnly,
+      defaultBranch: createOptions.setDefaultBranch,
+      source: createOptions.source
+    });
+    addRepo(info);
+    const token = createToken(name);
+    return {
+      id: info.id,
+      name: info.name,
+      description: info.description,
+      defaultBranch: info.defaultBranch,
+      remote: info.remote,
+      token: token.plaintext,
+      tokenExpiresAt: token.expiresAt
+    };
+  };
+  return {
+    create: createRepo,
+    async get(name) {
+      const repo = repos.get(name);
+      return repo ? createRepoHandle(repo) : null;
+    },
+    async import(params) {
+      return createRepo(params.target.name, {
+        description: params.target.opts?.description,
+        readOnly: params.target.opts?.readOnly,
+        source: params.source.url
+      });
+    },
+    async list(opts) {
+      const limit = opts?.limit ?? 50;
+      const repoList = Array.from(repos.values()).slice(0, limit).map((repo) => {
+        const { remote: _remote, ...rest } = repo;
+        return rest;
+      });
+      return {
+        repos: repoList,
+        total: repos.size,
+        ...repos.size > repoList.length && { cursor: String(repoList.length) }
+      };
+    },
+    async delete(name) {
+      tokens.delete(name);
+      return repos.delete(name);
+    }
+  };
+}
+// src/test/utilities/env.ts
+function createMockEnv(options = {}) {
+  const env2 = {};
+  if (options.kv) {
+    for (const name of options.kv) {
+      env2[name] = createMockKV();
+    }
+  }
+  if (options.d1) {
+    for (const name of options.d1) {
+      env2[name] = createMockD1();
+    }
+  }
+  if (options.r2) {
+    for (const name of options.r2) {
+      env2[name] = createMockR2();
+    }
+  }
+  if (options.queues) {
+    for (const name of options.queues) {
+      env2[name] = createMockQueue();
+    }
+  }
+  if (options.rateLimits) {
+    for (const [name, rateLimitOptions] of Object.entries(options.rateLimits)) {
+      env2[name] = createMockRateLimit(rateLimitOptions);
+    }
+  }
+  if (options.versionMetadata) {
+    env2[options.versionMetadata] = createMockVersionMetadata();
+  }
+  if (options.hyperdrive) {
+    for (const [name, binding] of Object.entries(options.hyperdrive)) {
+      env2[name] = typeof binding === "string" ? createMockHyperdrive(binding) : binding;
+    }
+  }
+  if (Array.isArray(options.workerLoaders)) {
+    for (const name of options.workerLoaders) {
+      env2[name] = createMockWorkerLoader();
+    }
+  } else if (options.workerLoaders) {
+    for (const [name, workerLoaderOptions] of Object.entries(options.workerLoaders)) {
+      env2[name] = createMockWorkerLoader(workerLoaderOptions);
+    }
+  }
+  if (Array.isArray(options.mtlsCertificates)) {
+    for (const name of options.mtlsCertificates) {
+      env2[name] = createMockMTLSCertificate();
+    }
+  } else if (options.mtlsCertificates) {
+    for (const [name, handler] of Object.entries(options.mtlsCertificates)) {
+      env2[name] = createMockMTLSCertificate(handler);
+    }
+  }
+  if (Array.isArray(options.dispatchNamespaces)) {
+    for (const name of options.dispatchNamespaces) {
+      env2[name] = createMockDispatchNamespace();
+    }
+  } else if (options.dispatchNamespaces) {
+    for (const [name, dispatchNamespaceOptions] of Object.entries(options.dispatchNamespaces)) {
+      env2[name] = createMockDispatchNamespace(dispatchNamespaceOptions);
+    }
+  }
+  if (Array.isArray(options.workflows)) {
+    for (const name of options.workflows) {
+      env2[name] = createMockWorkflow();
+    }
+  } else if (options.workflows) {
+    for (const [name, workflowOptions] of Object.entries(options.workflows)) {
+      env2[name] = "create" in workflowOptions ? workflowOptions : createMockWorkflow(workflowOptions);
+    }
+  }
+  if (Array.isArray(options.pipelines)) {
+    for (const name of options.pipelines) {
+      env2[name] = createMockPipeline();
+    }
+  } else if (options.pipelines) {
+    for (const [name, pipeline] of Object.entries(options.pipelines)) {
+      env2[name] = pipeline;
+    }
+  }
+  if (typeof options.images === "string") {
+    env2[options.images] = createMockImagesBinding();
+  } else if (options.images) {
+    env2.IMAGES = options.images;
+  }
+  if (typeof options.media === "string") {
+    env2[options.media] = createMockMediaBinding();
+  } else if (options.media) {
+    env2.MEDIA = options.media;
+  }
+  if (Array.isArray(options.artifacts)) {
+    for (const name of options.artifacts) {
+      env2[name] = createMockArtifacts();
+    }
+  } else if (options.artifacts) {
+    for (const [name, artifactsOptions] of Object.entries(options.artifacts)) {
+      env2[name] = isArtifactsBinding(artifactsOptions) ? artifactsOptions : createMockArtifacts(artifactsOptions);
+    }
+  }
+  if (options.secretsStore) {
+    for (const [name, value] of Object.entries(options.secretsStore)) {
+      env2[name] = createMockSecretsStoreSecret(value);
+    }
+  }
+  if (options.vars) {
+    Object.assign(env2, options.vars);
+  }
+  if (options.secrets) {
+    Object.assign(env2, options.secrets);
+  }
+  if (options.custom) {
+    Object.assign(env2, options.custom);
+  }
+  return env2;
+}
+// src/test/simple-context-bindings.ts
+function buildRemoteAndStaticBindings(config) {
+  const remoteBindings = {};
+  if (isRemoteModeActive()) {
+    if (config.bindings?.ai) {
+      const aiBindingName = config.bindings.ai.binding || "AI";
+      remoteBindings[aiBindingName] = createRemoteAI(config.accountId);
+    }
+    if (config.bindings?.vectorize) {
+      for (const [name, vectorConfig] of Object.entries(config.bindings.vectorize)) {
+        remoteBindings[name] = createRemoteVectorize(vectorConfig.indexName, config.accountId);
+      }
+    }
+  }
+  if (config.vars) {
+    for (const [key, value] of Object.entries(config.vars)) {
+      remoteBindings[key] = value;
+    }
+  }
+  if (config.bindings?.sendEmail) {
+    for (const [name, binding] of Object.entries(config.bindings.sendEmail)) {
+      remoteBindings[name] = createLocalSendEmailBinding(binding);
+    }
+  }
+  if (config.bindings?.workerLoaders) {
+    for (const name of Object.keys(config.bindings.workerLoaders)) {
+      remoteBindings[name] = createLocalWorkerLoaderBinding();
+    }
+  }
+  if (config.bindings?.versionMetadata) {
+    remoteBindings[config.bindings.versionMetadata.binding] = createMockVersionMetadata();
+  }
+  return remoteBindings;
+}
+
+// src/test/email.ts
+import { join as join4 } from "path";
+var miniflarePort = 8787;
+var emailListeners = [];
+var sentEmails = [];
+var emailHandlerPath = null;
+var configDir = null;
+var testEnvGetter = null;
+function configureEmail(options = {}) {
+  if (options.port) {
+    miniflarePort = options.port;
+  }
+  emailHandlerPath = options.handlerPath ?? emailHandlerPath;
+  configDir = options.configDir ?? configDir;
+  testEnvGetter = options.getEnv ?? testEnvGetter;
+}
+function buildRawEmail(options) {
+  if (options.raw) {
+    return options.raw;
+  }
+  const lines = [];
+  const messageId = `<${Date.now()}-${Math.random().toString(36).slice(2)}@devflare.dev>`;
+  const date = new Date().toUTCString();
+  lines.push(`From: ${options.from}`);
+  lines.push(`To: ${options.to}`);
+  lines.push(`Date: ${date}`);
+  lines.push(`Message-ID: ${messageId}`);
+  if (options.subject) {
+    lines.push(`Subject: ${options.subject}`);
+  }
+  if (options.headers) {
+    for (const [key, value] of Object.entries(options.headers)) {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  lines.push("MIME-Version: 1.0");
+  lines.push("Content-Type: text/plain; charset=UTF-8");
+  lines.push("");
+  lines.push(options.body ?? "");
+  return lines.join(`\r
+`);
+}
+function createEmailHeaders(rawEmail) {
+  const headers = new Headers;
+  const lines = rawEmail.split(/\r?\n/);
+  for (const line of lines) {
+    if (!line.trim()) {
+      break;
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex <= 0) {
+      continue;
+    }
+    headers.append(line.slice(0, colonIndex).trim(), line.slice(colonIndex + 1).trim());
+  }
+  return headers;
+}
+function createRawEmailStream(rawEmail) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(new TextEncoder().encode(rawEmail));
+      controller.close();
+    }
+  });
+}
+function resolveEmailHandler(module) {
+  if (typeof module.default === "function") {
+    return module.default;
+  }
+  if (module.default && typeof module.default.email === "function") {
+    return module.default.email.bind(module.default);
+  }
+  if (typeof module.email === "function") {
+    return module.email;
+  }
+  return null;
+}
+function getRecordedRawContent(raw) {
+  if (typeof raw === "string") {
+    return raw;
+  }
+  return;
+}
+async function send(options) {
+  const raw = buildRawEmail(options);
+  if (emailHandlerPath && configDir && testEnvGetter) {
+    const absolutePath = join4(configDir, emailHandlerPath);
+    const handlerModule = await import(absolutePath);
+    const emailHandler = resolveEmailHandler(handlerModule);
+    if (!emailHandler) {
+      throw new Error(`Email handler at "${emailHandlerPath}" must export a default function or named "email" export.
+NaN`);
+    }
+    const waitUntilPromises = [];
+    const ctx = {
+      waitUntil(promise) {
+        waitUntilPromises.push(promise);
+      },
+      passThroughOnException() {},
+      props: {}
+    };
+    const runtimeEnv = testEnvGetter();
+    const timestamp = new Date;
+    const message = {
+      from: options.from,
+      to: options.to,
+      headers: createEmailHeaders(raw),
+      raw: createRawEmailStream(raw),
+      rawSize: raw.length,
+      setReject(reason) {
+        throw new Error(`Email rejected: ${reason}`);
+      },
+      async forward(rcptTo) {
+        recordSentEmail({
+          type: "forward",
+          from: options.from,
+          to: rcptTo,
+          raw,
+          timestamp
+        });
+      },
+      async reply(message2) {
+        recordSentEmail({
+          type: "reply",
+          from: message2.from ?? options.to,
+          to: message2.to ?? options.from,
+          raw: getRecordedRawContent(message2.raw),
+          timestamp
+        });
+      }
+    };
+    const emailEvent = createEmailEvent(message, runtimeEnv, ctx);
+    await runWithEventContext(emailEvent, () => emailHandler(emailEvent));
+    await Promise.all(waitUntilPromises);
+    return new Response(JSON.stringify({ ok: true, from: options.from, to: options.to }), {
+      headers: { "Content-Type": "application/json" }
     });
   }
   const url = new URL(`http://localhost:${miniflarePort}/cdn-cgi/handler/email`);
@@ -1330,6 +2360,12 @@ function resetQueueState() {
   configDir2 = null;
   testEnvGetter2 = null;
 }
+var EMPTY_QUEUE_METADATA = {
+  metrics: {
+    backlogCount: 0,
+    backlogBytes: 0
+  }
+};
 function createMessage(options) {
   const id = options.id ?? crypto.randomUUID();
   const timestamp = options.timestamp ?? new Date;
@@ -1357,6 +2393,7 @@ function createMessage(options) {
 function createMessageBatch(messages) {
   return {
     queue: "test-queue",
+    metadata: EMPTY_QUEUE_METADATA,
     messages,
     ackAll() {
       for (const msg of messages) {
@@ -1400,8 +2437,8 @@ NaN`);
     passThroughOnException() {},
     props: {}
   };
-  const env2 = testEnvGetter2();
-  const queueEvent = createQueueEvent(batch, env2, ctx);
+  const env3 = testEnvGetter2();
+  const queueEvent = createQueueEvent(batch, env3, ctx);
   await runWithEventContext(queueEvent, () => queueHandler(queueEvent));
   await Promise.all(waitUntilPromises);
   const acked = [];
@@ -1430,7 +2467,7 @@ NaN`);
 async function send2(message) {
   return trigger([message]);
 }
-var queue = {
+var queue2 = {
   trigger,
   send: send2
 };
@@ -1480,8 +2517,8 @@ NaN`);
     passThroughOnException() {},
     props: {}
   };
-  const env2 = testEnvGetter3();
-  const scheduledEvent = createScheduledEvent(controller, env2, ctx);
+  const env3 = testEnvGetter3();
+  const scheduledEvent = createScheduledEvent(controller, env3, ctx);
   try {
     await runWithEventContext(scheduledEvent, () => scheduledHandler(scheduledEvent));
     await Promise.all(waitUntilPromises);
@@ -1552,7 +2589,8 @@ async function trigger3(items) {
   });
   const absolutePath = join7(configDir4, tailHandlerPath);
   const handlerModule = await import(absolutePath);
-  const tailHandler = handlerModule.default ?? handlerModule.tail;
+  const defaultExport = handlerModule.default;
+  const tailHandler = typeof defaultExport === "function" ? defaultExport : defaultExport && typeof defaultExport.tail === "function" ? defaultExport.tail.bind(defaultExport) : handlerModule.tail;
   if (typeof tailHandler !== "function") {
     throw new Error(`Tail handler at "${tailHandlerPath}" must export a default function or named "tail" export.
 NaN`);
@@ -1565,10 +2603,10 @@ NaN`);
     passThroughOnException() {},
     props: {}
   };
-  const env2 = testEnvGetter4();
-  const tailEvent = createTailEvent(traceItems, env2, ctx);
+  const env3 = testEnvGetter4();
+  const tailEvent = createTailEvent(traceItems, env3, ctx);
   try {
-    await runWithEventContext(tailEvent, () => tailHandler(tailEvent));
+    await runWithEventContext(tailEvent, () => tailHandler.length >= 2 ? tailHandler(traceItems, env3, ctx) : tailHandler(tailEvent, env3, ctx));
     await Promise.all(waitUntilPromises);
     return {
       success: true,
@@ -1666,9 +2704,9 @@ async function fetch2(request, options) {
     passThroughOnException() {},
     props: {}
   };
-  const env2 = getEnv();
+  const env3 = getEnv();
   const initialRouteMatch = routeModules.length > 0 ? matchFetchRoute(routeModules, req) : null;
-  const fetchEvent = createFetchEvent(req, env2, ctx, {
+  const fetchEvent = createFetchEvent(req, env3, ctx, {
     params: initialRouteMatch?.params ?? {}
   });
   const response = await runWithEventContext(fetchEvent, () => invokeFetchModule(handlerModule, fetchEvent, routeModules.length > 0 ? createRouteResolve(routeModules, fetchEvent) : undefined));
@@ -1798,23 +2836,464 @@ async function resolveHandlerPath(configDir6, configValue, defaultPath) {
   }
 }
 async function resolveHandlerPaths(configDir6, config) {
-  const [fetch3, queue2, scheduled2, email2, tail2, routes] = await Promise.all([
+  const [fetch3, queue3, scheduled2, email2, tail2, routes] = await Promise.all([
     resolveHandlerPath(configDir6, config.files?.fetch, DEFAULT_FETCH_PATH),
     resolveHandlerPath(configDir6, config.files?.queue, DEFAULT_QUEUE_PATH),
     resolveHandlerPath(configDir6, config.files?.scheduled, DEFAULT_SCHEDULED_PATH),
     resolveHandlerPath(configDir6, config.files?.email, DEFAULT_EMAIL_PATH),
-    resolveHandlerPath(configDir6, undefined, DEFAULT_TAIL_PATH),
+    resolveHandlerPath(configDir6, config.files?.tail, DEFAULT_TAIL_PATH),
     discoverRoutes(configDir6, config)
   ]);
-  return { fetch: fetch3, queue: queue2, scheduled: scheduled2, email: email2, tail: tail2, routes };
+  return { fetch: fetch3, queue: queue3, scheduled: scheduled2, email: email2, tail: tail2, routes };
+}
+
+// src/test/simple-context-lifecycle.ts
+import { dirname as dirname5, resolve as resolve3 } from "path";
+
+// src/test/containers.ts
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync as existsSync3 } from "node:fs";
+import { stat } from "node:fs/promises";
+import { createConnection } from "node:net";
+import { basename, dirname as dirname4, isAbsolute, join as join10, resolve as resolve2 } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { execa } from "execa";
+var realContainerCommandRunner = {
+  async exec(command, args, options = {}) {
+    try {
+      const result = await execa(command, args, {
+        cwd: options.cwd,
+        env: options.env,
+        reject: false,
+        timeout: options.timeoutMs ?? 15000
+      });
+      return {
+        exitCode: result.exitCode ?? 0,
+        stdout: String(result.stdout ?? ""),
+        stderr: String(result.stderr ?? "")
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        exitCode: err.exitCode ?? 1,
+        stdout: String(err.stdout ?? ""),
+        stderr: String(err.stderr ?? err.message ?? "Container command failed")
+      };
+    }
+  }
+};
+async function detectContainerEngine(options = {}) {
+  const runner = options.runner ?? realContainerCommandRunner;
+  const candidates = options.engine && options.engine !== "auto" ? [options.engine] : ["docker", "podman"];
+  const checked = [];
+  for (const engine of candidates) {
+    let result;
+    try {
+      result = await runner.exec(engine, ["info"], { timeoutMs: 1e4 });
+    } catch (error) {
+      result = {
+        exitCode: 1,
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error)
+      };
+    }
+    if (result.exitCode === 0) {
+      checked.push({ engine, available: true });
+      return { available: true, engine, checked };
+    }
+    checked.push({
+      engine,
+      available: false,
+      reason: formatCommandFailure(result)
+    });
+  }
+  return {
+    available: false,
+    reason: checked.map((check) => `${check.engine}: ${check.reason ?? "not available"}`).join("; "),
+    checked
+  };
+}
+async function getContainerSkipReason(options = {}) {
+  const env3 = options.env ?? process.env;
+  if (!isTruthyEnvFlag(env3.DEVFLARE_CONTAINER_TESTS)) {
+    return "Container tests require DEVFLARE_CONTAINER_TESTS=1 because they launch local Docker/Podman containers.";
+  }
+  const status = await detectContainerEngine(options);
+  if (!status.available) {
+    return `No reachable Docker or Podman engine found: ${status.reason}`;
+  }
+  return null;
+}
+function createContainerManager(options = {}) {
+  const active = new Set;
+  const getRunner = () => options.runner ?? realContainerCommandRunner;
+  const manager = {
+    detectEngine(engineOptions = {}) {
+      return detectContainerEngine({
+        engine: engineOptions.engine ?? options.engine,
+        runner: engineOptions.runner ?? getRunner()
+      });
+    },
+    async start(className, startOptions) {
+      const cwd = options.cwd ?? getCallerDirectory();
+      const resolved = await resolveContainerStart(className, startOptions, cwd);
+      const status = await manager.detectEngine();
+      const engine = getAvailableContainerEngine(status, className);
+      const runner = getRunner();
+      const offline = startOptions.offline ?? true;
+      const prepared = await prepareImage({
+        engine,
+        runner,
+        image: resolved.image,
+        className,
+        configDir: resolved.configDir,
+        imageBuildContext: resolved.config?.imageBuildContext,
+        offline
+      });
+      const host = startOptions.host ?? "127.0.0.1";
+      const hostPort = startOptions.hostPort ?? await (options.allocatePort ?? getAvailablePort)();
+      const containerName = makeContainerName(className, startOptions.instance);
+      const runArgs = buildRunArgs({
+        name: containerName,
+        className,
+        image: prepared.image,
+        host,
+        hostPort,
+        containerPort: startOptions.port,
+        envVars: startOptions.envVars,
+        entrypoint: startOptions.entrypoint,
+        command: startOptions.command
+      });
+      const runResult = await runner.exec(engine, runArgs, {
+        cwd: resolved.configDir,
+        env: options.env ?? process.env
+      });
+      if (runResult.exitCode !== 0) {
+        throw new Error(`Failed to start Devflare container "${className}": ${formatCommandFailure(runResult)}`);
+      }
+      const instance = new LocalDevflareContainer({
+        id: runResult.stdout.trim() || containerName,
+        name: containerName,
+        className,
+        engine,
+        host,
+        hostPort,
+        port: startOptions.port,
+        runner,
+        fetchImpl: options.fetch ?? fetch,
+        onDispose: (container) => active.delete(container)
+      });
+      active.add(instance);
+      await waitForContainerReadiness(instance, startOptions, options.waitForPort ?? waitForTcpPort);
+      return instance;
+    },
+    async stopAll() {
+      await Promise.all([...active].map((container) => container.stop()));
+    }
+  };
+  return manager;
+}
+var defaultContainerManager = createContainerManager();
+var containers = defaultContainerManager;
+async function stopActiveContainers() {
+  await defaultContainerManager.stopAll();
+}
+function getAvailableContainerEngine(status, className) {
+  if (!status.available) {
+    throw new Error(`Cannot start Devflare container "${className}": ${status.reason}`);
+  }
+  return status.engine;
+}
+async function waitForContainerReadiness(instance, options, waitForPort) {
+  if (!(options.waitForReady ?? true)) {
+    return;
+  }
+  try {
+    await waitForPort(instance.host, instance.hostPort, options.readyTimeoutMs ?? 20000);
+  } catch (error) {
+    await instance.destroy();
+    throw error;
+  }
+}
+async function resolveContainerStart(className, options, cwd) {
+  if (options.image) {
+    return {
+      configDir: cwd,
+      image: options.image
+    };
+  }
+  const { config, configDir: configDir6 } = await loadContainerConfig(options.configPath, cwd);
+  const container = config.containers?.find((candidate) => candidate.className === className || candidate.name === className);
+  if (!container) {
+    throw new Error(`Container "${className}" was not found in devflare config.`);
+  }
+  return {
+    configDir: configDir6,
+    image: container.image,
+    config: container
+  };
+}
+async function loadContainerConfig(configPath, cwd) {
+  const absolutePath = configPath ? resolve2(cwd, configPath) : await findNearestConfig(cwd);
+  if (!absolutePath) {
+    throw new Error(`Could not find a devflare config file for container lookup. Searched upward from: ${cwd}`);
+  }
+  const configDir6 = dirname4(absolutePath);
+  const loadedConfig = await loadConfig({
+    cwd: configDir6,
+    configFile: basename(absolutePath)
+  });
+  const config = await applyLocalDevVarsToConfig(loadedConfig, {
+    cwd: configDir6,
+    configPath: absolutePath
+  });
+  return { config, configDir: configDir6 };
+}
+async function prepareImage(options) {
+  if (looksLikeLocalPath(options.image)) {
+    return {
+      image: await buildLocalImage(options)
+    };
+  }
+  const inspect = await options.runner.exec(options.engine, ["image", "inspect", options.image], {
+    cwd: options.configDir
+  });
+  if (inspect.exitCode === 0) {
+    return { image: options.image };
+  }
+  if (options.offline) {
+    throw new Error(`Container image "${options.image}" is not present locally. Devflare container tests are offline-first; pull/build the image ahead of time or pass offline: false.`);
+  }
+  const pull = await options.runner.exec(options.engine, ["pull", options.image], {
+    cwd: options.configDir
+  });
+  if (pull.exitCode !== 0) {
+    throw new Error(`Failed to pull container image "${options.image}": ${formatCommandFailure(pull)}`);
+  }
+  return { image: options.image };
+}
+async function buildLocalImage(options) {
+  const imagePath = resolve2(options.configDir, options.image);
+  const imageStat = await stat(imagePath);
+  const dockerfile = imageStat.isDirectory() ? join10(imagePath, "Dockerfile") : imagePath;
+  const context2 = resolve2(options.configDir, options.imageBuildContext ?? (imageStat.isDirectory() ? options.image : dirname4(options.image)));
+  if (!existsSync3(dockerfile)) {
+    throw new Error(`Container Dockerfile does not exist: ${dockerfile}`);
+  }
+  const tag = makeLocalImageTag(options.className, options.configDir, options.image);
+  const args = [
+    "build",
+    ...options.offline ? [getOfflineBuildPullArg(options.engine)] : [],
+    "-t",
+    tag,
+    "-f",
+    dockerfile,
+    context2
+  ];
+  const result = await options.runner.exec(options.engine, args, {
+    cwd: options.configDir
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to build local container image "${options.image}": ${formatCommandFailure(result)}`);
+  }
+  return tag;
+}
+function buildRunArgs(options) {
+  const args = [
+    "run",
+    "-d",
+    "--name",
+    options.name,
+    "--label",
+    "devflare.managed=true",
+    "--label",
+    `devflare.container.class=${options.className}`,
+    "-p",
+    `${options.host}:${options.hostPort}:${options.containerPort}`
+  ];
+  for (const [key, value] of Object.entries(options.envVars ?? {})) {
+    args.push("-e", `${key}=${value}`);
+  }
+  const command = [...options.command ?? []];
+  if (options.entrypoint && options.entrypoint.length > 0) {
+    args.push("--entrypoint", options.entrypoint[0]);
+    command.unshift(...options.entrypoint.slice(1));
+  }
+  args.push(options.image, ...command);
+  return args;
+}
+
+class LocalDevflareContainer {
+  id;
+  name;
+  className;
+  engine;
+  host;
+  hostPort;
+  port;
+  runner;
+  fetchImpl;
+  onDispose;
+  disposed = false;
+  constructor(options) {
+    this.id = options.id;
+    this.name = options.name;
+    this.className = options.className;
+    this.engine = options.engine;
+    this.host = options.host;
+    this.hostPort = options.hostPort;
+    this.port = options.port;
+    this.runner = options.runner;
+    this.fetchImpl = options.fetchImpl;
+    this.onDispose = options.onDispose;
+  }
+  fetch(input, init) {
+    return fetchWithStartupRetries(this.fetchImpl, this.toLocalRequest(input, init));
+  }
+  async logs() {
+    const result = await this.runner.exec(this.engine, ["logs", this.name]);
+    if (result.exitCode !== 0) {
+      throw new Error(`Failed to read logs for Devflare container "${this.name}": ${formatCommandFailure(result)}`);
+    }
+    return result.stdout;
+  }
+  async getState() {
+    const result = await this.runner.exec(this.engine, [
+      "inspect",
+      "--format",
+      "{{json .State}}",
+      this.name
+    ]);
+    if (result.exitCode !== 0) {
+      throw new Error(`Failed to inspect Devflare container "${this.name}": ${formatCommandFailure(result)}`);
+    }
+    const parsed = JSON.parse(result.stdout || "{}");
+    return {
+      status: parsed.Status ?? (parsed.Running ? "running" : "stopped"),
+      running: Boolean(parsed.Running),
+      ...typeof parsed.ExitCode === "number" && { exitCode: parsed.ExitCode }
+    };
+  }
+  async stop() {
+    if (this.disposed)
+      return;
+    try {
+      await this.runner.exec(this.engine, ["stop", this.name]);
+    } finally {
+      await this.runner.exec(this.engine, ["rm", "-f", this.name]);
+      this.disposed = true;
+      this.onDispose(this);
+    }
+  }
+  async destroy() {
+    if (this.disposed)
+      return;
+    await this.runner.exec(this.engine, ["rm", "-f", this.name]);
+    this.disposed = true;
+    this.onDispose(this);
+  }
+  toLocalRequest(input, init) {
+    const base = `http://${this.host}:${this.hostPort}/`;
+    if (input instanceof Request) {
+      const source = init ? new Request(input, init) : input;
+      const sourceUrl2 = new URL(source.url);
+      const localUrl2 = new URL(`${sourceUrl2.pathname}${sourceUrl2.search}`, base);
+      return new Request(localUrl2, {
+        method: source.method,
+        headers: source.headers,
+        body: source.body,
+        redirect: source.redirect,
+        signal: source.signal
+      });
+    }
+    const sourceUrl = new URL(String(input), base);
+    const localUrl = new URL(`${sourceUrl.pathname}${sourceUrl.search}`, base);
+    return new Request(localUrl, init);
+  }
+}
+async function fetchWithStartupRetries(fetchImpl, request) {
+  if (!canRetryRequest(request)) {
+    return fetchImpl(request);
+  }
+  const deadline = Date.now() + 5000;
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      return await fetchImpl(request.clone());
+    } catch (error) {
+      if (!isTransientContainerFetchError(error)) {
+        throw error;
+      }
+      lastError = error;
+      await delay(100);
+    }
+  }
+  throw lastError;
+}
+function canRetryRequest(request) {
+  return (request.method === "GET" || request.method === "HEAD") && request.body === null;
+}
+function isTransientContainerFetchError(error) {
+  const value = error;
+  const code = value.code ?? value.cause?.code;
+  if (code === "ECONNRESET" || code === "ECONNREFUSED" || code === "EPIPE" || code === "UND_ERR_SOCKET") {
+    return true;
+  }
+  return typeof value.message === "string" && (value.message.includes("socket connection was closed") || value.message.includes("fetch failed"));
+}
+async function waitForTcpPort(host, port, timeoutMs) {
+  const start = Date.now();
+  let lastError;
+  while (Date.now() - start < timeoutMs) {
+    try {
+      await connectOnce(host, port);
+      return;
+    } catch (error) {
+      lastError = error;
+      await delay(100);
+    }
+  }
+  const message = lastError instanceof Error ? lastError.message : "timed out";
+  throw new Error(`Timed out waiting for container port ${host}:${port}: ${message}`);
+}
+function connectOnce(host, port) {
+  return new Promise((resolveConnection, rejectConnection) => {
+    const socket = createConnection({ host, port });
+    socket.once("connect", () => {
+      socket.destroy();
+      resolveConnection();
+    });
+    socket.once("error", rejectConnection);
+  });
+}
+function looksLikeLocalPath(image) {
+  return image === "Dockerfile" || image.startsWith(".") || image.startsWith("/") || image.startsWith("\\") || isAbsolute(image) || image.endsWith("/Dockerfile") || image.endsWith("\\Dockerfile");
+}
+function getOfflineBuildPullArg(engine) {
+  return engine === "podman" ? "--pull=never" : "--pull=false";
+}
+function makeLocalImageTag(className, configDir6, image) {
+  const hash = createHash("sha256").update(`${configDir6}:${image}`).digest("hex").slice(0, 12);
+  return `devflare-local-${sanitizeName(className)}:${hash}`;
+}
+function makeContainerName(className, instance) {
+  return `devflare-${sanitizeName(className)}-${sanitizeName(instance ?? "default")}-${randomUUID().slice(0, 8)}`;
+}
+function sanitizeName(value) {
+  return value.toLowerCase().replace(/[^a-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "") || "container";
+}
+function formatCommandFailure(result) {
+  return (result.stderr || result.stdout || `exit code ${result.exitCode}`).trim();
+}
+function isTruthyEnvFlag(value) {
+  return value === "1" || value?.toLowerCase() === "true" || value?.toLowerCase() === "yes";
 }
 
 // src/test/simple-context-lifecycle.ts
-import { dirname as dirname4, resolve as resolve2 } from "path";
 async function resolveTestContextConfig(configPath, callerDir = getCallerDirectory()) {
   let absolutePath;
   if (configPath) {
-    absolutePath = resolve2(callerDir, configPath);
+    absolutePath = resolve3(callerDir, configPath);
   } else {
     const found = await findNearestConfig(callerDir);
     if (!found) {
@@ -1824,11 +3303,15 @@ async function resolveTestContextConfig(configPath, callerDir = getCallerDirecto
     }
     absolutePath = found;
   }
-  const configDir6 = dirname4(absolutePath);
-  const config = await loadConfig({
+  const configDir6 = dirname5(absolutePath);
+  const loadedConfig = await loadConfig({
     cwd: configDir6,
     configFile: absolutePath.split(/[/\\]/).pop()
   });
+  const config = await applyLocalDevVarsToConfig(loadedConfig, {
+    cwd: configDir6,
+    configPath: absolutePath
+  });
   return { absolutePath, configDir: configDir6, config };
 }
 function createDisposeContext(state) {
@@ -1841,6 +3324,8 @@ function createDisposeContext(state) {
       await state.miniflare.dispose();
       state.miniflare = null;
     }
+    await disposeLocalWorkerLoaderBindings();
+    await stopActiveContainers();
     state.envProxy = null;
     state.transportDecode = null;
     state.remoteBindings = null;
@@ -1867,10 +3352,10 @@ function isRetriableTestContextStartupError(error) {
   return message.includes("websocket connection failed") || message.includes("connection timeout: ws://") || message.includes("econnrefused") || message.includes("eaddrinuse") || message.includes("address already in use");
 }
 async function waitForTestContextStartupRetry() {
-  await new Promise((resolve3) => setTimeout(resolve3, TEST_CONTEXT_STARTUP_RETRY_DELAY_MS));
+  await new Promise((resolve4) => setTimeout(resolve4, TEST_CONTEXT_STARTUP_RETRY_DELAY_MS));
 }
 async function waitForBridgeClientRetry() {
-  await new Promise((resolve3) => setTimeout(resolve3, TEST_CONTEXT_BRIDGE_CONNECT_RETRY_DELAY_MS));
+  await new Promise((resolve4) => setTimeout(resolve4, TEST_CONTEXT_BRIDGE_CONNECT_RETRY_DELAY_MS));
 }
 async function connectBridgeClientWithRetry(url) {
   let lastError;
@@ -1890,6 +3375,48 @@ async function connectBridgeClientWithRetry(url) {
   }
   throw lastError instanceof Error ? lastError : new Error("Bridge-backed test context could not connect to the WebSocket gateway.");
 }
+function expandLocalBindingWorkers(mfConfig) {
+  const auxiliaryWorkers = [
+    ...mfConfig.__devflareLocalSecretWorkers ?? [],
+    ...mfConfig.__devflareLocalBindingWorkers ?? []
+  ];
+  if (!Array.isArray(auxiliaryWorkers) || auxiliaryWorkers.length === 0) {
+    return mfConfig;
+  }
+  const {
+    __devflareLocalSecretWorkers,
+    __devflareLocalBindingWorkers,
+    port,
+    host,
+    log,
+    kvPersist,
+    r2Persist,
+    d1Persist,
+    durableObjectsPersist,
+    workflowsPersist,
+    imagesPersist,
+    ...primaryWorker
+  } = mfConfig;
+  const primaryWorkerName = typeof primaryWorker.name === "string" ? primaryWorker.name : "primary";
+  return {
+    ...port !== undefined && { port },
+    ...host && { host },
+    ...log && { log },
+    ...kvPersist && { kvPersist },
+    ...r2Persist && { r2Persist },
+    ...d1Persist && { d1Persist },
+    ...durableObjectsPersist && { durableObjectsPersist },
+    ...workflowsPersist && { workflowsPersist },
+    ...imagesPersist && { imagesPersist },
+    workers: [
+      {
+        ...primaryWorker,
+        name: primaryWorkerName
+      },
+      ...auxiliaryWorkers
+    ]
+  };
+}
 async function startBridgeBackedTestContext(mfConfig) {
   const { Miniflare } = await import("miniflare");
   for (let attempt = 1;attempt <= TEST_CONTEXT_STARTUP_RETRY_ATTEMPTS; attempt++) {
@@ -1897,10 +3424,10 @@ async function startBridgeBackedTestContext(mfConfig) {
     let miniflare = null;
     let client = null;
     try {
-      miniflare = new Miniflare({
+      miniflare = new Miniflare(expandLocalBindingWorkers({
         ...mfConfig,
         port
-      });
+      }));
       await miniflare.ready;
       const miniflareBindings = wrapEnvSendEmailBindings(await miniflare.getBindings());
       client = await connectBridgeClientWithRetry(`ws://localhost:${port}`);
@@ -1949,9 +3476,9 @@ async function bootTestRuntime(mfConfig, usesMultiWorker) {
 }
 
 // src/test/simple-context-transport.ts
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 async function loadTransportDecoders(configDir6, transportFile) {
-  const transportPath = join10(configDir6, transportFile);
+  const transportPath = join11(configDir6, transportFile);
   const transportModule = await import(transportPath);
   if (!transportModule.transport) {
     console.warn(`[devflare] Warning: Transport file "${transportFile}" does not export a named "transport" object.
@@ -2001,15 +3528,32 @@ function applyMultiWorkerConfig(mfConfig, config, serviceBindingResolution, doBi
     ...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 },
-    ...serviceBindingResolution?.primaryServiceBindings && {
-      serviceBindings: serviceBindingResolution.primaryServiceBindings
-    }
+    ...mfConfig.serviceBindings || serviceBindingResolution?.primaryServiceBindings ? {
+      serviceBindings: {
+        ...mfConfig.serviceBindings ?? {},
+        ...serviceBindingResolution?.primaryServiceBindings ?? {}
+      }
+    } : {}
   };
   const additionalWorkers = [
     ...serviceBindingResolution?.workers || [],
-    ...doBindingResolution?.workers || []
+    ...doBindingResolution?.workers || [],
+    ...mfConfig.__devflareLocalSecretWorkers || [],
+    ...mfConfig.__devflareLocalBindingWorkers || []
   ];
   const workersByName = new Map;
   for (const worker2 of additionalWorkers) {
@@ -2031,15 +3575,35 @@ function applyMultiWorkerConfig(mfConfig, config, serviceBindingResolution, doBi
   delete mfConfig.kvNamespaces;
   delete mfConfig.r2Buckets;
   delete mfConfig.d1Databases;
+  delete mfConfig.ratelimits;
+  delete mfConfig.versionMetadata;
+  delete mfConfig.workerLoaders;
+  delete mfConfig.mtlsCertificates;
+  delete mfConfig.dispatchNamespaces;
+  delete mfConfig.workflows;
+  delete mfConfig.pipelines;
+  delete mfConfig.images;
+  delete mfConfig.media;
+  delete mfConfig.artifacts;
+  delete mfConfig.secretsStoreSecrets;
+  delete mfConfig.wrappedBindings;
+  delete mfConfig.serviceBindings;
+  delete mfConfig.__devflareLocalSecretWorkers;
+  delete mfConfig.__devflareLocalBindingWorkers;
   delete mfConfig.durableObjects;
   mfConfig.workers = workers;
 }
 
 // src/test/simple-context-mfconfig.ts
-function buildInlineBridgeMfConfig(config) {
+function buildInlineBridgeMfConfig(config, options = {}) {
   const localWorkerBindings = config.vars ?? {};
+  const localSecretWrappedBindingConfig = options.cwd ? buildLocalSecretWrappedBindingConfig(config, options.cwd) : undefined;
+  const localBindingShimServiceConfig = buildLocalBindingShimServiceConfig(config);
+  const localSecretBindingNames = new Set(localSecretWrappedBindingConfig?.localBindingNames ?? []);
   const mfConfig = {
-    modules: true
+    modules: true,
+    compatibilityDate: config.compatibilityDate ?? "2025-01-01",
+    ...config.compatibilityFlags && { compatibilityFlags: config.compatibilityFlags }
   };
   if (config.bindings?.kv) {
     mfConfig.kvNamespaces = Object.keys(config.bindings.kv);
@@ -2052,6 +3616,10 @@ function buildInlineBridgeMfConfig(config) {
       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)) {
@@ -2059,6 +3627,152 @@ function buildInlineBridgeMfConfig(config) {
     }
     mfConfig.queueProducers = queueProducers;
   }
+  if (config.bindings?.rateLimits) {
+    mfConfig.ratelimits = Object.fromEntries(Object.entries(config.bindings.rateLimits).map(([bindingName, binding]) => [
+      bindingName,
+      {
+        simple: {
+          limit: binding.simple.limit,
+          period: binding.simple.period
+        }
+      }
+    ]));
+  }
+  if (config.bindings?.versionMetadata) {
+    mfConfig.versionMetadata = config.bindings.versionMetadata.binding;
+  }
+  if (config.bindings?.workerLoaders) {
+    mfConfig.workerLoaders = Object.fromEntries(Object.keys(config.bindings.workerLoaders).map((bindingName) => [bindingName, {}]));
+  }
+  if (config.bindings?.mtlsCertificates) {
+    mfConfig.mtlsCertificates = Object.fromEntries(Object.entries(config.bindings.mtlsCertificates).map(([bindingName, binding]) => {
+      const normalized = normalizeMtlsCertificateBinding(binding);
+      return [
+        bindingName,
+        {
+          certificate_id: normalized.certificateId
+        }
+      ];
+    }));
+  }
+  if (config.bindings?.dispatchNamespaces) {
+    mfConfig.dispatchNamespaces = Object.fromEntries(Object.entries(config.bindings.dispatchNamespaces).map(([bindingName, binding]) => {
+      const normalized = normalizeDispatchNamespaceBinding(binding);
+      return [
+        bindingName,
+        {
+          namespace: normalized.namespace
+        }
+      ];
+    }));
+  }
+  if (config.bindings?.workflows) {
+    mfConfig.workflows = Object.fromEntries(Object.entries(config.bindings.workflows).map(([bindingName, binding]) => {
+      const normalized = normalizeWorkflowBinding(binding);
+      return [
+        bindingName,
+        {
+          name: normalized.name,
+          className: normalized.className,
+          ...normalized.scriptName && { scriptName: normalized.scriptName },
+          ...normalized.limits && { stepLimit: normalized.limits.steps }
+        }
+      ];
+    }));
+  }
+  if (config.bindings?.pipelines) {
+    mfConfig.pipelines = Object.fromEntries(Object.entries(config.bindings.pipelines).map(([bindingName, binding]) => {
+      const normalized = normalizePipelineBinding(binding);
+      return [
+        bindingName,
+        typeof binding === "string" ? normalized.pipeline : { pipeline: normalized.pipeline }
+      ];
+    }));
+  }
+  if (config.bindings?.images && localBindingShimServiceConfig.localBindingNames.length === 0) {
+    const [entry] = Object.entries(config.bindings.images);
+    if (entry) {
+      const [bindingName, binding] = entry;
+      const normalized = normalizeImagesBinding(bindingName, binding);
+      mfConfig.images = {
+        binding: normalized.binding
+      };
+    }
+  }
+  if (config.bindings?.media && localBindingShimServiceConfig.localBindingNames.length === 0) {
+    const [entry] = Object.entries(config.bindings.media);
+    if (entry) {
+      const [bindingName, binding] = entry;
+      const normalized = normalizeMediaBinding(bindingName, binding);
+      mfConfig.media = {
+        binding: normalized.binding
+      };
+    }
+  }
+  if (config.bindings?.artifacts) {
+    mfConfig.artifacts = Object.fromEntries(Object.entries(config.bindings.artifacts).map(([bindingName, binding]) => {
+      const normalized = normalizeArtifactsBinding(binding);
+      return [
+        bindingName,
+        {
+          namespace: normalized.namespace
+        }
+      ];
+    }));
+  }
+  if (config.bindings?.aiSearchNamespaces) {
+    mfConfig.aiSearchNamespaces = Object.fromEntries(Object.entries(config.bindings.aiSearchNamespaces).map(([bindingName, binding]) => [
+      bindingName,
+      {
+        namespace: binding.namespace
+      }
+    ]));
+  }
+  if (config.bindings?.aiSearch) {
+    mfConfig.aiSearchInstances = Object.fromEntries(Object.entries(config.bindings.aiSearch).map(([bindingName, binding]) => [
+      bindingName,
+      {
+        instance_name: binding.instanceName
+      }
+    ]));
+  }
+  if (config.bindings?.secretsStore) {
+    const secretsStoreEntries = Object.entries(config.bindings.secretsStore).flatMap(([bindingName, binding]) => {
+      if (localSecretBindingNames.has(bindingName)) {
+        return [];
+      }
+      const normalized = normalizeSecretsStoreBinding(binding, config.secretsStoreId, bindingName);
+      return [[
+        bindingName,
+        {
+          store_id: normalized.storeId,
+          secret_name: normalized.secretName
+        }
+      ]];
+    });
+    if (secretsStoreEntries.length > 0) {
+      mfConfig.secretsStoreSecrets = Object.fromEntries(secretsStoreEntries);
+    }
+  }
+  const wrappedBindings = {
+    ...localSecretWrappedBindingConfig?.wrappedBindings ?? {}
+  };
+  const localBindingWorkers = [
+    ...localSecretWrappedBindingConfig?.workers ?? [],
+    ...localBindingShimServiceConfig.workers
+  ];
+  if (Object.keys(wrappedBindings).length > 0) {
+    mfConfig.wrappedBindings = wrappedBindings;
+  }
+  if (localBindingShimServiceConfig.localBindingNames.length > 0) {
+    mfConfig.serviceBindings = {
+      ...mfConfig.serviceBindings ?? {},
+      ...localBindingShimServiceConfig.serviceBindings
+    };
+  }
+  if (localBindingWorkers.length > 0) {
+    mfConfig.__devflareLocalBindingWorkers = localBindingWorkers;
+  }
   if (Object.keys(localWorkerBindings).length > 0) {
     mfConfig.bindings = localWorkerBindings;
   }
@@ -2112,7 +3826,7 @@ async function createTestContext(configPath) {
   if (needsMultiWorkerForDOs) {
     doBindingResolution = await resolveDOBindings(config, configDir6);
   }
-  const mfConfig = buildInlineBridgeMfConfig(config);
+  const mfConfig = buildInlineBridgeMfConfig(config, { cwd: configDir6 });
   const transportFile = resolveTransportFile(configDir6, config.files?.transport);
   if (transportFile) {
     state.transportDecode = await loadTransportDecoders(configDir6, transportFile);
@@ -2182,7 +3896,7 @@ async function createTestContext(configPath) {
 // src/test/cf.ts
 var cf = {
   email,
-  queue,
+  queue: queue2,
   scheduled,
   worker,
   tail
@@ -2190,9 +3904,16 @@ var cf = {
 // src/test/should-skip.ts
 var REMOTE_ONLY_SERVICES = new Set([
   "ai",
+  "ai_search",
+  "ai_gateway",
+  "media",
+  "mtls_certificates",
+  "artifacts",
+  "builds",
   "vectorize"
 ]);
 var skipResults = new Map;
+var containerSkipResult = null;
 var EXPECTED_ERROR_PATTERNS = [
   "ECONNREFUSED",
   "ETIMEDOUT",
@@ -2263,12 +3984,30 @@ function getSkipResult(service) {
     result = computeSkip(service);
     skipResults.set(service, result);
   }
-  return result;
+  return result;
+}
+function getContainerSkipResult() {
+  if (!containerSkipResult) {
+    containerSkipResult = getContainerSkipReason().then((reason) => {
+      if (reason) {
+        console.log(`CONTAINERS tests skipped: ${reason}`);
+        return true;
+      }
+      return false;
+    });
+  }
+  return containerSkipResult;
 }
 var shouldSkip = {
   get ai() {
     return getSkipResult("ai");
   },
+  get aiSearch() {
+    return getSkipResult("ai_search");
+  },
+  get aiGateway() {
+    return getSkipResult("ai_gateway");
+  },
   get vectorize() {
     return getSkipResult("vectorize");
   },
@@ -2289,423 +4028,974 @@ var shouldSkip = {
   },
   get durableObjects() {
     return getSkipResult("durable_objects");
+  },
+  get media() {
+    return getSkipResult("media");
+  },
+  get mtlsCertificates() {
+    return getSkipResult("mtls_certificates");
+  },
+  get artifacts() {
+    return getSkipResult("artifacts");
+  },
+  get builds() {
+    return getSkipResult("builds");
+  },
+  get containers() {
+    return getContainerSkipResult();
   }
 };
-// src/test/utilities.ts
-function createMockTestContext(options = {}) {
-  const waitUntilPromises = [];
-  const ctx = {
-    waitUntil(promise) {
-      waitUntilPromises.push(promise);
-    },
-    passThroughOnException() {},
-    props: {}
+// src/test/ai-search.ts
+var MOCK_TIMESTAMP = "2026-04-26T00:00:00.000Z";
+function cloneInfo(value) {
+  return { ...value };
+}
+function extractSearchQuery(params) {
+  if ("query" in params && typeof params.query === "string") {
+    return params.query;
+  }
+  const messages = "messages" in params ? params.messages : [];
+  return messages.filter((message) => message.role === "user" && message.content).map((message) => message.content).join(" ");
+}
+function tokenize(value) {
+  return value.toLowerCase().split(/[^a-z0-9_]+/).filter((token) => token.length > 2);
+}
+function scoreText(query, text) {
+  const tokens = tokenize(query);
+  if (tokens.length === 0) {
+    return 1;
+  }
+  const haystack = text.toLowerCase();
+  const matches = tokens.filter((token) => haystack.includes(token)).length;
+  return matches === 0 ? 0 : Math.max(0.1, matches / tokens.length);
+}
+function streamFromText(text) {
+  const encoded = new TextEncoder().encode(text);
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoded);
+      controller.close();
+    }
+  });
+}
+async function contentToText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (content instanceof Blob) {
+    return content.text();
+  }
+  return new Response(content).text();
+}
+function createItemInfo(id, key, content, options = {}) {
+  return {
+    id,
+    key,
+    status: options.status ?? "completed",
+    next_action: null,
+    namespace: options.namespace,
+    chunks_count: content.length > 0 ? 1 : 0,
+    file_size: new TextEncoder().encode(content).byteLength,
+    source_id: options.sourceId ?? null,
+    last_seen_at: MOCK_TIMESTAMP,
+    created_at: MOCK_TIMESTAMP,
+    metadata: options.metadata
   };
+}
+function createItemChunks(item, chunks) {
+  let offset = 0;
+  return chunks.map((text, index) => {
+    const start = offset;
+    const end = start + new TextEncoder().encode(text).byteLength;
+    offset = end;
+    return {
+      id: `${item.id}:chunk-${index + 1}`,
+      text,
+      start_byte: start,
+      end_byte: end,
+      item: {
+        timestamp: Date.parse(MOCK_TIMESTAMP),
+        key: item.key,
+        metadata: item.metadata
+      }
+    };
+  });
+}
+function createStoredItem(sequence, fixture, namespace) {
+  const content = fixture.content ?? fixture.chunks?.join(`
+`) ?? "";
+  const id = fixture.id ?? `item-${sequence}`;
+  const info = createItemInfo(id, fixture.key, content, {
+    metadata: fixture.metadata,
+    status: fixture.status,
+    namespace
+  });
+  const chunks = createItemChunks(info, fixture.chunks ?? [content]);
   return {
-    env: options.env ?? {},
-    ctx,
-    request: options.request ?? null,
-    waitUntilPromises
+    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
+      }
+    ]
   };
 }
-async function withTestContext(options, handler) {
-  const testCtx = createMockTestContext(options);
-  return runWithContext(testCtx.env, testCtx.ctx, options.request ?? null, handler, options.type ?? "fetch");
+function isAISearchInstance(value) {
+  return typeof value.search === "function";
 }
-function createMockKV(initialData = {}) {
-  const store = new Map;
-  const metadata = new Map;
-  const encoder = new TextEncoder;
-  const decoder = new TextDecoder;
-  for (const [key, value] of Object.entries(initialData)) {
-    store.set(key, encoder.encode(value));
+function createMockAISearchInstance(options = {}) {
+  const instanceId = options.id ?? options.info?.id ?? "mock-ai-search";
+  const namespace = options.namespace ?? options.info?.namespace;
+  const items = new Map;
+  const jobs = new Map;
+  const searches = [];
+  let itemSequence = 0;
+  let jobSequence = 0;
+  let info = {
+    id: instanceId,
+    type: "builtin",
+    namespace,
+    status: "ready",
+    created_at: MOCK_TIMESTAMP,
+    modified_at: MOCK_TIMESTAMP,
+    index_method: {
+      vector: true,
+      keyword: true
+    },
+    fusion_method: "rrf",
+    ...options.info
+  };
+  for (const fixture of options.items ?? []) {
+    const stored = createStoredItem(++itemSequence, fixture, namespace);
+    items.set(stored.info.id, stored);
   }
-  const 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 findMatches = (params) => {
+    searches.push(params);
+    const query = extractSearchQuery(params);
+    const maxResults = params.ai_search_options?.retrieval?.max_num_results ?? 10;
     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();
+    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"
           }
         });
       }
-      default:
-        return decoder.decode(bytes);
     }
+    return {
+      search_query: query,
+      chunks: chunks.slice(0, maxResults)
+    };
   };
-  const resolveType = (options) => {
-    const type = typeof options === "string" ? options : options?.type ?? "text";
-    return type;
-  };
-  return {
-    async get(key, options) {
-      const bytes = store.get(key);
-      if (bytes === undefined)
-        return null;
-      return decodeBytes(bytes, resolveType(options));
+  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 put(key, value, _options) {
-      const bytes = await toBytes(value);
-      store.set(key, bytes);
+    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 delete(key) {
-      store.delete(key);
-      metadata.delete(key);
+    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 list(options) {
-      const prefix = options?.prefix ?? "";
-      const limit = options?.limit ?? 1000;
-      const keys = Array.from(store.keys()).filter((key) => key.startsWith(prefix)).slice(0, limit).map((name) => ({ name }));
+    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 {
-        keys,
-        list_complete: keys.length < limit,
-        cursor: undefined
+        result,
+        result_info: {
+          count: result.length,
+          per_page: limit,
+          cursor: null,
+          truncated: item.logs.length > result.length
+        }
       };
     },
-    async getWithMetadata(key, options) {
-      const bytes = store.get(key);
+    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 {
-        value: bytes === undefined ? null : decodeBytes(bytes, resolveType(options)),
-        metadata: metadata.get(key) ?? null
+        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);
   };
-}
-var TABLE_NAME_RE = /(?:from|into|update)\s+["'`]?([a-zA-Z_][a-zA-Z0-9_]*)["'`]?/i;
-var extractTable = (sql) => {
-  const match = TABLE_NAME_RE.exec(sql);
-  return match ? match[1] : null;
-};
-var detectOp = (sql) => {
-  const trimmed = sql.trimStart().toLowerCase();
-  if (trimmed.startsWith("select"))
-    return "select";
-  if (trimmed.startsWith("insert"))
-    return "insert";
-  if (trimmed.startsWith("update"))
-    return "update";
-  if (trimmed.startsWith("delete"))
-    return "delete";
-  return "other";
-};
-function createMockD1(mockResultsOrOptions = []) {
-  const options = Array.isArray(mockResultsOrOptions) ? { results: mockResultsOrOptions } : mockResultsOrOptions;
-  const tables = new Map;
-  for (const [name, rows] of Object.entries(options.fixtures ?? {})) {
-    tables.set(name, [...rows]);
-  }
-  const fallback = options.results ?? [];
-  const resolveRows = (sql) => {
-    const op = detectOp(sql);
-    const table = extractTable(sql);
-    if (table && tables.has(table)) {
-      return { rows: tables.get(table) ?? [], op, table };
+  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);
     }
-    return { rows: [...fallback], op, table };
   };
-  const createStatement = (sql) => {
-    let boundValues = [];
-    const statement = {
-      bind(...values) {
-        boundValues = values;
-        return statement;
-      },
-      async first(column) {
-        const { rows } = resolveRows(sql);
-        const row = rows[0];
-        if (!row)
-          return null;
-        if (column)
-          return row[column];
-        return row;
-      },
-      async all() {
-        const { rows } = resolveRows(sql);
-        return {
-          results: rows,
-          success: true,
-          meta: { duration: 0, changes: 0, last_row_id: 0 }
-        };
-      },
-      async run() {
-        const { op, table } = resolveRows(sql);
-        let changes = 0;
-        let lastRowId = 0;
-        if (op === "insert" && table) {
-          const rows = tables.get(table) ?? [];
-          const bound = boundValues.length > 0 ? Object.fromEntries(boundValues.map((v, i) => [`col${i}`, v])) : {};
-          rows.push(bound);
-          tables.set(table, rows);
-          changes = 1;
-          lastRowId = rows.length;
-        } else if (op === "delete" && table) {
-          const rows = tables.get(table) ?? [];
-          changes = rows.length;
-          tables.set(table, []);
-        } else if (op === "update" && table) {
-          changes = (tables.get(table) ?? []).length;
+  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
         }
-        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));
+      };
+    },
+    async cancel() {
+      const job = jobs.get(jobId);
+      if (!job) {
+        throw new Error(`Mock AI Search job "${jobId}" was not found.`);
       }
-    };
-    return statement;
+      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 {
-    prepare(query) {
-      return createStatement(query);
+    async search(params) {
+      return findMatches(params);
     },
-    async exec(_query) {
+    async chatCompletions(params) {
+      const search = findMatches({
+        messages: params.messages,
+        ai_search_options: params.ai_search_options
+      });
+      const content = typeof options.chatMessage === "function" ? options.chatMessage(search.chunks, params) : options.chatMessage ?? (search.chunks.map((chunk) => chunk.text).join(`
+`) || "No matching offline AI Search chunks.");
+      if (params.stream) {
+        const payload = JSON.stringify({
+          choices: [{ delta: { content } }],
+          chunks: search.chunks
+        });
+        return streamFromText(`data: ${payload}
+
+`);
+      }
       return {
-        results: [],
-        success: true,
-        meta: { duration: 0, changes: 0, last_row_id: 0 }
+        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 batch(statements) {
-      return statements.map(() => ({
-        results: [],
-        success: true,
-        meta: { duration: 0, changes: 0, last_row_id: 0 }
-      }));
+    async update(config) {
+      info = {
+        ...info,
+        ...config,
+        modified_at: MOCK_TIMESTAMP
+      };
+      return cloneInfo(info);
     },
-    async dump() {
-      return new ArrayBuffer(0);
+    async info() {
+      return cloneInfo(info);
     },
-    withSession(_constraintOrBookmark) {
-      return this;
+    async stats() {
+      const stats = {
+        queued: 0,
+        running: 0,
+        completed: 0,
+        error: 0,
+        skipped: 0,
+        outdated: 0,
+        last_activity: MOCK_TIMESTAMP,
+        engine: {
+          vectorize: {
+            vectorsCount: items.size,
+            dimensions: 0
+          },
+          r2: {
+            payloadSizeBytes: Array.from(items.values()).reduce((sum, item) => sum + item.info.file_size, 0),
+            metadataSizeBytes: 0,
+            objectCount: items.size
+          }
+        }
+      };
+      for (const item of items.values()) {
+        stats[item.info.status] = (stats[item.info.status] ?? 0) + 1;
+      }
+      return stats;
+    },
+    get items() {
+      return itemsApi;
+    },
+    get jobs() {
+      return jobsApi;
+    },
+    _getSearches() {
+      return [...searches];
+    },
+    _getItems() {
+      return Array.from(items.values()).map((item) => cloneInfo(item.info));
+    },
+    _getJobs() {
+      return Array.from(jobs.values()).map((job) => cloneInfo(job));
     }
   };
 }
-function createMockR2() {
-  const store = new Map;
-  const createR2Object = (key, content, metadata) => {
-    const encoder = new TextEncoder;
-    const data = encoder.encode(content);
-    return {
-      key,
-      version: "1",
-      size: data.length,
-      etag: `"${key}-etag"`,
-      httpEtag: `"${key}-etag"`,
-      uploaded: new Date,
-      httpMetadata: metadata ?? {},
-      customMetadata: {},
-      checksums: {},
-      storageClass: "Standard",
-      body: new ReadableStream({
-        start(controller) {
-          controller.enqueue(data);
-          controller.close();
-        }
-      }),
-      bodyUsed: false,
-      async arrayBuffer() {
-        return new Uint8Array(data).buffer;
-      },
-      async text() {
-        return content;
-      },
-      async json() {
-        return JSON.parse(content);
-      },
-      async blob() {
-        return new Blob([data]);
-      },
-      writeHttpMetadata(headers) {}
-    };
+function createMockAISearchNamespace(options = {}) {
+  const namespaceName = options.namespace ?? "default";
+  const instances = new Map;
+  for (const [name, instanceOptions] of Object.entries(options.instances ?? {})) {
+    instances.set(name, isAISearchInstance(instanceOptions) ? instanceOptions : createMockAISearchInstance({
+      id: name,
+      namespace: namespaceName,
+      ...instanceOptions
+    }));
+  }
+  const getInstance = (name) => {
+    const instance = instances.get(name);
+    if (!instance) {
+      throw new Error(`Mock AI Search namespace has no instance named "${name}".`);
+    }
+    return instance;
   };
   return {
-    async put(key, value, options) {
-      let content;
-      if (typeof value === "string") {
-        content = value;
-      } else if (value instanceof ArrayBuffer) {
-        content = new TextDecoder().decode(value);
-      } else if (value instanceof Blob) {
-        content = await value.text();
-      } else if (value === null) {
-        content = "";
-      } else {
-        const reader = value.getReader();
-        const chunks = [];
-        let done = false;
-        while (!done) {
-          const result = await reader.read();
-          done = result.done;
-          if (result.value) {
-            chunks.push(new TextDecoder().decode(result.value));
-          }
-        }
-        content = chunks.join("");
+    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));
       }
-      store.set(key, { content });
-      return createR2Object(key, content);
+      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 get(key, options) {
-      const item = store.get(key);
-      if (!item)
-        return null;
-      return createR2Object(key, item.content, item.metadata);
+    async create(config) {
+      const instance = createMockAISearchInstance({
+        id: config.id,
+        namespace: namespaceName,
+        info: config
+      });
+      instances.set(config.id, instance);
+      return instance;
     },
-    async head(key) {
-      const item = store.get(key);
-      if (!item)
-        return null;
+    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 {
-        key,
-        version: "1",
-        size: new TextEncoder().encode(item.content).length,
-        etag: `"${key}-etag"`,
-        httpEtag: `"${key}-etag"`,
-        uploaded: new Date,
-        httpMetadata: item.metadata ?? {},
-        customMetadata: {},
-        checksums: {},
-        storageClass: "Standard",
-        writeHttpMetadata(headers) {}
+        search_query: query,
+        chunks,
+        ...errors.length > 0 && { errors }
       };
     },
-    async delete(keys) {
-      const keyArray = Array.isArray(keys) ? keys : [keys];
-      for (const key of keyArray) {
-        store.delete(key);
+    async chatCompletions(params) {
+      const search = await this.search({
+        messages: params.messages,
+        ai_search_options: params.ai_search_options
+      });
+      const content = search.chunks.map((chunk) => chunk.text).join(`
+`) || "No matching offline AI Search chunks.";
+      if (params.stream) {
+        return streamFromText(`data: ${JSON.stringify({ chunks: search.chunks })}
+
+`);
       }
-    },
-    async list(options) {
-      const objects = Array.from(store.entries()).map(([key, { content, metadata }]) => createR2Object(key, content, metadata));
       return {
-        objects,
-        truncated: false,
-        delimitedPrefixes: []
+        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
       };
     },
-    async createMultipartUpload(key, options) {
-      throw new Error("Multipart upload not implemented in mock");
-    },
-    async resumeMultipartUpload(key, uploadId) {
-      throw new Error("Multipart upload not implemented in mock");
+    _getInstances() {
+      return Array.from(instances.keys());
     }
   };
 }
-function createMockQueue() {
-  const messages = [];
+
+// src/test/offline-bindings.ts
+var SUPPORT_MATRIX = {
+  rateLimits: {
+    service: "rateLimits",
+    tier: "offline-native",
+    reason: "Miniflare and devflare/test can simulate fixed-window RateLimit bindings locally.",
+    recommendation: "Use createOfflineEnv() or createMockRateLimit() for pure tests; use createTestContext() for Miniflare-backed tests."
+  },
+  versionMetadata: {
+    service: "versionMetadata",
+    tier: "offline-native",
+    reason: "Version metadata can be deterministic in tests without Cloudflare state.",
+    recommendation: "Use createOfflineEnv() or createMockVersionMetadata() when asserting version-aware code."
+  },
+  secretsStore: {
+    service: "secretsStore",
+    tier: "offline-native",
+    reason: "Secrets Store binding shape is local-testable with local secret-store values or fixed fixtures.",
+    recommendation: "Use devflare secrets --local for dev/test values, or pass fixtures.secretsStore values for pure tests."
+  },
+  hyperdrive: {
+    service: "hyperdrive",
+    tier: "offline-native",
+    reason: "Hyperdrive can run locally through Miniflare when Devflare has a local connection string or test fixture for the target database.",
+    recommendation: "Use bindings.hyperdrive.*.localConnectionString, CLOUDFLARE_HYPERDRIVE_LOCAL_CONNECTION_STRING_<BINDING>, or fixtures.hyperdrive for offline tests."
+  },
+  workerLoaders: {
+    service: "workerLoaders",
+    tier: "offline-native",
+    reason: "Worker Loader bindings run locally through Miniflare and can use explicit Worker stubs for pure tests.",
+    recommendation: "Use createTestContext() for local WorkerLoader execution; pass fixtures.workerLoaders with a WorkerStub for pure tests."
+  },
+  mtlsCertificates: {
+    service: "mtlsCertificates",
+    tier: "offline-fixture",
+    reason: "Fetcher call paths can be tested locally, but real certificate presentation is Cloudflare/Wrangler remote behavior.",
+    recommendation: "Pass fixtures.mtlsCertificates handlers for unit tests; use remote/deployed tests for certificate presentation."
+  },
+  dispatchNamespaces: {
+    service: "dispatchNamespaces",
+    tier: "offline-fixture",
+    reason: "Tenant dispatch can be backed by explicit test fetchers, but namespace uploads and lifecycle are Cloudflare-managed.",
+    recommendation: "Pass fixtures.dispatchNamespaces workers for deterministic tenant routing tests."
+  },
+  workflows: {
+    service: "workflows",
+    tier: "offline-native",
+    reason: "Workflow binding calls can run through Miniflare or a deterministic local Workflow mock for app-level tests.",
+    recommendation: "Use createOfflineEnv() for pure tests and createTestContext() when Miniflare execution semantics matter."
+  },
+  pipelines: {
+    service: "pipelines",
+    tier: "offline-native",
+    reason: "Pipeline sends can be recorded locally; Cloudflare owns production batching and sinks.",
+    recommendation: "Use createOfflineEnv() or createMockPipeline() to assert records sent by application code."
+  },
+  images: {
+    service: "images",
+    tier: "offline-native",
+    reason: "Images has local development support and Devflare provides a low-fidelity deterministic pure mock.",
+    recommendation: "Use createOfflineEnv() for chain-shape tests; use Cloudflare for hosted image APIs and transform fidelity."
+  },
+  media: {
+    service: "media",
+    tier: "offline-native",
+    reason: "Media Transformations can run through Miniflare wiring locally, and Devflare provides a deterministic pure mock for app-level chain tests.",
+    recommendation: "Use createTestContext() for local Worker binding tests and createMockMediaBinding() for pure tests; use Cloudflare for codec/output fidelity."
+  },
+  artifacts: {
+    service: "artifacts",
+    tier: "offline-fixture",
+    reason: "Artifacts repo metadata and token flows can be modeled in memory; real Git remotes are Cloudflare-managed.",
+    recommendation: "Use createMockArtifacts() for unit tests; use Cloudflare for Git protocol and namespace access."
+  },
+  aiSearch: {
+    service: "aiSearch",
+    tier: "offline-fixture",
+    reason: "AI Search application flows can use deterministic in-memory instances and namespaces, but indexing/ranking/crawling are hosted Cloudflare behavior.",
+    recommendation: "Use createMockAISearchInstance(), createMockAISearchNamespace(), or createOfflineEnv(); use remote tests for real relevance behavior."
+  },
+  aiSearchNamespaces: {
+    service: "aiSearchNamespaces",
+    tier: "offline-fixture",
+    reason: "AI Search namespace management can be backed by an explicit in-memory instance registry for tests.",
+    recommendation: "Use fixtures.aiSearchNamespaces to model tenant instances and multi-instance searches."
+  },
+  containers: {
+    service: "containers",
+    tier: "offline-native",
+    reason: "Devflare can launch local Docker/Podman containers in explicit tests when an engine and cached images are available.",
+    recommendation: "Use devflare/test containers helpers and shouldSkip.containers; keep ordinary unit tests engine-free."
+  },
+  browser: {
+    service: "browser",
+    tier: "offline-native",
+    reason: "Cloudflare lists Browser Run as locally simulatable, while live view, HITL, recordings, and external CDP remain hosted features.",
+    recommendation: "Use Cloudflare/Wrangler Browser local development for browser execution and remote/deployed tests for hosted-only features."
+  },
+  ai: {
+    service: "ai",
+    tier: "remote-boundary",
+    reason: "Workers AI inference has no local simulation in Cloudflare local development.",
+    recommendation: "Use DEVFLARE_REMOTE=1/devflare remote enable for real calls, or inject a custom fake for pure tests."
+  },
+  aiGateway: {
+    service: "aiGateway",
+    tier: "remote-boundary",
+    reason: "AI Gateway routing and logs are Cloudflare account resources reached through the Workers AI binding.",
+    recommendation: "Use remote-mode AI Gateway helpers for integration tests and custom fakes for offline unit tests."
+  },
+  vectorize: {
+    service: "vectorize",
+    tier: "remote-boundary",
+    reason: "Cloudflare lists Vectorize with no local simulation.",
+    recommendation: "Use DEVFLARE_REMOTE=1/devflare remote enable for real indexes, or inject a fake Vectorize binding for pure tests."
+  },
+  builds: {
+    service: "builds",
+    tier: "remote-boundary",
+    reason: "Cloudflare Builds/Git-connected Workers are CI/CD orchestration, not a Worker runtime binding.",
+    recommendation: "Run Devflare commands inside your CI; validate Cloudflare build integration with Cloudflare/Wrangler tests."
+  }
+};
+function copySupport(entry) {
+  return { ...entry };
+}
+function getOfflineSupportMatrix() {
+  return Object.fromEntries(Object.entries(SUPPORT_MATRIX).map(([service, entry]) => [service, copySupport(entry)]));
+}
+function describeOfflineSupport(service) {
+  const entry = SUPPORT_MATRIX[service];
+  if (entry) {
+    return copySupport(entry);
+  }
   return {
-    async send(message, options) {
-      messages.push({ body: message, options });
-    },
-    async sendBatch(batch) {
-      messages.push(...batch);
-    },
-    _getMessages() {
-      return messages;
-    }
+    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 createMockEnv(options = {}) {
-  const env2 = {};
-  if (options.kv) {
-    for (const name of options.kv) {
-      env2[name] = createMockKV();
+function createMissingSecret(binding) {
+  return {
+    async get() {
+      throw new Error(`Offline Secrets Store binding "${binding}" has no value. Pass fixtures.secretsStore.${binding} or write a local secret with devflare secrets --local.`);
     }
+  };
+}
+function isWorkflowBinding(value) {
+  return typeof value.create === "function";
+}
+function isPipelineBinding(value) {
+  return typeof value?.send === "function";
+}
+function isImagesBinding(value) {
+  return typeof value?.input === "function";
+}
+function isHyperdriveBinding(value) {
+  return typeof value?.connectionString === "string";
+}
+function isMediaBinding(value) {
+  return typeof value?.input === "function";
+}
+function isArtifactsBinding2(value) {
+  return typeof value?.create === "function";
+}
+function isAISearchInstance2(value) {
+  return typeof value?.search === "function";
+}
+function isAISearchNamespace(value) {
+  return typeof value?.get === "function";
+}
+function addBoundary(remoteBoundaries, service, binding, reason) {
+  remoteBoundaries.push({
+    service,
+    binding,
+    reason,
+    recommendation: describeOfflineSupport(service).recommendation
+  });
+}
+function addStaticBindings(env3, config) {
+  if (config.vars) {
+    Object.assign(env3, config.vars);
   }
-  if (options.d1) {
-    for (const name of options.d1) {
-      env2[name] = createMockD1();
-    }
+}
+function addRateLimitBindings(env3, bindings) {
+  for (const [name, binding] of Object.entries(bindings?.rateLimits ?? {})) {
+    env3[name] = createMockRateLimit(binding.simple);
   }
-  if (options.r2) {
-    for (const name of options.r2) {
-      env2[name] = createMockR2();
+}
+function addVersionMetadataBinding(env3, bindings) {
+  if (bindings?.versionMetadata) {
+    env3[bindings.versionMetadata.binding] = createMockVersionMetadata();
+  }
+}
+function getHyperdriveConnectionString(name, binding, fixture) {
+  if (typeof fixture === "string") {
+    return fixture;
+  }
+  const envValue = process.env[`CLOUDFLARE_HYPERDRIVE_LOCAL_CONNECTION_STRING_${name}`] ?? process.env[`WRANGLER_HYPERDRIVE_LOCAL_CONNECTION_STRING_${name}`];
+  if (envValue?.trim()) {
+    return envValue;
+  }
+  return normalizeHyperdriveBinding(binding).localConnectionString;
+}
+function addHyperdriveBindings(env3, bindings, fixtures, missingFixtures) {
+  for (const [name, binding] of Object.entries(bindings?.hyperdrive ?? {})) {
+    const fixture = fixtures.hyperdrive?.[name];
+    if (isHyperdriveBinding(fixture)) {
+      env3[name] = fixture;
+      continue;
+    }
+    const connectionString = getHyperdriveConnectionString(name, binding, fixture);
+    if (connectionString) {
+      env3[name] = createMockHyperdrive(connectionString);
+      continue;
     }
+    missingFixtures.push({
+      service: "hyperdrive",
+      binding: name,
+      reason: `Hyperdrive binding "${name}" has no local connection string. Configure bindings.hyperdrive.${name}.localConnectionString or pass fixtures.hyperdrive.${name}.`
+    });
   }
-  if (options.queues) {
-    for (const name of options.queues) {
-      env2[name] = createMockQueue();
+}
+function addWorkerLoaderBindings(env3, bindings, fixtures) {
+  for (const name of Object.keys(bindings?.workerLoaders ?? {})) {
+    env3[name] = createMockWorkerLoader(fixtures.workerLoaders?.[name]);
+  }
+}
+function addMTLSCertificateBindings(env3, bindings, fixtures) {
+  for (const name of Object.keys(bindings?.mtlsCertificates ?? {})) {
+    env3[name] = createMockMTLSCertificate(fixtures.mtlsCertificates?.[name]);
+  }
+}
+function addDispatchNamespaceBindings(env3, bindings, fixtures) {
+  for (const name of Object.keys(bindings?.dispatchNamespaces ?? {})) {
+    env3[name] = createMockDispatchNamespace(fixtures.dispatchNamespaces?.[name]);
+  }
+}
+function addWorkflowBindings(env3, bindings, fixtures) {
+  for (const name of Object.keys(bindings?.workflows ?? {})) {
+    const fixture = fixtures.workflows?.[name];
+    env3[name] = fixture && isWorkflowBinding(fixture) ? fixture : createMockWorkflow(fixture);
+  }
+}
+function addPipelineBindings(env3, bindings, fixtures) {
+  for (const name of Object.keys(bindings?.pipelines ?? {})) {
+    const fixture = fixtures.pipelines?.[name];
+    env3[name] = isPipelineBinding(fixture) ? fixture : createMockPipeline();
+  }
+}
+function addImagesBindings(env3, bindings, fixtures) {
+  for (const name of Object.keys(bindings?.images ?? {})) {
+    const fixture = fixtures.images?.[name];
+    env3[name] = isImagesBinding(fixture) ? fixture : createMockImagesBinding(fixture);
+  }
+}
+function addMediaBindings(env3, bindings, fixtures) {
+  for (const name of Object.keys(bindings?.media ?? {})) {
+    const fixture = fixtures.media?.[name];
+    env3[name] = isMediaBinding(fixture) ? fixture : createMockMediaBinding(fixture);
+  }
+}
+function addArtifactsBindings(env3, bindings, fixtures) {
+  for (const name of Object.keys(bindings?.artifacts ?? {})) {
+    const fixture = fixtures.artifacts?.[name];
+    env3[name] = isArtifactsBinding2(fixture) ? fixture : createMockArtifacts(fixture);
+  }
+}
+function addSecretsStoreBindings(env3, bindings, fixtures, localSecretValues, missingFixtures) {
+  for (const name of Object.keys(bindings?.secretsStore ?? {})) {
+    const value = fixtures.secretsStore?.[name] ?? localSecretValues[name];
+    if (value === undefined) {
+      missingFixtures.push({
+        service: "secretsStore",
+        binding: name,
+        reason: `Secrets Store values are not present in fixtures or the local secret store; pass fixtures.secretsStore.${name} or run devflare secrets --local.`
+      });
+      env3[name] = createMissingSecret(name);
+    } else {
+      env3[name] = createMockSecretsStoreSecret(value);
     }
   }
-  if (options.vars) {
-    Object.assign(env2, options.vars);
+}
+function addAISearchBindings(env3, bindings, fixtures) {
+  for (const [name, binding] of Object.entries(bindings?.aiSearch ?? {})) {
+    const fixture = fixtures.aiSearch?.[name];
+    env3[name] = isAISearchInstance2(fixture) ? fixture : createMockAISearchInstance({
+      id: binding.instanceName,
+      ...fixture
+    });
   }
-  if (options.secrets) {
-    Object.assign(env2, options.secrets);
+}
+function addAISearchNamespaceBindings(env3, bindings, fixtures) {
+  for (const [name, binding] of Object.entries(bindings?.aiSearchNamespaces ?? {})) {
+    const fixture = fixtures.aiSearchNamespaces?.[name];
+    env3[name] = isAISearchNamespace(fixture) ? fixture : createMockAISearchNamespace({
+      namespace: binding.namespace,
+      ...fixture
+    });
   }
-  if (options.custom) {
-    Object.assign(env2, options.custom);
+}
+function addRemoteBoundaries(remoteBoundaries, bindings) {
+  if (bindings?.ai) {
+    addBoundary(remoteBoundaries, "ai", bindings.ai.binding || "AI", "Workers AI inference is not available in offline local simulations.");
   }
-  return env2;
+  for (const name of Object.keys(bindings?.vectorize ?? {})) {
+    addBoundary(remoteBoundaries, "vectorize", name, "Vectorize has no offline local simulation in Cloudflare local development.");
+  }
+}
+function createOfflineBindings(config, fixtures = {}, options = {}) {
+  const env3 = {};
+  const remoteBoundaries = [];
+  const missingFixtures = [];
+  const bindings = config.bindings;
+  const localSecretValues = options.cwd && options.useLocalSecrets !== false ? resolveLocalSecretValuesForBindings(config, options.cwd) : {};
+  addStaticBindings(env3, config);
+  addRateLimitBindings(env3, bindings);
+  addVersionMetadataBinding(env3, bindings);
+  addHyperdriveBindings(env3, bindings, fixtures, missingFixtures);
+  addWorkerLoaderBindings(env3, bindings, fixtures);
+  addMTLSCertificateBindings(env3, bindings, fixtures);
+  addDispatchNamespaceBindings(env3, bindings, fixtures);
+  addWorkflowBindings(env3, bindings, fixtures);
+  addPipelineBindings(env3, bindings, fixtures);
+  addImagesBindings(env3, bindings, fixtures);
+  addMediaBindings(env3, bindings, fixtures);
+  addArtifactsBindings(env3, bindings, fixtures);
+  addSecretsStoreBindings(env3, bindings, fixtures, localSecretValues, missingFixtures);
+  addAISearchBindings(env3, bindings, fixtures);
+  addAISearchNamespaceBindings(env3, bindings, fixtures);
+  addRemoteBoundaries(remoteBoundaries, bindings);
+  if (fixtures.custom) {
+    Object.assign(env3, fixtures.custom);
+  }
+  return {
+    env: env3,
+    support: getOfflineSupportMatrix(),
+    remoteBoundaries,
+    missingFixtures
+  };
+}
+function createOfflineEnv(config, fixtures = {}, options = {}) {
+  return createOfflineBindings(config, fixtures, options).env;
 }
 export {
   worker,
   withTestContext,
   tail,
+  stopActiveContainers,
   shouldSkip,
   scheduled,
   resolveServiceBindings,
   resolveDOBindings,
-  queue,
+  queue2 as queue,
   hasServiceBindings,
   hasCrossWorkerDOs,
+  getOfflineSupportMatrix,
+  getContainerSkipReason,
   env,
   email,
+  detectContainerEngine,
+  describeOfflineSupport,
   createTestContext,
+  createOfflineEnv,
+  createOfflineBindings,
+  createMockWorkflow,
+  createMockWorkerLoader,
+  createMockVersionMetadata,
   createMockTestContext,
+  createMockSecretsStoreSecret,
+  createMockRateLimit,
   createMockR2,
   createMockQueue,
+  createMockPipeline,
+  createMockMediaBinding,
+  createMockMTLSCertificate,
   createMockKV,
+  createMockImagesBinding,
+  createMockHyperdrive,
   createMockEnv,
+  createMockDispatchNamespace,
   createMockD1,
+  createMockArtifacts,
+  createMockAISearchNamespace,
+  createMockAISearchInstance,
+  createContainerManager,
+  containers,
   clearBundleCache,
   cf
 };