devflare 1.0.0-next.20 → 1.0.0-next.22

package/dist/test/index.js

@@ -2,47 +2,41 @@ import {
   getRemoteModeStatus,
   isRemoteModeActive
 } from "../index-d8bdkx2h.js";
-import {
-  discoverEntrypointsSync
-} from "../index-gj5qh491.js";
-import {
-  resolvePackageSpecifier
-} from "../index-t4fhcx1n.js";
 import {
   canProceedWithTest
 } from "../index-15fpa5tx.js";
 import {
-  transformWorkerEntrypoint
-} from "../index-7k278fgz.js";
-import {
-  buildHyperdrivesConfig,
   bundleWorkflowEntrypointScript
-} from "../index-01kehw41.js";
-import"../index-gq39t0rx.js";
+} from "../index-zawn5tte.js";
+import"../index-w36q6819.js";
 import {
   createRouteResolve,
   invokeFetchModule,
   matchFetchRoute,
   resolveFetchHandler
-} from "../index-fnk0tkw7.js";
+} from "../index-jwd3fanx.js";
 import {
   __clearTestContext,
   __setTestContext,
   env
-} from "../index-0wa0ebm1.js";
+} from "../index-xp0qkkxf.js";
 import"../index-a855bdsx.js";
 import {
-  discoverRoutes
-} from "../index-qf2dkqxh.js";
+  buildHyperdrivesConfig,
+  clearBundleCache,
+  discoverRoutes,
+  hasCrossWorkerDOs,
+  hasServiceBindings,
+  resolveDOBindings,
+  resolveServiceBindings
+} from "../index-s9q605sq.js";
+import"../index-3edvz3hs.js";
 import {
   DEFAULT_DO_PATTERN,
-  findFiles,
-  findFilesSync
+  findFiles
 } from "../index-qwgr4q7s.js";
-import"../index-65e7xx1a.js";
-import {
-  findDurableObjectClasses
-} from "../index-vhqww6tt.js";
+import"../index-aqrwyy57.js";
+import"../index-vhqww6tt.js";
 import {
   createLocalWorkerLoaderBinding,
   disposeLocalWorkerLoaderBindings,
@@ -66,11 +60,11 @@ import {
   runWithContext,
   runWithEventContext,
   setBindingHints
-} from "../index-vrps1gky.js";
+} from "../index-c1cj9085.js";
 import {
   createLocalSendEmailBinding,
   wrapEnvSendEmailBindings
-} from "../index-kgstnk6g.js";
+} from "../index-hpwa6vsw.js";
 import {
   applyLocalDevVarsToConfig
 } from "../index-c3nxftnp.js";
@@ -103,382 +97,10 @@ import {
   __require
 } from "../index-37x76zdn.js";
 
-// src/test/resolve-service-bindings.ts
-import { dirname, join, resolve } from "path";
-import { existsSync, readFileSync } from "fs";
-function getBunRuntime() {
-  const g = globalThis;
-  if (typeof g.Bun === "object" && g.Bun !== null) {
-    return g.Bun;
-  }
-  return;
-}
-function discoverDOFilesSync(dir) {
-  const classToPath = new Map;
-  try {
-    const files = findFilesSync(DEFAULT_DO_PATTERN, { cwd: dir });
-    for (const filePath of files) {
-      try {
-        const code = readFileSync(filePath, "utf-8");
-        const classNames = findDurableObjectClasses(code);
-        for (const className of classNames) {
-          if (!classToPath.has(className)) {
-            classToPath.set(className, filePath);
-          }
-        }
-      } catch {}
-    }
-  } catch {}
-  return classToPath;
-}
-var bundleCache = new Map;
-function clearBundleCache() {
-  bundleCache.clear();
-}
-function findDefaultServiceWorkerEntrypoint(refConfigDir) {
-  for (const candidate of ["src/worker.ts", "src/worker.js"]) {
-    const absolutePath = resolve(refConfigDir, candidate);
-    if (existsSync(absolutePath)) {
-      return absolutePath;
-    }
-  }
-  return null;
-}
-function hasServiceBindings(config) {
-  const services = config.bindings?.services;
-  if (!services)
-    return false;
-  return Object.keys(services).length > 0;
-}
-async function resolveServiceBindings(config, configDir) {
-  const services = config.bindings?.services;
-  if (!services) {
-    return { workers: [], primaryServiceBindings: {} };
-  }
-  const workersByName = new Map;
-  const primaryServiceBindings = {};
-  for (const [bindingName, binding] of Object.entries(services)) {
-    const workerBinding = binding;
-    const ref = workerBinding.__ref;
-    if (ref) {
-      if ("__import" in ref && typeof ref.__import === "function") {
-        await ref.resolve();
-      }
-      const workerName = ref.name;
-      const entrypoint = workerBinding.entrypoint;
-      if (!workersByName.has(workerName)) {
-        const worker = await resolveRefWorker(ref, entrypoint, configDir);
-        if (worker) {
-          workersByName.set(workerName, worker);
-        }
-      }
-      primaryServiceBindings[bindingName] = {
-        name: workerName,
-        ...entrypoint && { entrypoint }
-      };
-    } else {
-      primaryServiceBindings[bindingName] = {
-        name: workerBinding.service,
-        ...workerBinding.entrypoint && { entrypoint: workerBinding.entrypoint }
-      };
-    }
-  }
-  return {
-    workers: [...workersByName.values()],
-    primaryServiceBindings
-  };
-}
-async function resolveRefWorker(ref, _entrypoint, parentConfigDir) {
-  const config = ref.config;
-  if (!config)
-    return null;
-  const configPath = ref.configPath;
-  if (!configPath || configPath === "<resolved>") {
-    console.warn(`[devflare] Cannot resolve worker "${ref.name}" - configPath not available`);
-    return null;
-  }
-  const refConfigDir = resolve(parentConfigDir, dirname(configPath));
-  const entrypoints = [];
-  const workerEntrypointPath = findDefaultServiceWorkerEntrypoint(refConfigDir);
-  if (workerEntrypointPath) {
-    entrypoints.push({
-      path: workerEntrypointPath,
-      className: "Worker",
-      isWorkerTs: true
-    });
-  }
-  if (config.files?.entrypoints !== false) {
-    const discoveredEntrypoints = discoverEntrypointsSync(refConfigDir, typeof config.files?.entrypoints === "string" ? config.files.entrypoints : undefined);
-    for (const ep of discoveredEntrypoints) {
-      entrypoints.push({
-        path: ep.filePath,
-        className: ep.className,
-        isWorkerTs: false
-      });
-    }
-  }
-  if (entrypoints.length === 0) {
-    console.warn(`[devflare] Worker "${ref.name}" has no entry points`);
-    return null;
-  }
-  const script = await bundleAllEntrypoints(entrypoints, ref.name);
-  if (!script)
-    return null;
-  return {
-    name: ref.name,
-    script,
-    modules: true,
-    compatibilityDate: config.compatibilityDate ?? "2025-01-01"
-  };
-}
-async function bundleAllEntrypoints(entrypoints, workerName) {
-  const cacheKey = entrypoints.map((ep) => `${ep.path}::${ep.className}`).join("|");
-  const cached = bundleCache.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-  const bun = getBunRuntime();
-  if (!bun) {
-    console.warn("[devflare] Bun runtime required for bundling worker scripts");
-    return null;
-  }
-  try {
-    const { readFileSync: readFileSync2, writeFileSync, mkdirSync, unlinkSync } = await import("fs");
-    const imports = [];
-    const exports = [];
-    let defaultExportClass = null;
-    for (let i = 0;i < entrypoints.length; i++) {
-      const ep = entrypoints[i];
-      const sourceCode = readFileSync2(ep.path, "utf-8");
-      if (ep.isWorkerTs) {
-        const result = transformWorkerEntrypoint(sourceCode, ep.path, {
-          className: ep.className,
-          injectContext: false
-        });
-        if (result) {
-          const tempDir2 = join(dirname(ep.path), ".devflare");
-          mkdirSync(tempDir2, { recursive: true });
-          const tempPath = join(tempDir2, `__${ep.className}_${i}.ts`);
-          writeFileSync(tempPath, result.code);
-          imports.push(`import { ${ep.className} } from '${tempPath.replace(/\\/g, "/")}'`);
-          exports.push(ep.className);
-          if (!defaultExportClass) {
-            defaultExportClass = ep.className;
-          }
-        }
-      } else {
-        imports.push(`import { ${ep.className} } from '${ep.path.replace(/\\/g, "/")}'`);
-        exports.push(ep.className);
-      }
-    }
-    const defaultExport = defaultExportClass ? `
-export default ${defaultExportClass}` : "";
-    const entryCode = `
-${imports.join(`
-`)}
-export { ${exports.join(", ")} }${defaultExport}
-`;
-    const tempDir = join(dirname(entrypoints[0].path), ".devflare");
-    mkdirSync(tempDir, { recursive: true });
-    const entryPath = join(tempDir, `__entry_${workerName}.ts`);
-    writeFileSync(entryPath, entryCode);
-    try {
-      const result = await bun.build({
-        entrypoints: [entryPath],
-        target: "browser",
-        format: "esm",
-        minify: false,
-        external: ["cloudflare:workers", "cloudflare:*"]
-      });
-      if (!result.success) {
-        console.warn(`[devflare] Failed to bundle worker "${workerName}": ${result.logs.join(`
-`)}`);
-        return null;
-      }
-      const bundledCode = await result.outputs[0].text();
-      bundleCache.set(cacheKey, bundledCode);
-      return bundledCode;
-    } finally {
-      try {
-        unlinkSync(entryPath);
-      } catch {}
-    }
-  } catch (error) {
-    console.warn(`[devflare] Error bundling worker "${workerName}":`, error);
-    return null;
-  }
-}
-function hasCrossWorkerDOs(config) {
-  const dos = config.bindings?.durableObjects;
-  if (!dos)
-    return false;
-  for (const doConfig of Object.values(dos)) {
-    const normalized = normalizeDOBinding(doConfig);
-    if (normalized.__ref)
-      return true;
-  }
-  return false;
-}
-async function resolveDOBindings(config, configDir) {
-  const dos = config.bindings?.durableObjects;
-  if (!dos) {
-    return { workers: [], crossWorkerDOBindings: {} };
-  }
-  const workersByName = new Map;
-  const crossWorkerDOBindings = {};
-  for (const [bindingName, rawDoConfig] of Object.entries(dos)) {
-    const hasRef = typeof rawDoConfig === "object" && "__ref" in rawDoConfig;
-    if (!hasRef) {
-      continue;
-    }
-    const ref = rawDoConfig.__ref;
-    if ("__import" in ref && typeof ref.__import === "function") {
-      await ref.resolve();
-    }
-    const doConfig = normalizeDOBinding(rawDoConfig);
-    const workerName = ref.name;
-    if (!workersByName.has(workerName)) {
-      const worker = await resolveDORefWorker(ref, configDir);
-      if (worker) {
-        workersByName.set(workerName, worker);
-      }
-    }
-    crossWorkerDOBindings[bindingName] = {
-      className: doConfig.className,
-      scriptName: workerName
-    };
-  }
-  return {
-    workers: [...workersByName.values()],
-    crossWorkerDOBindings
-  };
-}
-async function resolveDORefWorker(ref, parentConfigDir) {
-  const config = ref.config;
-  if (!config)
-    return null;
-  const configPath = ref.configPath;
-  if (!configPath || configPath === "<resolved>") {
-    console.warn(`[devflare] Cannot resolve DO worker "${ref.name}" - configPath not available`);
-    return null;
-  }
-  const resolvedConfigPath = resolvePackageSpecifier(configPath, parentConfigDir);
-  const refConfigDir = dirname(resolvedConfigPath);
-  const dosConfig = config.bindings?.durableObjects;
-  if (!dosConfig || Object.keys(dosConfig).length === 0) {
-    console.warn(`[devflare] Referenced worker "${ref.name}" has no Durable Objects`);
-    return null;
-  }
-  const discoveredDOs = discoverDOFilesSync(refConfigDir);
-  const doClasses = [];
-  for (const [bindingName, rawDoConfig] of Object.entries(dosConfig)) {
-    const doConfig = normalizeDOBinding(rawDoConfig);
-    const className = doConfig.className;
-    const scriptName = doConfig.scriptName;
-    if (scriptName) {
-      const scriptPath = resolve(refConfigDir, "src", scriptName);
-      if (!existsSync(scriptPath)) {
-        const altPath = resolve(refConfigDir, scriptName);
-        if (!existsSync(altPath)) {
-          console.warn(`[devflare] DO script not found: ${scriptPath} or ${altPath}`);
-          continue;
-        }
-        doClasses.push({ bindingName, className, scriptPath: altPath });
-      } else {
-        doClasses.push({ bindingName, className, scriptPath });
-      }
-    } else {
-      const discoveredPath = discoveredDOs.get(className);
-      if (discoveredPath) {
-        doClasses.push({ bindingName, className, scriptPath: discoveredPath });
-      } else {
-        console.warn(`[devflare] DO "${bindingName}" (class: ${className}) not found in do.*.ts files in "${ref.name}"`);
-        continue;
-      }
-    }
-  }
-  if (doClasses.length === 0) {
-    console.warn(`[devflare] No valid DO classes found in "${ref.name}"`);
-    return null;
-  }
-  const script = await bundleDOClasses(doClasses, ref.name);
-  if (!script)
-    return null;
-  const durableObjects = {};
-  for (const do_ of doClasses) {
-    durableObjects[do_.bindingName] = do_.className;
-  }
-  return {
-    name: ref.name,
-    script,
-    modules: true,
-    compatibilityDate: config.compatibilityDate ?? "2025-01-01",
-    durableObjects
-  };
-}
-async function bundleDOClasses(doClasses, workerName) {
-  const cacheKey = `do:${doClasses.map((d) => `${d.scriptPath}::${d.className}`).join("|")}`;
-  const cached = bundleCache.get(cacheKey);
-  if (cached)
-    return cached;
-  const bun = getBunRuntime();
-  if (!bun) {
-    console.warn("[devflare] Bun runtime required for bundling DO classes");
-    return null;
-  }
-  try {
-    const { writeFileSync, mkdirSync, unlinkSync } = await import("fs");
-    const imports = doClasses.map((d) => `import { ${d.className} } from '${d.scriptPath.replace(/\\/g, "/")}'`).join(`
-`);
-    const exports = doClasses.map((d) => d.className).join(", ");
-    const entryCode = `
-${imports}
-
-// Re-export DO classes for Miniflare binding
-export { ${exports} }
-
-// Default export with fetch handler
-export default {
-	async fetch(request, env) {
-		return new Response('DO Worker: ${workerName}')
-	}
-}
-`;
-    const tempDir = join(dirname(doClasses[0].scriptPath), ".devflare");
-    mkdirSync(tempDir, { recursive: true });
-    const entryPath = join(tempDir, `__do_entry_${workerName}.ts`);
-    writeFileSync(entryPath, entryCode);
-    try {
-      const result = await bun.build({
-        entrypoints: [entryPath],
-        target: "browser",
-        format: "esm",
-        minify: false,
-        external: ["cloudflare:workers", "cloudflare:*"]
-      });
-      if (!result.success) {
-        console.warn(`[devflare] Failed to bundle DO worker "${workerName}": ${result.logs.join(`
-`)}`);
-        return null;
-      }
-      const bundledCode = await result.outputs[0].text();
-      bundleCache.set(cacheKey, bundledCode);
-      return bundledCode;
-    } finally {
-      try {
-        unlinkSync(entryPath);
-      } catch {}
-    }
-  } catch (error) {
-    console.warn(`[devflare] Error bundling DO worker "${workerName}":`, error);
-    return null;
-  }
-}
-
 // src/test/simple-context-durable-objects.ts
 import { mkdirSync, writeFileSync } from "fs";
 import { readFile } from "fs/promises";
-import { dirname as dirname3, join as join3 } from "path";
+import { dirname as dirname2, join as join2 } from "path";
 
 // src/test/simple-context-gateway-script.ts
 function buildGatewayScript(bundledCode, wrappers, nativeRpcBindingNames = []) {
@@ -695,9 +317,9 @@ function __normalizeEmailMessage(message) {
 }
 
 // src/test/simple-context-paths.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync } from "fs";
 import { createServer } from "net";
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 var DEFAULT_TRANSPORT_ENTRY_FILES = [
   "src/transport.ts",
@@ -705,8 +327,8 @@ var DEFAULT_TRANSPORT_ENTRY_FILES = [
   "src/transport.mts",
   "src/transport.mjs"
 ];
-var CURRENT_PACKAGE_ROOT = findPackageRoot(dirname2(fileURLToPath(import.meta.url)));
-function getBunRuntime2() {
+var CURRENT_PACKAGE_ROOT = findPackageRoot(dirname(fileURLToPath(import.meta.url)));
+function getBunRuntime() {
   const g = globalThis;
   if (typeof g.Bun === "object" && g.Bun !== null) {
     return g.Bun;
@@ -728,8 +350,8 @@ function getStackCallerDirectory() {
     const stack = err.stack;
     for (const site of stack ?? []) {
       const filename = site.getFileName?.();
-      if (filename && !isInsideCurrentPackage(filename) && !filename.includes("simple-context") && !filename.includes("node_modules") && !filename.includes("[") && existsSync2(filename)) {
-        return dirname2(filename);
+      if (filename && !isInsideCurrentPackage(filename) && !filename.includes("simple-context") && !filename.includes("node_modules") && !filename.includes("[") && existsSync(filename)) {
+        return dirname(filename);
       }
     }
   } finally {
@@ -740,10 +362,10 @@ function getStackCallerDirectory() {
 function findPackageRoot(startDir) {
   let currentDir = startDir;
   while (true) {
-    if (existsSync2(join2(currentDir, "package.json"))) {
+    if (existsSync(join(currentDir, "package.json"))) {
       return currentDir;
     }
-    const parentDir = dirname2(currentDir);
+    const parentDir = dirname(currentDir);
     if (parentDir === currentDir) {
       return startDir;
     }
@@ -762,7 +384,7 @@ async function findNearestConfig(startDir) {
     if (configPath) {
       return configPath;
     }
-    const parentDir = dirname2(currentDir);
+    const parentDir = dirname(currentDir);
     if (parentDir === currentDir) {
       return null;
     }
@@ -798,7 +420,7 @@ function resolveTransportFile(configDir, configuredPath) {
     return null;
   }
   for (const defaultEntry of DEFAULT_TRANSPORT_ENTRY_FILES) {
-    if (existsSync2(join2(configDir, defaultEntry))) {
+    if (existsSync(join(configDir, defaultEntry))) {
       return defaultEntry;
     }
   }
@@ -857,7 +479,7 @@ async function resolveLocalDurableObjects(config, configDir) {
     let scriptPath;
     let nativeRpc = false;
     if (doInfo.kind === "cross-worker" && doInfo.scriptName) {
-      scriptPath = join3(configDir, "src", doInfo.scriptName);
+      scriptPath = join2(configDir, "src", doInfo.scriptName);
       try {
         const code = await readFile(scriptPath, "utf-8");
         nativeRpc = classSupportsNativeDurableObjectRpc(code, doInfo.className);
@@ -943,7 +565,7 @@ async function bundleDurableObjectModules(configDir, doInfos, transportFile) {
   const virtualImports = [];
   const virtualExports = [];
   if (transportFile) {
-    const transportPath = join3(configDir, transportFile);
+    const transportPath = join2(configDir, transportFile);
     virtualImports.push(`import { transport } from '${transportPath.replace(/\\/g, "/")}'`);
     virtualExports.push("export { transport }");
   }
@@ -956,10 +578,10 @@ async function bundleDurableObjectModules(configDir, doInfos, transportFile) {
   }
   const virtualEntry = [...virtualImports, "", ...virtualExports].join(`
 `);
-  const virtualPath = join3(configDir, ".devflare", "__test_entry.ts");
-  mkdirSync(dirname3(virtualPath), { recursive: true });
+  const virtualPath = join2(configDir, ".devflare", "__test_entry.ts");
+  mkdirSync(dirname2(virtualPath), { recursive: true });
   writeFileSync(virtualPath, virtualEntry);
-  const bun = getBunRuntime2();
+  const bun = getBunRuntime();
   if (!bun) {
     throw new Error("Bun runtime is required for createTestContext with Durable Objects");
   }
@@ -2159,7 +1781,7 @@ function buildRemoteAndStaticBindings(config) {
 }
 
 // src/test/email.ts
-import { join as join4 } from "path";
+import { join as join3 } from "path";
 var miniflarePort = 8787;
 var emailListeners = [];
 var sentEmails = [];
@@ -2244,7 +1866,7 @@ function getRecordedRawContent(raw) {
 async function send(options) {
   const raw = buildRawEmail(options);
   if (emailHandlerPath && configDir && testEnvGetter) {
-    const absolutePath = join4(configDir, emailHandlerPath);
+    const absolutePath = join3(configDir, emailHandlerPath);
     const handlerModule = await import(absolutePath);
     const emailHandler = resolveEmailHandler(handlerModule);
     if (!emailHandler) {
@@ -2346,7 +1968,7 @@ var email = {
 };
 
 // src/test/queue.ts
-import { join as join5 } from "path";
+import { join as join4 } from "path";
 var queueHandlerPath = null;
 var configDir2 = null;
 var testEnvGetter2 = null;
@@ -2414,7 +2036,7 @@ async function trigger(messages) {
   if (!configDir2 || !testEnvGetter2) {
     throw new Error("Queue helper not initialized. Call createTestContext() before using cf.queue.trigger()");
   }
-  const absolutePath = join5(configDir2, queueHandlerPath);
+  const absolutePath = join4(configDir2, queueHandlerPath);
   const handlerModule = await import(absolutePath);
   const queueHandler = handlerModule.default ?? handlerModule.queue;
   if (typeof queueHandler !== "function") {
@@ -2473,7 +2095,7 @@ var queue2 = {
 };
 
 // src/test/scheduled.ts
-import { join as join6 } from "path";
+import { join as join5 } from "path";
 var scheduledHandlerPath = null;
 var configDir3 = null;
 var testEnvGetter3 = null;
@@ -2497,7 +2119,7 @@ async function trigger2(cronOrOptions) {
   const options = typeof cronOrOptions === "string" ? { cron: cronOrOptions } : cronOrOptions ?? {};
   const cron = options.cron ?? "* * * * *";
   const scheduledTime = options.scheduledTime instanceof Date ? options.scheduledTime.getTime() : options.scheduledTime ?? Date.now();
-  const absolutePath = join6(configDir3, scheduledHandlerPath);
+  const absolutePath = join5(configDir3, scheduledHandlerPath);
   const handlerModule = await import(absolutePath);
   const scheduledHandler = handlerModule.default ?? handlerModule.scheduled;
   if (typeof scheduledHandler !== "function") {
@@ -2541,7 +2163,7 @@ var scheduled = {
 };
 
 // src/test/tail.ts
-import { join as join7 } from "path";
+import { join as join6 } from "path";
 var tailHandlerPath = null;
 var configDir4 = null;
 var testEnvGetter4 = null;
@@ -2587,7 +2209,7 @@ async function trigger3(items) {
     }
     return createTraceItem(item);
   });
-  const absolutePath = join7(configDir4, tailHandlerPath);
+  const absolutePath = join6(configDir4, tailHandlerPath);
   const handlerModule = await import(absolutePath);
   const defaultExport = handlerModule.default;
   const tailHandler = typeof defaultExport === "function" ? defaultExport : defaultExport && typeof defaultExport.tail === "function" ? defaultExport.tail.bind(defaultExport) : handlerModule.tail;
@@ -2629,7 +2251,7 @@ var tail = {
 };
 
 // src/test/worker.ts
-import { join as join8 } from "path";
+import { join as join7 } from "path";
 var fetchHandlerPath = null;
 var configDir5 = null;
 var testEnvGetter5 = null;
@@ -2678,11 +2300,11 @@ async function fetch2(request, options) {
   } else {
     req = request;
   }
-  const handlerModule = fetchHandlerPath ? await import(join8(workerConfigDir, fetchHandlerPath)) : {};
+  const handlerModule = fetchHandlerPath ? await import(join7(workerConfigDir, fetchHandlerPath)) : {};
   const routeModules = await Promise.all(fileRoutes.map(async (route) => {
     return {
       ...route,
-      module: await import(join8(workerConfigDir, route.filePath))
+      module: await import(join7(workerConfigDir, route.filePath))
     };
   }));
   const methodExports = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "ALL"];
@@ -2813,7 +2435,7 @@ function createMultiWorkerEnvAccessor(state) {
 }
 
 // src/test/simple-context-handlers.ts
-import { join as join9 } from "path";
+import { join as join8 } from "path";
 var DEFAULT_FETCH_PATH = "src/fetch.ts";
 var DEFAULT_QUEUE_PATH = "src/queue.ts";
 var DEFAULT_SCHEDULED_PATH = "src/scheduled.ts";
@@ -2826,7 +2448,7 @@ async function resolveHandlerPath(configDir6, configValue, defaultPath) {
   if (configValue === false) {
     return null;
   }
-  const defaultAbsolute = join9(configDir6, defaultPath);
+  const defaultAbsolute = join8(configDir6, defaultPath);
   try {
     const fs = await import("fs/promises");
     await fs.access(defaultAbsolute);
@@ -2848,14 +2470,14 @@ async function resolveHandlerPaths(configDir6, config) {
 }
 
 // src/test/simple-context-lifecycle.ts
-import { dirname as dirname5, resolve as resolve3 } from "path";
+import { dirname as dirname4, resolve as resolve2 } from "path";
 
 // src/test/containers.ts
 import { createHash, randomUUID } from "node:crypto";
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync2 } 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 { basename, dirname as dirname3, isAbsolute, join as join9, resolve } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { execa } from "execa";
 var realContainerCommandRunner = {
@@ -3034,11 +2656,11 @@ async function resolveContainerStart(className, options, cwd) {
   };
 }
 async function loadContainerConfig(configPath, cwd) {
-  const absolutePath = configPath ? resolve2(cwd, configPath) : await findNearestConfig(cwd);
+  const absolutePath = configPath ? resolve(cwd, configPath) : await findNearestConfig(cwd);
   if (!absolutePath) {
     throw new Error(`Could not find a devflare config file for container lookup. Searched upward from: ${cwd}`);
   }
-  const configDir6 = dirname4(absolutePath);
+  const configDir6 = dirname3(absolutePath);
   const loadedConfig = await loadConfig({
     cwd: configDir6,
     configFile: basename(absolutePath)
@@ -3073,11 +2695,11 @@ async function prepareImage(options) {
   return { image: options.image };
 }
 async function buildLocalImage(options) {
-  const imagePath = resolve2(options.configDir, options.image);
+  const imagePath = resolve(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)) {
+  const dockerfile = imageStat.isDirectory() ? join9(imagePath, "Dockerfile") : imagePath;
+  const context2 = resolve(options.configDir, options.imageBuildContext ?? (imageStat.isDirectory() ? options.image : dirname3(options.image)));
+  if (!existsSync2(dockerfile)) {
     throw new Error(`Container Dockerfile does not exist: ${dockerfile}`);
   }
   const tag = makeLocalImageTag(options.className, options.configDir, options.image);
@@ -3293,7 +2915,7 @@ function isTruthyEnvFlag(value) {
 async function resolveTestContextConfig(configPath, callerDir = getCallerDirectory()) {
   let absolutePath;
   if (configPath) {
-    absolutePath = resolve3(callerDir, configPath);
+    absolutePath = resolve2(callerDir, configPath);
   } else {
     const found = await findNearestConfig(callerDir);
     if (!found) {
@@ -3303,7 +2925,7 @@ async function resolveTestContextConfig(configPath, callerDir = getCallerDirecto
     }
     absolutePath = found;
   }
-  const configDir6 = dirname5(absolutePath);
+  const configDir6 = dirname4(absolutePath);
   const loadedConfig = await loadConfig({
     cwd: configDir6,
     configFile: absolutePath.split(/[/\\]/).pop()
@@ -3352,10 +2974,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((resolve4) => setTimeout(resolve4, TEST_CONTEXT_STARTUP_RETRY_DELAY_MS));
+  await new Promise((resolve3) => setTimeout(resolve3, TEST_CONTEXT_STARTUP_RETRY_DELAY_MS));
 }
 async function waitForBridgeClientRetry() {
-  await new Promise((resolve4) => setTimeout(resolve4, TEST_CONTEXT_BRIDGE_CONNECT_RETRY_DELAY_MS));
+  await new Promise((resolve3) => setTimeout(resolve3, TEST_CONTEXT_BRIDGE_CONNECT_RETRY_DELAY_MS));
 }
 async function connectBridgeClientWithRetry(url) {
   let lastError;
@@ -3476,9 +3098,9 @@ async function bootTestRuntime(mfConfig, usesMultiWorker) {
 }
 
 // src/test/simple-context-transport.ts
-import { join as join11 } from "path";
+import { join as join10 } from "path";
 async function loadTransportDecoders(configDir6, transportFile) {
-  const transportPath = join11(configDir6, transportFile);
+  const transportPath = join10(configDir6, transportFile);
   const transportModule = await import(transportPath);
   if (!transportModule.transport) {
     console.warn(`[devflare] Warning: Transport file "${transportFile}" does not export a named "transport" object.