devflare 1.0.0-next.4 → 1.0.0-next.6

package/dist/{dev-pa8dhm20.js → dev-7agn9g5s.js}

@@ -21,7 +21,7 @@ import { createConsola } from "consola";
 import { resolve as resolve3 } from "pathe";
 
 // src/dev-server/server.ts
-import { resolve as resolve2 } from "pathe";
+import { dirname as dirname2, resolve as resolve2 } from "pathe";
 
 // src/bundler/do-bundler.ts
 import { resolve, dirname, relative } from "pathe";
@@ -1093,8 +1093,60 @@ async function checkRemoteBindingRequirements(config) {
 }
 
 // src/dev-server/server.ts
-function getGatewayScript(wsRoutes = [], debug = false) {
+var DEFAULT_FETCH_ENTRY_FILES = [
+  "src/fetch.ts",
+  "src/fetch.js",
+  "src/fetch.mts",
+  "src/fetch.mjs"
+];
+var INTERNAL_APP_SERVICE_BINDING = "__DEVFLARE_APP";
+async function resolveMainWorkerScriptPath(cwd, config) {
+  if (config.files?.fetch === false) {
+    return null;
+  }
+  const fs = await import("node:fs/promises");
+  const candidates = new Set;
+  if (typeof config.files?.fetch === "string" && config.files.fetch) {
+    candidates.add(config.files.fetch);
+  }
+  for (const defaultEntry of DEFAULT_FETCH_ENTRY_FILES) {
+    candidates.add(defaultEntry);
+  }
+  for (const candidate of candidates) {
+    const absolutePath = resolve2(cwd, candidate);
+    try {
+      await fs.access(absolutePath);
+      return absolutePath;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function collectWorkerWatchRoots(cwd, config, mainWorkerScriptPath) {
+  const roots = new Set;
+  const addFileParent = (filePath) => {
+    if (typeof filePath !== "string" || !filePath) {
+      return;
+    }
+    roots.add(dirname2(resolve2(cwd, filePath)));
+  };
+  if (mainWorkerScriptPath) {
+    roots.add(dirname2(mainWorkerScriptPath));
+  }
+  addFileParent(config.files?.fetch);
+  addFileParent(config.files?.queue);
+  addFileParent(config.files?.scheduled);
+  addFileParent(config.files?.email);
+  addFileParent(config.files?.transport);
+  if (config.files?.routes && typeof config.files.routes === "object") {
+    roots.add(resolve2(cwd, config.files.routes.dir));
+  }
+  return [...roots];
+}
+function getGatewayScript(wsRoutes = [], debug = false, appServiceBindingName = null) {
   const wsRoutesJson = JSON.stringify(wsRoutes);
+  const appServiceBindingJson = JSON.stringify(appServiceBindingName);
   return `
 // Bridge Gateway Worker — RPC Handler
 // Handles all binding operations via WebSocket RPC
@@ -1109,6 +1161,7 @@ const incomingStreams = new Map()
 
 // WebSocket routes configuration (injected at build time)
 const WS_ROUTES = ${wsRoutesJson}
+const APP_SERVICE_BINDING = ${appServiceBindingJson}
 
 export default {
 	async fetch(request, env, ctx) {
@@ -1149,6 +1202,13 @@ export default {
 			}), { headers: { 'Content-Type': 'application/json' } })
 		}
 
+		if (APP_SERVICE_BINDING) {
+			const appWorker = env[APP_SERVICE_BINDING]
+			if (appWorker && typeof appWorker.fetch === 'function') {
+				return appWorker.fetch(request)
+			}
+		}
+
 		return new Response('Devflare Bridge Gateway', { status: 200 })
 	}
 }
@@ -1676,15 +1736,64 @@ function createDevServer(options) {
   } = options;
   let miniflare = null;
   let doBundler = null;
+  let workerSourceWatcher = null;
   let viteProcess = null;
   let config = null;
   let browserShim = null;
   let browserShimPort = 8788;
+  let mainWorkerScriptPath = null;
+  let bundledMainWorkerScriptPath = null;
+  let currentDoResult = null;
+  let reloadChain = Promise.resolve();
+  async function bundleMainWorker() {
+    if (!mainWorkerScriptPath) {
+      bundledMainWorkerScriptPath = null;
+      return;
+    }
+    if (typeof Bun === "undefined" || typeof Bun.build !== "function") {
+      throw new Error("Worker-only dev mode requires the Bun runtime for main worker bundling");
+    }
+    const fs = await import("node:fs/promises");
+    const outDir = resolve2(cwd, ".devflare", "worker-bundles");
+    await fs.rm(outDir, { recursive: true, force: true });
+    await fs.mkdir(outDir, { recursive: true });
+    const result = await Bun.build({
+      entrypoints: [mainWorkerScriptPath],
+      outdir: outDir,
+      target: "browser",
+      conditions: ["browser"],
+      format: "esm",
+      minify: false,
+      splitting: false,
+      external: ["cloudflare:workers", "cloudflare:*"]
+    });
+    if (!result.success || result.outputs.length === 0) {
+      const logs = result.logs.map((log) => ("message" in log) ? log.message : String(log)).join(`
+`);
+      throw new Error(`Failed to bundle main worker:
+${logs}`);
+    }
+    bundledMainWorkerScriptPath = result.outputs[0].path;
+    logger?.debug(`Bundled main worker → ${bundledMainWorkerScriptPath}`);
+  }
   function buildMiniflareConfig(doResult) {
     if (!config)
       throw new Error("Config not loaded");
-    const bindings = config.bindings ?? {};
+    const loadedConfig = config;
+    const bindings = loadedConfig.bindings ?? {};
     const persistPath = resolve2(cwd, ".devflare/data");
+    const appWorkerName = loadedConfig.name;
+    const shouldRunMainWorker = !enableVite && !!mainWorkerScriptPath;
+    const queueProducers = (() => {
+      if (!bindings.queues?.producers) {
+        return;
+      }
+      const producers = {};
+      for (const [bindingName, queueName] of Object.entries(bindings.queues.producers)) {
+        producers[bindingName] = { queueName };
+      }
+      return producers;
+    })();
     const sharedOptions = {
       port: miniflarePort,
       host: "127.0.0.1",
@@ -1693,19 +1802,67 @@ function createDevServer(options) {
       d1Persist: persist ? `${persistPath}/d1` : undefined,
       durableObjectsPersist: persist ? `${persistPath}/do` : undefined
     };
-    const gatewayWorker = {
-      name: "gateway",
-      modules: true,
-      script: getGatewayScript(config.wsRoutes, debug),
-      compatibilityDate: config.compatibilityDate,
-      compatibilityFlags: config.compatibilityFlags ?? [],
-      routes: ["*"],
-      kvNamespaces: bindings.kv ? bindings.kv : undefined,
-      r2Buckets: bindings.r2 ? bindings.r2 : undefined,
-      d1Databases: bindings.d1 ? bindings.d1 : undefined,
-      bindings: config.vars
+    const createServiceBindings = (extraBindings = {}) => {
+      const serviceBindings = {};
+      if (bindings.services) {
+        for (const [bindingName, serviceConfig] of Object.entries(bindings.services)) {
+          serviceBindings[bindingName] = {
+            name: serviceConfig.service,
+            ...serviceConfig.entrypoint && { entrypoint: serviceConfig.entrypoint }
+          };
+        }
+      }
+      for (const [bindingName, target] of Object.entries(extraBindings)) {
+        serviceBindings[bindingName] = target;
+      }
+      return Object.keys(serviceBindings).length > 0 ? serviceBindings : undefined;
+    };
+    const createWorkerConfig = (options2) => {
+      const baseFlags = loadedConfig.compatibilityFlags ?? [];
+      const compatFlags = baseFlags.includes("nodejs_compat") ? baseFlags : [...baseFlags, "nodejs_compat"];
+      const workerConfig = {
+        name: options2.name,
+        modules: true,
+        compatibilityDate: loadedConfig.compatibilityDate,
+        compatibilityFlags: compatFlags,
+        ...bindings.kv && { kvNamespaces: bindings.kv },
+        ...bindings.r2 && { r2Buckets: bindings.r2 },
+        ...bindings.d1 && { d1Databases: bindings.d1 },
+        ...loadedConfig.vars && Object.keys(loadedConfig.vars).length > 0 && { bindings: loadedConfig.vars },
+        ...queueProducers && { queueProducers }
+      };
+      if (options2.scriptPath) {
+        workerConfig.scriptPath = options2.scriptPath;
+        workerConfig.modulesRoot = cwd;
+        workerConfig.modulesRules = [
+          { type: "ESModule", include: ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.mjs"] },
+          { type: "CommonJS", include: ["**/*.js", "**/*.cjs"] },
+          { type: "ESModule", include: ["**/*.jsx"] }
+        ];
+      }
+      if (options2.script) {
+        workerConfig.script = options2.script;
+      }
+      if (options2.durableObjects && Object.keys(options2.durableObjects).length > 0) {
+        workerConfig.durableObjects = options2.durableObjects;
+      }
+      if (options2.serviceBindings && Object.keys(options2.serviceBindings).length > 0) {
+        workerConfig.serviceBindings = options2.serviceBindings;
+      }
+      return workerConfig;
     };
-    if (!doResult || doResult.bundles.size === 0) {
+    const gatewayWorker = createWorkerConfig({
+      name: "gateway",
+      script: getGatewayScript(loadedConfig.wsRoutes, debug, shouldRunMainWorker ? INTERNAL_APP_SERVICE_BINDING : null),
+      serviceBindings: shouldRunMainWorker ? createServiceBindings({
+        [INTERNAL_APP_SERVICE_BINDING]: { name: appWorkerName }
+      }) : createServiceBindings()
+    });
+    gatewayWorker.routes = ["*"];
+    const hasDurableObjectBundles = !!doResult && doResult.bundles.size > 0;
+    const browserBindingName = bindings.browser?.binding;
+    const needsBrowserWorker = Boolean(browserBindingName && (hasDurableObjectBundles || shouldRunMainWorker));
+    if (!shouldRunMainWorker && !hasDurableObjectBundles && !needsBrowserWorker) {
       return {
         ...sharedOptions,
         ...gatewayWorker
@@ -1714,56 +1871,62 @@ function createDevServer(options) {
     const workers = [];
     const durableObjects = {};
     const browserShimUrl = `http://127.0.0.1:${browserShimPort}`;
-    const browserBindingName = bindings.browser?.binding;
     const browserWorkerName = "browser-binding";
-    for (const [bindingName, bundlePath] of doResult.bundles) {
-      const className = doResult.classes.get(bindingName);
-      if (!className)
-        continue;
-      const workerName = `do-${bindingName.toLowerCase()}`;
-      const baseFlags = config.compatibilityFlags ?? [];
-      const compatFlags = baseFlags.includes("nodejs_compat") ? baseFlags : [...baseFlags, "nodejs_compat"];
-      const workerConfig = {
-        name: workerName,
-        modules: true,
-        modulesRoot: cwd,
-        modulesRules: [
-          { type: "CommonJS", include: ["**/*.js", "**/*.cjs"] },
-          { type: "ESModule", include: ["**/*.mjs"] }
-        ],
-        scriptPath: bundlePath,
-        compatibilityDate: config.compatibilityDate,
-        compatibilityFlags: compatFlags,
-        durableObjects: {
-          [bindingName]: className
+    if (shouldRunMainWorker && mainWorkerScriptPath) {
+      const mainWorkerServiceBindings = createServiceBindings(browserBindingName ? {
+        [browserBindingName]: { name: browserWorkerName }
+      } : {});
+      const mainWorkerConfig = createWorkerConfig({
+        name: appWorkerName,
+        scriptPath: bundledMainWorkerScriptPath ?? mainWorkerScriptPath,
+        serviceBindings: mainWorkerServiceBindings
+      });
+      workers.push(mainWorkerConfig);
+    }
+    if (doResult) {
+      for (const [bindingName, bundlePath] of doResult.bundles) {
+        const className = doResult.classes.get(bindingName);
+        if (!className)
+          continue;
+        const workerName = `do-${bindingName.toLowerCase()}`;
+        const workerConfig = createWorkerConfig({
+          name: workerName,
+          scriptPath: bundlePath,
+          durableObjects: {
+            [bindingName]: className
+          },
+          serviceBindings: createServiceBindings(browserBindingName ? {
+            [browserBindingName]: { name: browserWorkerName }
+          } : {})
+        });
+        if (browserBindingName) {
+          logger?.debug(`DO ${workerName} has browser service binding: ${browserBindingName} → ${browserWorkerName}`);
         }
-      };
-      if (browserBindingName) {
-        workerConfig.serviceBindings = {
-          ...workerConfig.serviceBindings,
-          [browserBindingName]: browserWorkerName
+        logger?.debug(`DO ${workerName} config:`, JSON.stringify(workerConfig, null, 2));
+        workers.push(workerConfig);
+        durableObjects[bindingName] = {
+          className,
+          scriptName: workerName
         };
-        logger?.debug(`DO ${workerName} has browser service binding: ${browserBindingName} → ${browserWorkerName}`);
       }
-      logger?.debug(`DO ${workerName} config:`, JSON.stringify(workerConfig, null, 2));
-      workers.push(workerConfig);
-      durableObjects[bindingName] = {
-        className,
-        scriptName: workerName
-      };
     }
-    if (browserBindingName) {
-      const browserWorker = {
+    if (needsBrowserWorker) {
+      const browserWorker = createWorkerConfig({
         name: browserWorkerName,
-        modules: true,
-        script: getBrowserBindingScript(browserShimUrl, debug),
-        compatibilityDate: config.compatibilityDate,
-        compatibilityFlags: config.compatibilityFlags ?? []
-      };
+        script: getBrowserBindingScript(browserShimUrl, debug)
+      });
       workers.push(browserWorker);
       logger?.info(`Browser binding worker configured: ${browserBindingName} → ${browserShimUrl}`);
     }
-    gatewayWorker.durableObjects = durableObjects;
+    if (Object.keys(durableObjects).length > 0) {
+      gatewayWorker.durableObjects = durableObjects;
+      if (shouldRunMainWorker) {
+        const mainWorker = workers.find((worker) => worker.name === appWorkerName);
+        if (mainWorker) {
+          mainWorker.durableObjects = durableObjects;
+        }
+      }
+    }
     return {
       ...sharedOptions,
       workers: [gatewayWorker, ...workers]
@@ -1817,14 +1980,93 @@ function createDevServer(options) {
     }
   }
   async function reloadMiniflare(doResult) {
-    if (!miniflare)
+    currentDoResult = doResult;
+    const queuedReload = reloadChain.then(async () => {
+      if (!miniflare)
+        return;
+      const { Log, LogLevel } = await import("miniflare");
+      const mfConfig = buildMiniflareConfig(currentDoResult);
+      mfConfig.log = new Log(LogLevel.DEBUG);
+      logger?.info("Reloading Miniflare...");
+      await miniflare.setOptions(mfConfig);
+      logger?.success("Miniflare reloaded");
+    });
+    reloadChain = queuedReload.catch(() => {});
+    await queuedReload;
+  }
+  async function startWorkerSourceWatcher() {
+    if (enableVite || !config || !mainWorkerScriptPath) {
       return;
-    const { Log, LogLevel } = await import("miniflare");
-    const mfConfig = buildMiniflareConfig(doResult);
-    mfConfig.log = new Log(LogLevel.DEBUG);
-    logger?.info("Reloading Miniflare with updated DOs...");
-    await miniflare.setOptions(mfConfig);
-    logger?.success("Miniflare reloaded");
+    }
+    const watchRoots = collectWorkerWatchRoots(cwd, config, mainWorkerScriptPath);
+    if (watchRoots.length === 0) {
+      return;
+    }
+    const chokidar = await import("chokidar");
+    const isWindows = process.platform === "win32";
+    const ignoredSegments = ["/node_modules/", "/.git/", "/.devflare/", "/dist/"];
+    const normalizePath = (filePath) => filePath.replace(/\\/g, "/");
+    const isIgnoredPath = (filePath) => {
+      const normalizedPath = normalizePath(filePath);
+      return ignoredSegments.some((segment) => normalizedPath.includes(segment));
+    };
+    let reloadTimeout = null;
+    let reloadInProgress = false;
+    let pendingReloadPath = null;
+    const triggerReload = async (filePath) => {
+      if (reloadInProgress) {
+        pendingReloadPath = filePath;
+        return;
+      }
+      reloadInProgress = true;
+      try {
+        logger?.info(`Worker source changed: ${filePath}`);
+        await bundleMainWorker();
+        await reloadMiniflare(currentDoResult);
+      } catch (error) {
+        logger?.error("Worker source reload failed:", error);
+      } finally {
+        reloadInProgress = false;
+        if (pendingReloadPath) {
+          const nextPath = pendingReloadPath;
+          pendingReloadPath = null;
+          await triggerReload(nextPath);
+        }
+      }
+    };
+    const scheduleReload = (filePath) => {
+      if (reloadTimeout) {
+        clearTimeout(reloadTimeout);
+      }
+      reloadTimeout = setTimeout(() => {
+        triggerReload(filePath);
+      }, 150);
+    };
+    workerSourceWatcher = chokidar.watch(watchRoots, {
+      ignoreInitial: true,
+      usePolling: isWindows,
+      interval: isWindows ? 300 : undefined,
+      awaitWriteFinish: {
+        stabilityThreshold: 100,
+        pollInterval: 50
+      },
+      ignored: (filePath) => isIgnoredPath(filePath)
+    });
+    const onFileEvent = (filePath) => {
+      if (isIgnoredPath(filePath)) {
+        return;
+      }
+      scheduleReload(filePath);
+    };
+    workerSourceWatcher.on("change", onFileEvent);
+    workerSourceWatcher.on("add", onFileEvent);
+    workerSourceWatcher.on("unlink", onFileEvent);
+    workerSourceWatcher.on("ready", () => {
+      logger?.info(`Worker source watcher ready (${watchRoots.length} root(s))`);
+    });
+    workerSourceWatcher.on("error", (error) => {
+      logger?.error("Worker source watcher error:", error);
+    });
   }
   async function runD1Migrations() {
     if (!miniflare || !config?.bindings?.d1)
@@ -1911,6 +2153,13 @@ function createDevServer(options) {
     logger?.info("Starting unified dev server...");
     config = await loadConfig({ cwd, configFile: configPath });
     logger?.debug("Loaded config:", config.name);
+    mainWorkerScriptPath = await resolveMainWorkerScriptPath(cwd, config);
+    if (!enableVite && mainWorkerScriptPath) {
+      logger?.info(`Worker entry detected: ${mainWorkerScriptPath}`);
+      await bundleMainWorker();
+    } else if (!enableVite) {
+      logger?.warn("No local fetch worker entry was found for worker-only mode");
+    }
     const remoteCheck = await checkRemoteBindingRequirements(config);
     if (remoteCheck.hasRemoteBindings) {
       logger?.info("");
@@ -1961,9 +2210,12 @@ function createDevServer(options) {
         }
       });
       doResult = await doBundler.build();
+      currentDoResult = doResult;
       await doBundler.watch();
     }
+    currentDoResult = doResult;
     await startMiniflare(doResult);
+    await startWorkerSourceWatcher();
     if (enableVite) {
       await startVite();
     } else {
@@ -1977,6 +2229,10 @@ function createDevServer(options) {
       await doBundler.close();
       doBundler = null;
     }
+    if (workerSourceWatcher) {
+      await workerSourceWatcher.close();
+      workerSourceWatcher = null;
+    }
     if (miniflare) {
       await miniflare.dispose();
       miniflare = null;

package/dist/dev-server/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/dev-server/server.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,WAAW,CAAA;AAc3D,MAAM,WAAW,gBAAgB;IAChC,6BAA6B;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,kCAAkC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,iDAAiD;IACjD,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,2BAA2B;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,sBAAsB;IACtB,MAAM,CAAC,EAAE,eAAe,CAAA;IACxB,6BAA6B;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,0DAA0D;IAC1D,KAAK,CAAC,EAAE,OAAO,CAAA;CACf;AAED,MAAM,WAAW,SAAS;IACzB,2BAA2B;IAC3B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB,0BAA0B;IAC1B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACrB,yCAAyC;IACzC,YAAY,IAAI,aAAa,GAAG,IAAI,CAAA;CACpC;AA2kBD,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CA4epE"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/dev-server/server.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,WAAW,CAAA;AAc3D,MAAM,WAAW,gBAAgB;IAChC,6BAA6B;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,kCAAkC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,iDAAiD;IACjD,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,2BAA2B;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,sBAAsB;IACtB,MAAM,CAAC,EAAE,eAAe,CAAA;IACxB,6BAA6B;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,0DAA0D;IAC1D,KAAK,CAAC,EAAE,OAAO,CAAA;CACf;AAED,MAAM,WAAW,SAAS;IACzB,2BAA2B;IAC3B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB,0BAA0B;IAC1B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACrB,yCAAyC;IACzC,YAAY,IAAI,aAAa,GAAG,IAAI,CAAA;CACpC;AAmqBD,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAmuBpE"}

package/dist/index-62b3gt2g.js

@@ -0,0 +1,12 @@
+// src/workerName.ts
+var workerName = (() => {
+  if (typeof __DEVFLARE_WORKER_NAME__ !== "undefined") {
+    return __DEVFLARE_WORKER_NAME__;
+  }
+  if (typeof process !== "undefined" && process.env?.DEVFLARE_WORKER_NAME) {
+    return process.env.DEVFLARE_WORKER_NAME;
+  }
+  return "unknown";
+})();
+
+export { workerName };

package/dist/index-9ats0s83.js

@@ -0,0 +1,70 @@
+import {
+  getContextOrNull
+} from "./index-npc1c8jx.js";
+import {
+  bridgeEnv
+} from "./index-ccrh4w3t.js";
+
+// src/env.ts
+var testContextEnv = null;
+var testContextDispose = null;
+function __setTestContext(envBindings, dispose) {
+  testContextEnv = envBindings;
+  testContextDispose = dispose;
+}
+function __clearTestContext() {
+  testContextEnv = null;
+  testContextDispose = null;
+}
+var env = new Proxy({}, {
+  get(_target, prop) {
+    if (prop === "dispose") {
+      return async () => {
+        if (testContextDispose) {
+          await testContextDispose();
+          __clearTestContext();
+        }
+      };
+    }
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return ctx.env[prop];
+    }
+    if (testContextEnv) {
+      return testContextEnv[prop];
+    }
+    return bridgeEnv[prop];
+  },
+  has(_target, prop) {
+    if (prop === "dispose")
+      return true;
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return prop in ctx.env;
+    }
+    if (testContextEnv) {
+      return prop in testContextEnv;
+    }
+    return prop in bridgeEnv;
+  },
+  ownKeys(_target) {
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return Reflect.ownKeys(ctx.env);
+    }
+    if (testContextEnv) {
+      return Reflect.ownKeys(testContextEnv);
+    }
+    return Reflect.ownKeys(bridgeEnv);
+  },
+  getOwnPropertyDescriptor(_target, prop) {
+    if (prop === "dispose") {
+      return { configurable: true, enumerable: false, writable: false };
+    }
+    const ctx = getContextOrNull();
+    const source = ctx?.env ?? testContextEnv ?? bridgeEnv;
+    return Reflect.getOwnPropertyDescriptor(source, prop);
+  }
+});
+
+export { __setTestContext, __clearTestContext, env };