devflare 1.0.0-next.7 → 1.0.0-next.70

package/dist/index-f8qh2tyh.js

@@ -1,2152 +0,0 @@
-import {
-  getRemoteModeStatus,
-  isRemoteModeActive
-} from "./index-d8bdkx2h.js";
-import {
-  transformWorkerEntrypoint
-} from "./index-z14anrqp.js";
-import {
-  discoverEntrypointsSync,
-  resolvePackageSpecifier
-} from "./index-tk6ej9dj.js";
-import {
-  __clearTestContext,
-  __setTestContext
-} from "./index-9ats0s83.js";
-import {
-  runWithContext
-} from "./index-npc1c8jx.js";
-import {
-  DEFAULT_DO_PATTERN,
-  findFiles,
-  findFilesSync
-} from "./index-rbht7m9r.js";
-import {
-  findDurableObjectClasses
-} from "./index-gz1gndna.js";
-import {
-  startMiniflare,
-  startMiniflareFromConfig
-} from "./index-p7g30wd2.js";
-import {
-  BridgeClient,
-  createEnvProxy,
-  setBindingHints
-} from "./index-ccrh4w3t.js";
-import {
-  loadConfig,
-  normalizeDOBinding,
-  resolveConfigPath
-} from "./index-hcex3rgh.js";
-import {
-  canProceedWithTest,
-  getApiToken,
-  getEffectiveAccountId,
-  getPrimaryAccount,
-  isAuthenticated
-} from "./index-tfyxa77h.js";
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/test/simple-context.ts
-import { resolve as resolve2, dirname as dirname2, join as join6 } from "path";
-import { existsSync as existsSync2 } from "fs";
-
-// src/test/remote-ai.ts
-function createRemoteAI(accountId) {
-  let resolvedAccountId = null;
-  async function getAccountId() {
-    if (accountId)
-      return accountId;
-    if (resolvedAccountId)
-      return resolvedAccountId;
-    const primary = await getPrimaryAccount();
-    if (!primary) {
-      throw new Error("No Cloudflare account found. Run: bunx wrangler login");
-    }
-    const { accountId: effectiveId } = await getEffectiveAccountId(primary.id);
-    resolvedAccountId = effectiveId;
-    return effectiveId;
-  }
-  async function getToken() {
-    const token = await getApiToken();
-    if (!token) {
-      throw new Error("Not authenticated. Run: bunx wrangler login");
-    }
-    return token;
-  }
-  const ai = {
-    async run(model, inputs) {
-      const [acctId, token] = await Promise.all([getAccountId(), getToken()]);
-      const url = `https://api.cloudflare.com/client/v4/accounts/${acctId}/ai/run/${model}`;
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${token}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(inputs)
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`AI API error (${response.status}): ${errorText}`);
-      }
-      const result = await response.json();
-      if (!result.success) {
-        const message = result.errors?.[0]?.message || "Unknown AI error";
-        throw new Error(`AI API error: ${message}`);
-      }
-      return result.result;
-    },
-    gateway(_gatewayId) {
-      console.warn("AI Gateway is not supported in remote test mode");
-      return ai;
-    }
-  };
-  return ai;
-}
-
-// src/test/remote-vectorize.ts
-function createRemoteVectorize(indexName, accountId) {
-  let resolvedAccountId = null;
-  async function getAccountId() {
-    if (accountId)
-      return accountId;
-    if (resolvedAccountId)
-      return resolvedAccountId;
-    const primary = await getPrimaryAccount();
-    if (!primary) {
-      throw new Error("No Cloudflare account found. Run: bunx wrangler login");
-    }
-    const { accountId: effectiveId } = await getEffectiveAccountId(primary.id);
-    resolvedAccountId = effectiveId;
-    return effectiveId;
-  }
-  async function getToken() {
-    const token = await getApiToken();
-    if (!token) {
-      throw new Error("Not authenticated. Run: bunx wrangler login");
-    }
-    return token;
-  }
-  async function apiRequest(method, endpoint, body) {
-    const [acctId, token] = await Promise.all([getAccountId(), getToken()]);
-    const url = `https://api.cloudflare.com/client/v4/accounts/${acctId}/vectorize/v2/indexes/${indexName}${endpoint}`;
-    const response = await fetch(url, {
-      method,
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
-      },
-      body: body ? JSON.stringify(body) : undefined
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Vectorize API error (${response.status}): ${errorText}`);
-    }
-    const result = await response.json();
-    if (!result.success) {
-      const message = result.errors?.[0]?.message || "Unknown Vectorize error";
-      throw new Error(`Vectorize API error: ${message}`);
-    }
-    return result.result;
-  }
-  async function ndjsonRequest(endpoint, vectors) {
-    const [acctId, token] = await Promise.all([getAccountId(), getToken()]);
-    const url = `https://api.cloudflare.com/client/v4/accounts/${acctId}/vectorize/v2/indexes/${indexName}${endpoint}`;
-    const ndjson = vectors.map((v) => JSON.stringify(v)).join(`
-`);
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/x-ndjson"
-      },
-      body: ndjson
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Vectorize API error (${response.status}): ${errorText}`);
-    }
-    const result = await response.json();
-    if (!result.success) {
-      const message = result.errors?.[0]?.message || "Unknown Vectorize error";
-      throw new Error(`Vectorize API error: ${message}`);
-    }
-    return result.result;
-  }
-  const vectorize = {
-    async describe() {
-      return apiRequest("GET", "");
-    },
-    async query(vector, options) {
-      const vectorArray = Array.isArray(vector) ? vector : Array.from(vector);
-      return apiRequest("POST", "/query", {
-        vector: vectorArray,
-        topK: options?.topK ?? 10,
-        returnValues: options?.returnValues ?? false,
-        returnMetadata: options?.returnMetadata ?? "none",
-        namespace: options?.namespace,
-        filter: options?.filter
-      });
-    },
-    async insert(vectors) {
-      const result = await ndjsonRequest("/insert", vectors);
-      return {
-        count: result.count,
-        ids: result.ids || vectors.map((v) => v.id)
-      };
-    },
-    async upsert(vectors) {
-      const result = await ndjsonRequest("/upsert", vectors);
-      return {
-        count: result.count,
-        ids: result.ids || vectors.map((v) => v.id)
-      };
-    },
-    async deleteByIds(ids) {
-      const result = await apiRequest("POST", "/delete-by-ids", { ids });
-      return {
-        count: result.count,
-        ids
-      };
-    },
-    async getByIds(ids) {
-      return apiRequest("POST", "/get-by-ids", { ids });
-    }
-  };
-  return vectorize;
-}
-
-// src/test/resolve-service-bindings.ts
-import { dirname, join, resolve } from "path";
-import { existsSync, readFileSync } from "fs";
-function getBunRuntime() {
-  const g = globalThis;
-  if (typeof g.Bun === "object" && g.Bun !== null) {
-    return g.Bun;
-  }
-  return;
-}
-function discoverDOFilesSync(dir) {
-  const classToPath = new Map;
-  try {
-    const files = findFilesSync(DEFAULT_DO_PATTERN, { cwd: dir });
-    for (const filePath of files) {
-      try {
-        const code = readFileSync(filePath, "utf-8");
-        const classNames = findDurableObjectClasses(code);
-        for (const className of classNames) {
-          if (!classToPath.has(className)) {
-            classToPath.set(className, filePath);
-          }
-        }
-      } catch {}
-    }
-  } catch {}
-  return classToPath;
-}
-var bundleCache = new Map;
-function clearBundleCache() {
-  bundleCache.clear();
-}
-function hasServiceBindings(config) {
-  const services = config.bindings?.services;
-  if (!services)
-    return false;
-  return Object.keys(services).length > 0;
-}
-async function resolveServiceBindings(config, configDir) {
-  const services = config.bindings?.services;
-  if (!services) {
-    return { workers: [], primaryServiceBindings: {} };
-  }
-  const workersByName = new Map;
-  const primaryServiceBindings = {};
-  for (const [bindingName, binding] of Object.entries(services)) {
-    const workerBinding = binding;
-    const ref = workerBinding.__ref;
-    if (ref) {
-      if ("__import" in ref && typeof ref.__import === "function") {
-        await ref.resolve();
-      }
-      const workerName = ref.name;
-      const entrypoint = workerBinding.entrypoint;
-      if (!workersByName.has(workerName)) {
-        const worker = await resolveRefWorker(ref, entrypoint, configDir);
-        if (worker) {
-          workersByName.set(workerName, worker);
-        }
-      }
-      primaryServiceBindings[bindingName] = {
-        name: workerName,
-        ...entrypoint && { entrypoint }
-      };
-    } else {
-      primaryServiceBindings[bindingName] = {
-        name: workerBinding.service,
-        ...workerBinding.entrypoint && { entrypoint: workerBinding.entrypoint }
-      };
-    }
-  }
-  return {
-    workers: [...workersByName.values()],
-    primaryServiceBindings
-  };
-}
-async function resolveRefWorker(ref, _entrypoint, parentConfigDir) {
-  const config = ref.config;
-  if (!config)
-    return null;
-  const configPath = ref.configPath;
-  if (!configPath || configPath === "<resolved>") {
-    console.warn(`[devflare] Cannot resolve worker "${ref.name}" - configPath not available`);
-    return null;
-  }
-  const refConfigDir = resolve(parentConfigDir, dirname(configPath));
-  const entrypoints = [];
-  const files = config.files;
-  const mainPath = files?.fetch ?? "src/worker.ts";
-  const workerTsPath = resolve(refConfigDir, mainPath);
-  if (existsSync(workerTsPath)) {
-    const isWorkerTs = mainPath.endsWith("worker.ts") || mainPath.endsWith("worker.js");
-    entrypoints.push({
-      path: workerTsPath,
-      className: "Worker",
-      isWorkerTs
-    });
-  }
-  const discoveredEntrypoints = discoverEntrypointsSync(refConfigDir);
-  for (const ep of discoveredEntrypoints) {
-    entrypoints.push({
-      path: ep.filePath,
-      className: ep.className,
-      isWorkerTs: false
-    });
-  }
-  if (entrypoints.length === 0) {
-    console.warn(`[devflare] Worker "${ref.name}" has no entry points`);
-    return null;
-  }
-  const script = await bundleAllEntrypoints(entrypoints, ref.name);
-  if (!script)
-    return null;
-  return {
-    name: ref.name,
-    script,
-    modules: true,
-    compatibilityDate: config.compatibilityDate ?? "2025-01-01"
-  };
-}
-async function bundleAllEntrypoints(entrypoints, workerName) {
-  const cacheKey = entrypoints.map((ep) => `${ep.path}::${ep.className}`).join("|");
-  const cached = bundleCache.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-  const bun = getBunRuntime();
-  if (!bun) {
-    console.warn("[devflare] Bun runtime required for bundling worker scripts");
-    return null;
-  }
-  try {
-    const { readFileSync: readFileSync2, writeFileSync, mkdirSync, unlinkSync } = await import("fs");
-    const imports = [];
-    const exports = [];
-    let defaultExportClass = null;
-    for (let i = 0;i < entrypoints.length; i++) {
-      const ep = entrypoints[i];
-      const sourceCode = readFileSync2(ep.path, "utf-8");
-      if (ep.isWorkerTs) {
-        const result = transformWorkerEntrypoint(sourceCode, ep.path, {
-          className: ep.className,
-          injectContext: false
-        });
-        if (result) {
-          const tempDir2 = join(dirname(ep.path), ".devflare");
-          mkdirSync(tempDir2, { recursive: true });
-          const tempPath = join(tempDir2, `__${ep.className}_${i}.ts`);
-          writeFileSync(tempPath, result.code);
-          imports.push(`import { ${ep.className} } from '${tempPath.replace(/\\/g, "/")}'`);
-          exports.push(ep.className);
-          if (!defaultExportClass) {
-            defaultExportClass = ep.className;
-          }
-        }
-      } else {
-        imports.push(`import { ${ep.className} } from '${ep.path.replace(/\\/g, "/")}'`);
-        exports.push(ep.className);
-      }
-    }
-    const defaultExport = defaultExportClass ? `
-export default ${defaultExportClass}` : "";
-    const entryCode = `
-${imports.join(`
-`)}
-export { ${exports.join(", ")} }${defaultExport}
-`;
-    const tempDir = join(dirname(entrypoints[0].path), ".devflare");
-    mkdirSync(tempDir, { recursive: true });
-    const entryPath = join(tempDir, `__entry_${workerName}.ts`);
-    writeFileSync(entryPath, entryCode);
-    try {
-      const result = await bun.build({
-        entrypoints: [entryPath],
-        target: "browser",
-        format: "esm",
-        minify: false,
-        external: ["cloudflare:workers", "cloudflare:*"]
-      });
-      if (!result.success) {
-        console.warn(`[devflare] Failed to bundle worker "${workerName}": ${result.logs.join(`
-`)}`);
-        return null;
-      }
-      const bundledCode = await result.outputs[0].text();
-      bundleCache.set(cacheKey, bundledCode);
-      return bundledCode;
-    } finally {
-      try {
-        unlinkSync(entryPath);
-      } catch {}
-    }
-  } catch (error) {
-    console.warn(`[devflare] Error bundling worker "${workerName}":`, error);
-    return null;
-  }
-}
-function hasCrossWorkerDOs(config) {
-  const dos = config.bindings?.durableObjects;
-  if (!dos)
-    return false;
-  for (const doConfig of Object.values(dos)) {
-    const normalized = normalizeDOBinding(doConfig);
-    if (normalized.__ref)
-      return true;
-  }
-  return false;
-}
-async function resolveDOBindings(config, configDir) {
-  const dos = config.bindings?.durableObjects;
-  if (!dos) {
-    return { workers: [], crossWorkerDOBindings: {} };
-  }
-  const workersByName = new Map;
-  const crossWorkerDOBindings = {};
-  for (const [bindingName, rawDoConfig] of Object.entries(dos)) {
-    const hasRef = typeof rawDoConfig === "object" && "__ref" in rawDoConfig;
-    if (!hasRef) {
-      continue;
-    }
-    const ref = rawDoConfig.__ref;
-    if ("__import" in ref && typeof ref.__import === "function") {
-      await ref.resolve();
-    }
-    const doConfig = normalizeDOBinding(rawDoConfig);
-    const workerName = ref.name;
-    if (!workersByName.has(workerName)) {
-      const worker = await resolveDORefWorker(ref, configDir);
-      if (worker) {
-        workersByName.set(workerName, worker);
-      }
-    }
-    crossWorkerDOBindings[bindingName] = {
-      className: doConfig.className,
-      scriptName: workerName
-    };
-  }
-  return {
-    workers: [...workersByName.values()],
-    crossWorkerDOBindings
-  };
-}
-async function resolveDORefWorker(ref, parentConfigDir) {
-  const config = ref.config;
-  if (!config)
-    return null;
-  const configPath = ref.configPath;
-  if (!configPath || configPath === "<resolved>") {
-    console.warn(`[devflare] Cannot resolve DO worker "${ref.name}" - configPath not available`);
-    return null;
-  }
-  const resolvedConfigPath = resolvePackageSpecifier(configPath, parentConfigDir);
-  const refConfigDir = dirname(resolvedConfigPath);
-  const dosConfig = config.bindings?.durableObjects;
-  if (!dosConfig || Object.keys(dosConfig).length === 0) {
-    console.warn(`[devflare] Referenced worker "${ref.name}" has no Durable Objects`);
-    return null;
-  }
-  const discoveredDOs = discoverDOFilesSync(refConfigDir);
-  const doClasses = [];
-  for (const [bindingName, rawDoConfig] of Object.entries(dosConfig)) {
-    const doConfig = normalizeDOBinding(rawDoConfig);
-    const className = doConfig.className;
-    const scriptName = doConfig.scriptName;
-    if (scriptName) {
-      const scriptPath = resolve(refConfigDir, "src", scriptName);
-      if (!existsSync(scriptPath)) {
-        const altPath = resolve(refConfigDir, scriptName);
-        if (!existsSync(altPath)) {
-          console.warn(`[devflare] DO script not found: ${scriptPath} or ${altPath}`);
-          continue;
-        }
-        doClasses.push({ bindingName, className, scriptPath: altPath });
-      } else {
-        doClasses.push({ bindingName, className, scriptPath });
-      }
-    } else {
-      const discoveredPath = discoveredDOs.get(className);
-      if (discoveredPath) {
-        doClasses.push({ bindingName, className, scriptPath: discoveredPath });
-      } else {
-        console.warn(`[devflare] DO "${bindingName}" (class: ${className}) not found in do.*.ts files in "${ref.name}"`);
-        continue;
-      }
-    }
-  }
-  if (doClasses.length === 0) {
-    console.warn(`[devflare] No valid DO classes found in "${ref.name}"`);
-    return null;
-  }
-  const script = await bundleDOClasses(doClasses, ref.name);
-  if (!script)
-    return null;
-  const durableObjects = {};
-  for (const do_ of doClasses) {
-    durableObjects[do_.bindingName] = do_.className;
-  }
-  return {
-    name: ref.name,
-    script,
-    modules: true,
-    compatibilityDate: config.compatibilityDate ?? "2025-01-01",
-    durableObjects
-  };
-}
-async function bundleDOClasses(doClasses, workerName) {
-  const cacheKey = `do:${doClasses.map((d) => `${d.scriptPath}::${d.className}`).join("|")}`;
-  const cached = bundleCache.get(cacheKey);
-  if (cached)
-    return cached;
-  const bun = getBunRuntime();
-  if (!bun) {
-    console.warn("[devflare] Bun runtime required for bundling DO classes");
-    return null;
-  }
-  try {
-    const { writeFileSync, mkdirSync, unlinkSync } = await import("fs");
-    const imports = doClasses.map((d) => `import { ${d.className} } from '${d.scriptPath.replace(/\\/g, "/")}'`).join(`
-`);
-    const exports = doClasses.map((d) => d.className).join(", ");
-    const entryCode = `
-${imports}
-
-// Re-export DO classes for Miniflare binding
-export { ${exports} }
-
-// Default export with fetch handler
-export default {
-	async fetch(request, env) {
-		return new Response('DO Worker: ${workerName}')
-	}
-}
-`;
-    const tempDir = join(dirname(doClasses[0].scriptPath), ".devflare");
-    mkdirSync(tempDir, { recursive: true });
-    const entryPath = join(tempDir, `__do_entry_${workerName}.ts`);
-    writeFileSync(entryPath, entryCode);
-    try {
-      const result = await bun.build({
-        entrypoints: [entryPath],
-        target: "browser",
-        format: "esm",
-        minify: false,
-        external: ["cloudflare:workers", "cloudflare:*"]
-      });
-      if (!result.success) {
-        console.warn(`[devflare] Failed to bundle DO worker "${workerName}": ${result.logs.join(`
-`)}`);
-        return null;
-      }
-      const bundledCode = await result.outputs[0].text();
-      bundleCache.set(cacheKey, bundledCode);
-      return bundledCode;
-    } finally {
-      try {
-        unlinkSync(entryPath);
-      } catch {}
-    }
-  } catch (error) {
-    console.warn(`[devflare] Error bundling DO worker "${workerName}":`, error);
-    return null;
-  }
-}
-
-// src/test/queue.ts
-import { join as join2 } from "path";
-var queueHandlerPath = null;
-var configDir = null;
-var testEnvGetter = null;
-function configureQueue(options) {
-  queueHandlerPath = options.handlerPath;
-  configDir = options.configDir;
-  testEnvGetter = options.getEnv;
-}
-function resetQueueState() {
-  queueHandlerPath = null;
-  configDir = null;
-  testEnvGetter = null;
-}
-function createMessage(options) {
-  const id = options.id ?? crypto.randomUUID();
-  const timestamp = options.timestamp ?? new Date;
-  const attempts = options.attempts ?? 1;
-  let state = "pending";
-  return {
-    id,
-    timestamp,
-    body: options.body,
-    attempts,
-    ack() {
-      state = "acked";
-    },
-    retry(opts) {
-      state = "retried";
-    },
-    retryAll() {
-      state = "retried";
-    },
-    get _state() {
-      return state;
-    }
-  };
-}
-function createMessageBatch(messages) {
-  return {
-    queue: "test-queue",
-    messages,
-    ackAll() {
-      for (const msg of messages) {
-        msg.ack();
-      }
-    },
-    retryAll() {
-      for (const msg of messages) {
-        msg.retry();
-      }
-    }
-  };
-}
-async function trigger(messages) {
-  if (!queueHandlerPath) {
-    throw new Error("Queue handler not configured. Make sure your devflare.config.ts has files.queue set, " + "and the file exists at the specified path (default: src/queue.ts)");
-  }
-  if (!configDir || !testEnvGetter) {
-    throw new Error("Queue helper not initialized. Call createTestContext() before using cf.queue.trigger()");
-  }
-  const absolutePath = join2(configDir, queueHandlerPath);
-  const handlerModule = await import(absolutePath);
-  const queueHandler = handlerModule.default ?? handlerModule.queue;
-  if (typeof queueHandler !== "function") {
-    throw new Error(`Queue handler at "${queueHandlerPath}" must export a default function or named "queue" export.
-Expected: export default async function queue(batch, env, ctx) { ... }
-Or: export async function queue(batch, env, ctx) { ... }`);
-  }
-  const normalizedMessages = messages.map((msg) => {
-    if (typeof msg === "object" && msg !== null && "body" in msg) {
-      return msg;
-    }
-    return { body: msg };
-  });
-  const mockMessages = normalizedMessages.map((opts) => createMessage(opts));
-  const batch = createMessageBatch(mockMessages);
-  const waitUntilPromises = [];
-  const ctx = {
-    waitUntil(promise) {
-      waitUntilPromises.push(promise);
-    },
-    passThroughOnException() {},
-    props: {}
-  };
-  const env = testEnvGetter();
-  await queueHandler(batch, env, ctx);
-  await Promise.all(waitUntilPromises);
-  const acked = [];
-  const retried = [];
-  const failed = [];
-  for (const msg of mockMessages) {
-    switch (msg._state) {
-      case "acked":
-        acked.push(msg.id);
-        break;
-      case "retried":
-        retried.push(msg.id);
-        break;
-      case "failed":
-        failed.push(msg.id);
-        break;
-    }
-  }
-  return {
-    acked,
-    retried,
-    failed,
-    total: mockMessages.length
-  };
-}
-async function send(message) {
-  return trigger([message]);
-}
-var queue = {
-  trigger,
-  send
-};
-
-// src/test/scheduled.ts
-import { join as join3 } from "path";
-var scheduledHandlerPath = null;
-var configDir2 = null;
-var testEnvGetter2 = null;
-function configureScheduled(options) {
-  scheduledHandlerPath = options.handlerPath;
-  configDir2 = options.configDir;
-  testEnvGetter2 = options.getEnv;
-}
-function resetScheduledState() {
-  scheduledHandlerPath = null;
-  configDir2 = null;
-  testEnvGetter2 = null;
-}
-async function trigger2(cronOrOptions) {
-  if (!scheduledHandlerPath) {
-    throw new Error("Scheduled handler not configured. Make sure your devflare.config.ts has files.scheduled set, " + "and the file exists at the specified path (default: src/scheduled.ts)");
-  }
-  if (!configDir2 || !testEnvGetter2) {
-    throw new Error("Scheduled helper not initialized. Call createTestContext() before using cf.scheduled.trigger()");
-  }
-  const options = typeof cronOrOptions === "string" ? { cron: cronOrOptions } : cronOrOptions ?? {};
-  const cron = options.cron ?? "* * * * *";
-  const scheduledTime = options.scheduledTime instanceof Date ? options.scheduledTime.getTime() : options.scheduledTime ?? Date.now();
-  const absolutePath = join3(configDir2, scheduledHandlerPath);
-  const handlerModule = await import(absolutePath);
-  const scheduledHandler = handlerModule.default ?? handlerModule.scheduled;
-  if (typeof scheduledHandler !== "function") {
-    throw new Error(`Scheduled handler at "${scheduledHandlerPath}" must export a default function or named "scheduled" export.
-Expected: export default async function scheduled(controller, env, ctx) { ... }
-Or: export async function scheduled(controller, env, ctx) { ... }`);
-  }
-  const controller = {
-    scheduledTime,
-    cron,
-    noRetry() {}
-  };
-  const waitUntilPromises = [];
-  const ctx = {
-    waitUntil(promise) {
-      waitUntilPromises.push(promise);
-    },
-    passThroughOnException() {},
-    props: {}
-  };
-  const env = testEnvGetter2();
-  try {
-    await scheduledHandler(controller, env, ctx);
-    await Promise.all(waitUntilPromises);
-    return {
-      success: true,
-      cron,
-      scheduledTime
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error),
-      cron,
-      scheduledTime
-    };
-  }
-}
-var scheduled = {
-  trigger: trigger2
-};
-
-// src/test/worker.ts
-import { join as join4 } from "path";
-var fetchHandlerPath = null;
-var configDir3 = null;
-var testEnvGetter3 = null;
-function configureWorker(options) {
-  fetchHandlerPath = options.handlerPath;
-  configDir3 = options.configDir;
-  testEnvGetter3 = options.getEnv;
-}
-function resetWorkerState() {
-  fetchHandlerPath = null;
-  configDir3 = null;
-  testEnvGetter3 = null;
-}
-async function fetch2(request, options) {
-  if (!fetchHandlerPath) {
-    throw new Error("Fetch handler not configured. Make sure your devflare.config.ts has files.fetch set, " + "and the file exists at the specified path (default: src/fetch.ts)");
-  }
-  if (!configDir3 || !testEnvGetter3) {
-    throw new Error("Worker helper not initialized. Call createTestContext() before using cf.worker.fetch()");
-  }
-  let req;
-  if (typeof request === "string") {
-    const url = request.startsWith("http") ? request : `http://localhost${request.startsWith("/") ? "" : "/"}${request}`;
-    const headers = new Headers(options?.headers);
-    let body;
-    if (options?.body !== undefined) {
-      if (typeof options.body === "string") {
-        body = options.body;
-      } else {
-        body = JSON.stringify(options.body);
-        if (!headers.has("Content-Type")) {
-          headers.set("Content-Type", "application/json");
-        }
-      }
-    }
-    req = new Request(url, {
-      method: options?.method ?? "GET",
-      headers,
-      body
-    });
-  } else {
-    req = request;
-  }
-  const absolutePath = join4(configDir3, fetchHandlerPath);
-  const handlerModule = await import(absolutePath);
-  const fetchHandler = handlerModule.default ?? handlerModule.fetch;
-  if (typeof fetchHandler !== "function") {
-    throw new Error(`Fetch handler at "${fetchHandlerPath}" must export a default function or named "fetch" export.
-Expected: export default async function fetch(request, env, ctx) { ... }
-Or: export async function fetch(request, env, ctx) { ... }`);
-  }
-  const waitUntilPromises = [];
-  const ctx = {
-    waitUntil(promise) {
-      waitUntilPromises.push(promise);
-    },
-    passThroughOnException() {},
-    props: {}
-  };
-  const env = testEnvGetter3();
-  const response = await fetchHandler(req, env, ctx);
-  return response;
-}
-async function get(path, headers) {
-  return fetch2(path, { method: "GET", headers });
-}
-async function post(path, body, headers) {
-  return fetch2(path, { method: "POST", body, headers });
-}
-async function put(path, body, headers) {
-  return fetch2(path, { method: "PUT", body, headers });
-}
-async function del(path, headers) {
-  return fetch2(path, { method: "DELETE", headers });
-}
-async function patch(path, body, headers) {
-  return fetch2(path, { method: "PATCH", body, headers });
-}
-var worker = {
-  fetch: fetch2,
-  get,
-  post,
-  put,
-  delete: del,
-  patch
-};
-
-// src/test/tail.ts
-import { join as join5 } from "path";
-var tailHandlerPath = null;
-var configDir4 = null;
-var testEnvGetter4 = null;
-function configureTail(options) {
-  tailHandlerPath = options.handlerPath;
-  configDir4 = options.configDir;
-  testEnvGetter4 = options.getEnv;
-}
-function resetTailState() {
-  tailHandlerPath = null;
-  configDir4 = null;
-  testEnvGetter4 = null;
-}
-function createTraceItem(options) {
-  return {
-    scriptName: options.scriptName ?? "test-worker",
-    outcome: options.outcome ?? "ok",
-    eventTimestamp: options.eventTimestamp ?? Date.now(),
-    event: options.event ?? {
-      request: {
-        url: "https://example.com/",
-        method: "GET"
-      }
-    },
-    logs: options.logs ?? [],
-    exceptions: options.exceptions ?? [],
-    diagnosticsChannelEvents: options.diagnosticsChannelEvents ?? [],
-    scriptVersion: options.scriptVersion ?? { id: "test-version" },
-    dispatchNamespace: options.dispatchNamespace,
-    scriptTags: options.scriptTags ?? []
-  };
-}
-async function trigger3(items) {
-  if (!tailHandlerPath) {
-    throw new Error("Tail handler not configured. Make sure your devflare.config.ts has files.tail set, " + "or the file exists at src/tail.ts");
-  }
-  if (!configDir4 || !testEnvGetter4) {
-    throw new Error("Tail helper not initialized. Call createTestContext() before using cf.tail.trigger()");
-  }
-  const traceItems = items.map((item) => {
-    if ("eventTimestamp" in item && "outcome" in item && "scriptName" in item) {
-      return item;
-    }
-    return createTraceItem(item);
-  });
-  const absolutePath = join5(configDir4, tailHandlerPath);
-  const handlerModule = await import(absolutePath);
-  const tailHandler = handlerModule.default ?? handlerModule.tail;
-  if (typeof tailHandler !== "function") {
-    throw new Error(`Tail handler at "${tailHandlerPath}" must export a default function or named "tail" export.
-Expected: export default async function tail(events, env, ctx) { ... }
-Or: export async function tail(events, env, ctx) { ... }`);
-  }
-  const waitUntilPromises = [];
-  const ctx = {
-    waitUntil(promise) {
-      waitUntilPromises.push(promise);
-    },
-    passThroughOnException() {},
-    props: {}
-  };
-  const env = testEnvGetter4();
-  try {
-    await tailHandler(traceItems, env, ctx);
-    await Promise.all(waitUntilPromises);
-    return {
-      success: true,
-      itemCount: traceItems.length
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error),
-      itemCount: traceItems.length
-    };
-  }
-}
-function create(options = {}) {
-  return createTraceItem(options);
-}
-var tail = {
-  trigger: trigger3,
-  create
-};
-
-// src/test/email.ts
-var miniflarePort = 8787;
-var emailListeners = [];
-var sentEmails = [];
-function configureEmail(options = {}) {
-  if (options.port) {
-    miniflarePort = options.port;
-  }
-}
-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
-`);
-}
-async function send2(options) {
-  const raw = buildRawEmail(options);
-  const url = new URL(`http://localhost:${miniflarePort}/cdn-cgi/handler/email`);
-  url.searchParams.set("from", options.from);
-  url.searchParams.set("to", options.to);
-  const response = await fetch(url.toString(), {
-    method: "POST",
-    headers: {
-      "Content-Type": "text/plain"
-    },
-    body: raw
-  });
-  return response;
-}
-function onReceive(callback) {
-  emailListeners.push(callback);
-  return () => {
-    emailListeners = emailListeners.filter((cb) => cb !== callback);
-  };
-}
-function getSentEmails() {
-  return [...sentEmails];
-}
-function clearSentEmails() {
-  sentEmails = [];
-}
-function resetEmailState() {
-  emailListeners = [];
-  sentEmails = [];
-}
-var email = {
-  send: send2,
-  onReceive,
-  getSentEmails,
-  clearSentEmails
-};
-
-// src/test/simple-context.ts
-function findExportedClasses(code) {
-  const classes = [];
-  const classPattern = /export\s+class\s+(\w+)/g;
-  let match;
-  while ((match = classPattern.exec(code)) !== null) {
-    classes.push(match[1]);
-  }
-  return classes;
-}
-function getBunRuntime2() {
-  const g = globalThis;
-  if (typeof g.Bun === "object" && g.Bun !== null) {
-    return g.Bun;
-  }
-  return;
-}
-var globalClient = null;
-var globalMiniflare = null;
-var globalEnvProxy = null;
-var globalTransportDecode = null;
-var globalRemoteBindings = null;
-var globalMiniflareBindings = null;
-function getCallerDirectory() {
-  const bun = getBunRuntime2();
-  if (bun?.main) {
-    const mainPath = bun.main;
-    if (!mainPath.includes("[") && existsSync2(mainPath)) {
-      return dirname2(mainPath);
-    }
-  }
-  const originalPrepare = Error.prepareStackTrace;
-  Error.prepareStackTrace = (_, stack2) => stack2;
-  const err = new Error;
-  const stack = err.stack;
-  Error.prepareStackTrace = originalPrepare;
-  for (const site of stack) {
-    const filename = site.getFileName?.();
-    if (filename && !filename.includes("simple-context") && !filename.includes("node_modules") && !filename.includes("[") && existsSync2(filename)) {
-      return dirname2(filename);
-    }
-  }
-  return process.cwd();
-}
-async function findNearestConfig(startDir) {
-  let currentDir = startDir;
-  while (true) {
-    const configPath = await resolveConfigPath(currentDir);
-    if (configPath) {
-      return configPath;
-    }
-    const parentDir = dirname2(currentDir);
-    if (parentDir === currentDir) {
-      return null;
-    }
-    currentDir = parentDir;
-  }
-}
-async function createTestContext(configPath) {
-  const callerDir = getCallerDirectory();
-  let absolutePath;
-  if (configPath) {
-    absolutePath = resolve2(callerDir, configPath);
-  } else {
-    const found = await findNearestConfig(callerDir);
-    if (!found) {
-      throw new Error(`Could not find a devflare config file. Searched upward from: ${callerDir}
-` + `Expected one of: devflare.config.ts, devflare.config.mts, devflare.config.js, devflare.config.mjs
-` + `Either create a config file or provide an explicit path: createTestContext('./path/to/config.ts')`);
-    }
-    absolutePath = found;
-  }
-  const configDir5 = dirname2(absolutePath);
-  const config = await loadConfig({
-    cwd: configDir5,
-    configFile: absolutePath.split(/[/\\]/).pop()
-  });
-  globalRemoteBindings = {};
-  if (isRemoteModeActive()) {
-    if (config.bindings?.ai) {
-      const aiBindingName = config.bindings.ai.binding || "AI";
-      globalRemoteBindings[aiBindingName] = createRemoteAI(config.accountId);
-    }
-    if (config.bindings?.vectorize) {
-      for (const [name, vectorConfig] of Object.entries(config.bindings.vectorize)) {
-        globalRemoteBindings[name] = createRemoteVectorize(vectorConfig.indexName, config.accountId);
-      }
-    }
-  }
-  if (config.vars) {
-    for (const [key, value] of Object.entries(config.vars)) {
-      globalRemoteBindings[key] = value;
-    }
-  }
-  const hints = {};
-  if (config.bindings?.kv) {
-    for (const name of Object.keys(config.bindings.kv))
-      hints[name] = "kv";
-  }
-  if (config.bindings?.r2) {
-    for (const name of Object.keys(config.bindings.r2))
-      hints[name] = "r2";
-  }
-  if (config.bindings?.d1) {
-    for (const name of Object.keys(config.bindings.d1))
-      hints[name] = "d1";
-  }
-  if (config.bindings?.durableObjects) {
-    for (const name of Object.keys(config.bindings.durableObjects))
-      hints[name] = "do";
-  }
-  if (config.bindings?.services) {
-    for (const name of Object.keys(config.bindings.services))
-      hints[name] = "service";
-  }
-  const needsMultiWorkerForServices = hasServiceBindings(config);
-  const needsMultiWorkerForDOs = hasCrossWorkerDOs(config);
-  const needsMultiWorker = needsMultiWorkerForServices || needsMultiWorkerForDOs;
-  let serviceBindingResolution = null;
-  let doBindingResolution = null;
-  if (needsMultiWorkerForServices) {
-    serviceBindingResolution = await resolveServiceBindings(config, configDir5);
-  }
-  if (needsMultiWorkerForDOs) {
-    doBindingResolution = await resolveDOBindings(config, configDir5);
-  }
-  const randomPort = 1e4 + Math.floor(Math.random() * 50000);
-  const mfConfig = {
-    modules: true,
-    port: randomPort
-  };
-  if (config.bindings?.kv)
-    mfConfig.kvNamespaces = Object.keys(config.bindings.kv);
-  if (config.bindings?.r2)
-    mfConfig.r2Buckets = Object.keys(config.bindings.r2);
-  if (config.bindings?.d1)
-    mfConfig.d1Databases = Object.keys(config.bindings.d1);
-  if (config.bindings?.queues?.producers) {
-    const queueProducers = {};
-    for (const [bindingName, queueName] of Object.entries(config.bindings.queues.producers)) {
-      queueProducers[bindingName] = { queueName };
-    }
-    mfConfig.queueProducers = queueProducers;
-  }
-  const transportFile = config.files?.transport;
-  if (transportFile) {
-    const transportPath = join6(configDir5, transportFile);
-    const transportModule = await import(transportPath);
-    if (!transportModule.transport) {
-      console.warn(`[devflare] Warning: Transport file "${transportFile}" does not export a named "transport" object.
-Expected: export const transport = { ... }
-Transport encoding/decoding will be disabled.`);
-    } else {
-      globalTransportDecode = new Map;
-      for (const [typeName, transporter] of Object.entries(transportModule.transport)) {
-        const t = transporter;
-        globalTransportDecode.set(typeName, t.decode);
-      }
-    }
-  }
-  if (config.bindings?.durableObjects) {
-    const doConfig = {};
-    const doInfos = [];
-    const classToFilePath = new Map;
-    const doPatternConfig = config.files?.durableObjects;
-    const doPattern = typeof doPatternConfig === "string" ? doPatternConfig : DEFAULT_DO_PATTERN;
-    if (doPatternConfig !== false) {
-      const fs = await import("fs/promises");
-      const doFiles = await findFiles(doPattern, { cwd: configDir5 });
-      for (const filePath of doFiles) {
-        try {
-          const code = await fs.readFile(filePath, "utf-8");
-          const classNames = findExportedClasses(code);
-          for (const className of classNames) {
-            classToFilePath.set(className, filePath);
-          }
-        } catch {}
-      }
-    }
-    for (const [name, rawDoInfo] of Object.entries(config.bindings.durableObjects)) {
-      const doInfo = normalizeDOBinding(rawDoInfo);
-      if (doInfo.__ref) {
-        continue;
-      }
-      let scriptPath;
-      if (doInfo.scriptName) {
-        scriptPath = join6(configDir5, "src", doInfo.scriptName);
-      } else {
-        const discoveredPath = classToFilePath.get(doInfo.className);
-        if (!discoveredPath) {
-          throw new Error(`Durable object ${name} (className: '${doInfo.className}') not found.
-Either:
-  1. Set files.durableObjects pattern in config (e.g., 'src/do.*.ts')
-  2. Use explicit scriptName: { className: '${doInfo.className}', scriptName: 'do.file.ts' }`);
-        }
-        scriptPath = discoveredPath;
-      }
-      doConfig[name] = doInfo.className;
-      doInfos.push({ name, className: doInfo.className, scriptPath });
-    }
-    const virtualImports = [];
-    const virtualExports = [];
-    if (transportFile) {
-      const transportPath = join6(configDir5, transportFile);
-      virtualImports.push(`import { transport } from '${transportPath.replace(/\\/g, "/")}'`);
-      virtualExports.push("export { transport }");
-    }
-    for (const info of doInfos) {
-      virtualImports.push(`import { ${info.className} } from '${info.scriptPath.replace(/\\/g, "/")}'`);
-      virtualExports.push(`export { ${info.className} }`);
-    }
-    let bundledCode = "";
-    if (virtualImports.length > 0) {
-      const virtualEntry = [...virtualImports, "", ...virtualExports].join(`
-`);
-      const virtualPath = join6(configDir5, ".devflare", "__test_entry.ts");
-      const { writeFileSync, mkdirSync } = await import("fs");
-      mkdirSync(dirname2(virtualPath), { recursive: true });
-      writeFileSync(virtualPath, virtualEntry);
-      const bun = getBunRuntime2();
-      if (!bun) {
-        throw new Error("Bun runtime is required for createTestContext with Durable Objects");
-      }
-      const result = await bun.build({
-        entrypoints: [virtualPath],
-        target: "browser",
-        format: "esm",
-        minify: false,
-        external: ["cloudflare:workers", "cloudflare:*"]
-      });
-      if (!result.success) {
-        throw new Error(`Failed to bundle test entry: ${result.logs.join(`
-`)}`);
-      }
-      bundledCode = await result.outputs[0].text();
-    }
-    mfConfig.durableObjects = doConfig;
-    mfConfig.script = buildGatewayScript(bundledCode, "");
-  } else {
-    mfConfig.script = buildGatewayScript("", "");
-  }
-  const hasMultiWorkerServices = serviceBindingResolution && serviceBindingResolution.workers.length > 0;
-  const hasMultiWorkerDOs = doBindingResolution && doBindingResolution.workers.length > 0;
-  if (hasMultiWorkerServices || hasMultiWorkerDOs) {
-    const primaryDurableObjects = {
-      ...mfConfig.durableObjects || {},
-      ...doBindingResolution?.crossWorkerDOBindings || {}
-    };
-    const primaryWorker = {
-      name: config.name ?? "primary",
-      modules: true,
-      script: mfConfig.script,
-      compatibilityDate: config.compatibilityDate ?? "2025-01-01",
-      ...mfConfig.kvNamespaces && { kvNamespaces: mfConfig.kvNamespaces },
-      ...mfConfig.r2Buckets && { r2Buckets: mfConfig.r2Buckets },
-      ...mfConfig.d1Databases && { d1Databases: mfConfig.d1Databases },
-      ...Object.keys(primaryDurableObjects).length > 0 && { durableObjects: primaryDurableObjects },
-      ...serviceBindingResolution?.primaryServiceBindings && { serviceBindings: serviceBindingResolution.primaryServiceBindings }
-    };
-    const additionalWorkers = [
-      ...serviceBindingResolution?.workers || [],
-      ...doBindingResolution?.workers || []
-    ];
-    const workersByName = new Map;
-    for (const worker2 of additionalWorkers) {
-      if (!workersByName.has(worker2.name)) {
-        workersByName.set(worker2.name, worker2);
-      } else {
-        const existing = workersByName.get(worker2.name);
-        if (worker2.durableObjects) {
-          existing.durableObjects = {
-            ...existing.durableObjects || {},
-            ...worker2.durableObjects
-          };
-        }
-      }
-    }
-    const workers = [primaryWorker, ...workersByName.values()];
-    delete mfConfig.script;
-    delete mfConfig.modules;
-    delete mfConfig.kvNamespaces;
-    delete mfConfig.r2Buckets;
-    delete mfConfig.d1Databases;
-    delete mfConfig.durableObjects;
-    mfConfig.workers = workers;
-  }
-  const { Miniflare } = await import("miniflare");
-  globalMiniflare = new Miniflare(mfConfig);
-  await globalMiniflare.ready;
-  globalMiniflareBindings = await globalMiniflare.getBindings();
-  const disposeContext = async () => {
-    if (globalClient) {
-      await globalClient.disconnect();
-      globalClient = null;
-    }
-    if (globalMiniflare) {
-      await globalMiniflare.dispose();
-      globalMiniflare = null;
-    }
-    globalEnvProxy = null;
-    globalTransportDecode = null;
-    globalRemoteBindings = null;
-    globalMiniflareBindings = null;
-    resetQueueState();
-    resetScheduledState();
-    resetWorkerState();
-    resetTailState();
-    resetEmailState();
-    __clearTestContext();
-  };
-  const getTestEnv = () => {
-    if (globalMiniflareBindings)
-      return globalMiniflareBindings;
-    if (globalRemoteBindings)
-      return globalRemoteBindings;
-    if (globalEnvProxy)
-      return globalEnvProxy;
-    return {};
-  };
-  const queuePath = config.files?.queue;
-  const scheduledPath = config.files?.scheduled;
-  const fetchPath = config.files?.fetch;
-  const DEFAULT_FETCH_PATH = "src/fetch.ts";
-  const DEFAULT_QUEUE_PATH = "src/queue.ts";
-  const DEFAULT_SCHEDULED_PATH = "src/scheduled.ts";
-  const resolvePath = async (configValue, defaultPath) => {
-    if (typeof configValue === "string")
-      return configValue;
-    if (configValue === false)
-      return null;
-    const defaultAbsolute = join6(configDir5, defaultPath);
-    try {
-      const fs = await import("fs/promises");
-      await fs.access(defaultAbsolute);
-      return defaultPath;
-    } catch {
-      return null;
-    }
-  };
-  const [resolvedFetchPath, resolvedQueuePath, resolvedScheduledPath] = await Promise.all([
-    resolvePath(fetchPath, DEFAULT_FETCH_PATH),
-    resolvePath(queuePath, DEFAULT_QUEUE_PATH),
-    resolvePath(scheduledPath, DEFAULT_SCHEDULED_PATH)
-  ]);
-  configureQueue({
-    handlerPath: resolvedQueuePath,
-    configDir: configDir5,
-    getEnv: getTestEnv
-  });
-  configureScheduled({
-    handlerPath: resolvedScheduledPath,
-    configDir: configDir5,
-    getEnv: getTestEnv
-  });
-  configureWorker({
-    handlerPath: resolvedFetchPath,
-    configDir: configDir5,
-    getEnv: getTestEnv
-  });
-  configureTail({
-    handlerPath: null,
-    configDir: configDir5,
-    getEnv: getTestEnv
-  });
-  configureEmail({ port: randomPort });
-  if (hasMultiWorkerServices || hasMultiWorkerDOs) {
-    setBindingHints(hints);
-    const envAccessor2 = new Proxy({}, {
-      get(_, prop) {
-        if (globalRemoteBindings && prop in globalRemoteBindings) {
-          return globalRemoteBindings[prop];
-        }
-        if (globalMiniflareBindings && prop in globalMiniflareBindings) {
-          return globalMiniflareBindings[prop];
-        }
-        return;
-      },
-      has(_, prop) {
-        return Boolean(globalRemoteBindings && prop in globalRemoteBindings || globalMiniflareBindings && prop in globalMiniflareBindings);
-      }
-    });
-    __setTestContext(envAccessor2, disposeContext);
-    return;
-  }
-  globalClient = new BridgeClient({
-    url: `ws://localhost:${randomPort}`
-  });
-  await globalClient.connect();
-  setBindingHints(hints);
-  globalEnvProxy = createEnvProxy({
-    client: globalClient,
-    transformResult: (result) => decodeTransport(result)
-  });
-  const envAccessor = new Proxy({}, {
-    get(_, prop) {
-      if (globalRemoteBindings && prop in globalRemoteBindings) {
-        return globalRemoteBindings[prop];
-      }
-      if (globalMiniflareBindings && prop in globalMiniflareBindings) {
-        return globalMiniflareBindings[prop];
-      }
-      if (globalEnvProxy) {
-        return globalEnvProxy[prop];
-      }
-      return;
-    },
-    has(_, prop) {
-      return Boolean(globalRemoteBindings && prop in globalRemoteBindings || globalMiniflareBindings && prop in globalMiniflareBindings || globalEnvProxy !== null);
-    }
-  });
-  __setTestContext(envAccessor, disposeContext);
-}
-function decodeTransport(value) {
-  if (!globalTransportDecode || value === null || typeof value !== "object") {
-    return value;
-  }
-  if ("__transport" in value) {
-    const encoded = value;
-    const decoder = globalTransportDecode.get(encoded.__transport);
-    if (decoder) {
-      return decoder(encoded.value);
-    }
-  }
-  if (Array.isArray(value)) {
-    return value.map(decodeTransport);
-  }
-  const result = {};
-  for (const [k, v] of Object.entries(value)) {
-    result[k] = decodeTransport(v);
-  }
-  return result;
-}
-function buildGatewayScript(bundledCode, wrappers) {
-  return `
-// Bundled transport + DO classes
-${bundledCode}
-
-// DO Wrappers with RPC
-${wrappers}
-
-// Transport encoding helper
-const __transportEncoders = typeof transport !== 'undefined' ? transport : {}
-
-function __encodeTransport(value) {
-	if (value === null || value === undefined) return value
-	
-	// Try each encoder
-	for (const [typeName, transporter] of Object.entries(__transportEncoders)) {
-		const encoded = transporter.encode(value)
-		if (encoded !== false && encoded !== undefined) {
-			return { __transport: typeName, value: encoded }
-		}
-	}
-	
-	// Recursively encode arrays and objects
-	if (Array.isArray(value)) {
-		return value.map(__encodeTransport)
-	}
-	if (typeof value === 'object') {
-		const result = {}
-		for (const [k, v] of Object.entries(value)) {
-			result[k] = __encodeTransport(v)
-		}
-		return result
-	}
-	
-	return value
-}
-
-// Gateway with WebSocket RPC
-export default {
-	async fetch(request, env) {
-		if (request.headers.get('Upgrade') === 'websocket') {
-			const { 0: client, 1: server } = new WebSocketPair()
-			server.accept()
-			server.addEventListener('message', async (e) => {
-				try {
-					const m = JSON.parse(e.data)
-					if (m.t === 'rpc.call') {
-						const result = await executeRpc(env, m.method, m.params)
-						server.send(JSON.stringify({ t: 'rpc.ok', id: m.id, result }))
-					}
-				} catch (error) {
-					server.send(JSON.stringify({ t: 'rpc.err', id: 'unknown', error: { code: 'RPC_ERROR', message: error.message } }))
-				}
-			})
-			return new Response(null, { status: 101, webSocket: client })
-		}
-		return new Response('Gateway')
-	}
-}
-
-async function executeRpc(env, method, params) {
-	const [bindingName, ...rest] = method.split('.')
-	const op = rest.join('.')
-	const binding = env[bindingName]
-	if (!binding) throw new Error('Binding not found: ' + bindingName)
-
-	// KV operations
-	if (op === 'get') return binding.get(params[0], params[1])
-	if (op === 'put') return binding.put(params[0], params[1], params[2])
-	if (op === 'delete') return binding.delete(params[0])
-	if (op === 'list') return binding.list(params[0])
-	if (op === 'getWithMetadata') return binding.getWithMetadata(params[0], params[1])
-
-	// R2 operations
-	if (op === 'r2.get') return binding.get(params[0], params[1])
-	if (op === 'r2.put') return binding.put(params[0], params[1], params[2])
-	if (op === 'r2.delete') return binding.delete(params[0])
-	if (op === 'r2.list') return binding.list(params[0])
-	if (op === 'head') return binding.head(params[0])
-
-	// D1 operations
-	if (op === 'exec') return binding.exec(params[0])
-	if (op === 'dump') return binding.dump()
-	if (op === 'batch') {
-		const stmts = params[0].map(s => {
-			const stmt = binding.prepare(s.sql)
-			return s.bindings?.length ? stmt.bind(...s.bindings) : stmt
-		})
-		return binding.batch(stmts)
-	}
-	if (op === 'prepare.run') return binding.prepare(params[0]).bind(...(params[1] || [])).run()
-	if (op === 'prepare.all') return binding.prepare(params[0]).bind(...(params[1] || [])).all()
-	if (op === 'prepare.first') return binding.prepare(params[0]).bind(...(params[1] || [])).first(params[2])
-	if (op === 'prepare.raw') return binding.prepare(params[0]).bind(...(params[1] || [])).raw({ columnNames: params[2] })
-
-	// DO operations
-	if (op === 'idFromName') {
-		return { __type: 'DOId', hex: binding.idFromName(params[0]).toString() }
-	}
-	if (op === 'stub.rpc') {
-		const [, idSerialized, rpcMethod, rpcParams] = params
-		const stub = binding.get(binding.idFromString(idSerialized.hex))
-		
-		// Use native RPC: call method directly on stub
-		// This works for DOs extending DurableObject from cloudflare:workers
-		let result = await stub[rpcMethod](...(rpcParams || []))
-		// Apply transport encoding
-		result = __encodeTransport(result)
-		return result
-	}
-
-	throw new Error('Unknown operation: ' + method)
-}
-`;
-}
-// src/test/cf.ts
-var cf = {
-  email,
-  queue,
-  scheduled,
-  worker,
-  tail
-};
-// src/test/multi-worker-context.ts
-async function createMultiWorkerContext(options) {
-  const { workers, primary } = options;
-  const primaryName = primary ?? workers[0]?.name;
-  if (!primaryName) {
-    throw new Error("At least one worker must be configured");
-  }
-  const { Miniflare } = await import("miniflare");
-  const mfWorkers = workers.map((worker2) => {
-    const serviceBindings = {};
-    if (worker2.serviceBindings) {
-      for (const [bindingName, target] of Object.entries(worker2.serviceBindings)) {
-        if (typeof target === "string") {
-          serviceBindings[bindingName] = { name: target };
-        } else {
-          serviceBindings[bindingName] = target;
-        }
-      }
-    }
-    return {
-      name: worker2.name,
-      modules: worker2.modules ?? true,
-      script: worker2.script,
-      compatibilityDate: worker2.compatibilityDate ?? "2025-01-01",
-      ...Object.keys(serviceBindings).length > 0 ? { serviceBindings } : {}
-    };
-  });
-  const mf = new Miniflare({
-    workers: mfWorkers
-  });
-  const env2 = await mf.getBindings();
-  const fetch3 = async (input, init) => {
-    const response = await mf.dispatchFetch(input, init);
-    return response;
-  };
-  const dispose = async () => {
-    await new Promise((r) => setTimeout(r, 50));
-    await mf.dispose();
-  };
-  return {
-    mf,
-    env: env2,
-    fetch: fetch3,
-    dispose
-  };
-}
-function createEntrypointScript(className, methods) {
-  const methodDefs = Object.entries(methods).map(([name, body]) => `	${name}${body}`).join(`
-
-`);
-  return `import { WorkerEntrypoint } from 'cloudflare:workers'
-
-export class ${className} extends WorkerEntrypoint {
-${methodDefs}
-}
-`;
-}
-// src/test/should-skip.ts
-var REMOTE_ONLY_SERVICES = new Set([
-  "ai",
-  "vectorize"
-]);
-function isRemoteModeEnabled() {
-  return isRemoteModeActive();
-}
-var skipResults = new Map;
-var EXPECTED_ERROR_PATTERNS = [
-  "ECONNREFUSED",
-  "ETIMEDOUT",
-  "ENOTFOUND",
-  "fetch failed",
-  "network",
-  "401",
-  "403",
-  "429",
-  "500",
-  "502",
-  "503",
-  "504",
-  "rate limit",
-  "unauthorized",
-  "forbidden",
-  "timeout"
-];
-function isExpectedError(error) {
-  if (!(error instanceof Error))
-    return false;
-  const msg = error.message.toLowerCase();
-  return EXPECTED_ERROR_PATTERNS.some((pattern) => msg.includes(pattern.toLowerCase()));
-}
-async function computeSkip(service) {
-  try {
-    if (REMOTE_ONLY_SERVICES.has(service) && !isRemoteModeActive()) {
-      const status = getRemoteModeStatus();
-      console.log(`⏭️  ${service.toUpperCase()} tests skipped: Remote-only service.
-` + `   Enable with: ${status.isEnabled ? "" : "devflare remote enable"}
-` + `   Or set: DEVFLARE_REMOTE=1
-` + `   See: https://github.com/ArthurvdVenne/devflare#remote-testing`);
-      return true;
-    }
-    const isAuth = await isAuthenticated();
-    if (!isAuth) {
-      console.log(`⏭️  ${service.toUpperCase()} tests skipped: Not authenticated. Run: bunx wrangler login
-` + `   See: https://github.com/ArthurvdVenne/devflare#authentication`);
-      return true;
-    }
-    const primary = await getPrimaryAccount();
-    if (!primary) {
-      console.log(`⏭️  ${service.toUpperCase()} tests skipped: No Cloudflare account found
-` + `   See: https://github.com/ArthurvdVenne/devflare#authentication`);
-      return true;
-    }
-    const { accountId } = await getEffectiveAccountId(primary.id);
-    try {
-      const { allowed, reason } = await canProceedWithTest(accountId, service);
-      if (!allowed) {
-        console.log(`⏭️  ${service.toUpperCase()} tests skipped: ${reason}`);
-        return true;
-      }
-    } catch {}
-    return false;
-  } catch (error) {
-    if (isExpectedError(error)) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      console.log(`⏭️  ${service.toUpperCase()} tests skipped: ${message}`);
-      return true;
-    }
-    throw error;
-  }
-}
-function getSkipResult(service) {
-  let result = skipResults.get(service);
-  if (!result) {
-    result = computeSkip(service);
-    skipResults.set(service, result);
-  }
-  return result;
-}
-var shouldSkip = {
-  get ai() {
-    return getSkipResult("ai");
-  },
-  get vectorize() {
-    return getSkipResult("vectorize");
-  },
-  get workers() {
-    return getSkipResult("workers");
-  },
-  get kv() {
-    return getSkipResult("kv");
-  },
-  get d1() {
-    return getSkipResult("d1");
-  },
-  get r2() {
-    return getSkipResult("r2");
-  },
-  get queues() {
-    return getSkipResult("queues");
-  },
-  get durableObjects() {
-    return getSkipResult("durable_objects");
-  }
-};
-// src/test/utilities.ts
-function createMockTestContext(options = {}) {
-  const waitUntilPromises = [];
-  const ctx = {
-    waitUntil(promise) {
-      waitUntilPromises.push(promise);
-    },
-    passThroughOnException() {},
-    props: {}
-  };
-  return {
-    env: options.env ?? {},
-    ctx,
-    request: options.request ?? null,
-    waitUntilPromises
-  };
-}
-async function withTestContext(options, handler) {
-  const testCtx = createMockTestContext(options);
-  return runWithContext(testCtx.env, testCtx.ctx, options.request ?? null, handler, options.type ?? "fetch");
-}
-function createMockKV(initialData = {}) {
-  const store = new Map(Object.entries(initialData));
-  const metadata = new Map;
-  return {
-    async get(key, options) {
-      const value = store.get(key);
-      if (value === null || value === undefined)
-        return null;
-      const type = typeof options === "string" ? options : options?.type ?? "text";
-      switch (type) {
-        case "json":
-          return JSON.parse(value);
-        case "arrayBuffer":
-          return new TextEncoder().encode(value).buffer;
-        case "stream":
-          return new ReadableStream({
-            start(controller) {
-              controller.enqueue(new TextEncoder().encode(value));
-              controller.close();
-            }
-          });
-        default:
-          return value;
-      }
-    },
-    async put(key, value, options) {
-      if (typeof value === "string") {
-        store.set(key, value);
-      } else if (value instanceof ArrayBuffer) {
-        store.set(key, new TextDecoder().decode(value));
-      } else {
-        const reader = value.getReader();
-        const chunks = [];
-        let done = false;
-        while (!done) {
-          const result = await reader.read();
-          done = result.done;
-          if (result.value)
-            chunks.push(result.value);
-        }
-        const combined = new Uint8Array(chunks.reduce((acc, c) => acc + c.length, 0));
-        let offset = 0;
-        for (const chunk of chunks) {
-          combined.set(chunk, offset);
-          offset += chunk.length;
-        }
-        store.set(key, new TextDecoder().decode(combined));
-      }
-    },
-    async delete(key) {
-      store.delete(key);
-    },
-    async list(options) {
-      const prefix = options?.prefix ?? "";
-      const limit = options?.limit ?? 1000;
-      const keys = Array.from(store.keys()).filter((key) => key.startsWith(prefix)).slice(0, limit).map((name) => ({ name }));
-      return {
-        keys,
-        list_complete: keys.length < limit,
-        cursor: undefined
-      };
-    },
-    async getWithMetadata(key, options) {
-      return {
-        value: store.get(key) ?? null,
-        metadata: metadata.get(key) ?? null
-      };
-    }
-  };
-}
-function createMockD1(mockResults = []) {
-  let boundValues = [];
-  let currentResults = [...mockResults];
-  const createStatement = () => ({
-    bind(...values) {
-      boundValues = values;
-      return this;
-    },
-    async first(column) {
-      const row = currentResults[0];
-      if (!row)
-        return null;
-      if (column)
-        return row[column];
-      return row;
-    },
-    async all() {
-      return {
-        results: currentResults,
-        success: true,
-        meta: { duration: 0, changes: 0, last_row_id: 0 }
-      };
-    },
-    async run() {
-      return {
-        results: [],
-        success: true,
-        meta: { duration: 0, changes: 1, last_row_id: 1 }
-      };
-    },
-    async raw(options) {
-      return currentResults.map((row) => Object.values(row));
-    }
-  });
-  return {
-    prepare(query) {
-      return createStatement();
-    },
-    async exec(query) {
-      return {
-        results: [],
-        success: true,
-        meta: { duration: 0, changes: 0, last_row_id: 0 }
-      };
-    },
-    async batch(statements) {
-      return statements.map(() => ({
-        results: [],
-        success: true,
-        meta: { duration: 0, changes: 0, last_row_id: 0 }
-      }));
-    },
-    async dump() {
-      return new ArrayBuffer(0);
-    },
-    withSession(constraintOrBookmark) {
-      return this;
-    }
-  };
-}
-function createMockR2() {
-  const store = new Map;
-  const createR2Object = (key, content, metadata) => {
-    const encoder = new TextEncoder;
-    const data = encoder.encode(content);
-    return {
-      key,
-      version: "1",
-      size: data.length,
-      etag: `"${key}-etag"`,
-      httpEtag: `"${key}-etag"`,
-      uploaded: new Date,
-      httpMetadata: metadata ?? {},
-      customMetadata: {},
-      checksums: {},
-      storageClass: "Standard",
-      body: new ReadableStream({
-        start(controller) {
-          controller.enqueue(data);
-          controller.close();
-        }
-      }),
-      bodyUsed: false,
-      async arrayBuffer() {
-        return new Uint8Array(data).buffer;
-      },
-      async text() {
-        return content;
-      },
-      async json() {
-        return JSON.parse(content);
-      },
-      async blob() {
-        return new Blob([data]);
-      },
-      writeHttpMetadata(headers) {}
-    };
-  };
-  return {
-    async put(key, value, options) {
-      let content;
-      if (typeof value === "string") {
-        content = value;
-      } else if (value instanceof ArrayBuffer) {
-        content = new TextDecoder().decode(value);
-      } else if (value instanceof Blob) {
-        content = await value.text();
-      } else if (value === null) {
-        content = "";
-      } else {
-        const reader = value.getReader();
-        const chunks = [];
-        let done = false;
-        while (!done) {
-          const result = await reader.read();
-          done = result.done;
-          if (result.value) {
-            chunks.push(new TextDecoder().decode(result.value));
-          }
-        }
-        content = chunks.join("");
-      }
-      store.set(key, { content });
-      return createR2Object(key, content);
-    },
-    async get(key, options) {
-      const item = store.get(key);
-      if (!item)
-        return null;
-      return createR2Object(key, item.content, item.metadata);
-    },
-    async head(key) {
-      const item = store.get(key);
-      if (!item)
-        return null;
-      return {
-        key,
-        version: "1",
-        size: new TextEncoder().encode(item.content).length,
-        etag: `"${key}-etag"`,
-        httpEtag: `"${key}-etag"`,
-        uploaded: new Date,
-        httpMetadata: item.metadata ?? {},
-        customMetadata: {},
-        checksums: {},
-        storageClass: "Standard",
-        writeHttpMetadata(headers) {}
-      };
-    },
-    async delete(keys) {
-      const keyArray = Array.isArray(keys) ? keys : [keys];
-      for (const key of keyArray) {
-        store.delete(key);
-      }
-    },
-    async list(options) {
-      const objects = Array.from(store.entries()).map(([key, { content, metadata }]) => createR2Object(key, content, metadata));
-      return {
-        objects,
-        truncated: false,
-        delimitedPrefixes: []
-      };
-    },
-    async createMultipartUpload(key, options) {
-      throw new Error("Multipart upload not implemented in mock");
-    },
-    async resumeMultipartUpload(key, uploadId) {
-      throw new Error("Multipart upload not implemented in mock");
-    }
-  };
-}
-function createMockQueue() {
-  const messages = [];
-  return {
-    async send(message, options) {
-      messages.push({ body: message, options });
-    },
-    async sendBatch(batch) {
-      messages.push(...batch);
-    },
-    _getMessages() {
-      return messages;
-    }
-  };
-}
-function createMockEnv(options = {}) {
-  const env2 = {};
-  if (options.kv) {
-    for (const name of options.kv) {
-      env2[name] = createMockKV();
-    }
-  }
-  if (options.d1) {
-    for (const name of options.d1) {
-      env2[name] = createMockD1();
-    }
-  }
-  if (options.r2) {
-    for (const name of options.r2) {
-      env2[name] = createMockR2();
-    }
-  }
-  if (options.queues) {
-    for (const name of options.queues) {
-      env2[name] = createMockQueue();
-    }
-  }
-  if (options.vars) {
-    Object.assign(env2, options.vars);
-  }
-  if (options.secrets) {
-    Object.assign(env2, options.secrets);
-  }
-  if (options.custom) {
-    Object.assign(env2, options.custom);
-  }
-  return env2;
-}
-// src/test/bridge-context.ts
-var globalTestContext = null;
-async function createBridgeTestContext(options = {}) {
-  if (globalTestContext) {
-    await globalTestContext.stop();
-  }
-  let config = options.config;
-  if (options.configPath && !config) {
-    config = await loadConfig({ cwd: options.configPath.replace(/[/\\][^/\\]+$/, ""), configFile: options.configPath.split(/[/\\]/).pop() });
-  }
-  let miniflare;
-  if (config) {
-    miniflare = await startMiniflareFromConfig(config, {
-      ...options.miniflare,
-      port: options.port ?? 8787,
-      persist: options.persist ?? false,
-      verbose: options.verbose ?? false
-    });
-  } else {
-    miniflare = await startMiniflare({
-      ...options.miniflare,
-      port: options.port ?? 8787,
-      persist: options.persist ?? false,
-      verbose: options.verbose ?? false
-    });
-  }
-  const bindings = await miniflare.getBindings();
-  if (config?.bindings) {
-    const hints = {};
-    if (config.bindings.kv) {
-      Object.keys(config.bindings.kv).forEach((name) => {
-        hints[name] = "kv";
-      });
-    }
-    if (config.bindings.r2) {
-      Object.keys(config.bindings.r2).forEach((name) => {
-        hints[name] = "r2";
-      });
-    }
-    if (config.bindings.d1) {
-      Object.keys(config.bindings.d1).forEach((name) => {
-        hints[name] = "d1";
-      });
-    }
-    if (config.bindings.durableObjects) {
-      Object.keys(config.bindings.durableObjects).forEach((name) => {
-        hints[name] = "do";
-      });
-    }
-    if (config.bindings.queues?.consumers) {
-      config.bindings.queues.consumers.forEach((c) => {
-        hints[c.queue] = "queue";
-      });
-    }
-    if (config.bindings.ai)
-      hints[config.bindings.ai.binding] = "ai";
-    setBindingHints(hints);
-  }
-  const ctx = {
-    env: bindings,
-    miniflare,
-    async stop() {
-      await miniflare.dispose();
-      globalTestContext = null;
-    },
-    async reset() {
-      for (const [name, binding] of Object.entries(bindings)) {
-        if (isKVNamespace(binding)) {
-          const kv = binding;
-          const { keys } = await kv.list();
-          for (const key of keys) {
-            await kv.delete(key.name);
-          }
-        }
-      }
-    }
-  };
-  globalTestContext = ctx;
-  return ctx;
-}
-async function stopBridgeTestContext() {
-  if (globalTestContext) {
-    await globalTestContext.stop();
-  }
-}
-function getBridgeTestContext() {
-  if (!globalTestContext) {
-    throw new Error("Bridge test context not initialized. Call createBridgeTestContext() in beforeAll().");
-  }
-  return globalTestContext;
-}
-var testEnv = new Proxy({}, {
-  get(target, prop) {
-    if (typeof prop !== "string")
-      return;
-    const ctx = getBridgeTestContext();
-    return ctx.env[prop];
-  }
-});
-function isKVNamespace(binding) {
-  return typeof binding === "object" && binding !== null && "get" in binding && "put" in binding && "delete" in binding && "list" in binding;
-}
-export { clearBundleCache, hasServiceBindings, resolveServiceBindings, hasCrossWorkerDOs, resolveDOBindings, queue, scheduled, worker, tail, email, createTestContext, cf, createMultiWorkerContext, createEntrypointScript, isRemoteModeEnabled, shouldSkip, createMockTestContext, withTestContext, createMockKV, createMockD1, createMockR2, createMockQueue, createMockEnv, createBridgeTestContext, stopBridgeTestContext, getBridgeTestContext, testEnv };