@jundle/cloudflare 0.0.1-14 → 0.0.1-16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jundle/cloudflare",
-  "version": "0.0.1-14",
+  "version": "0.0.1-16",
   "description": "Cloudflare Workers runtime for the jundle dev server (workerd via Miniflare).",
   "license": "ISC",
   "type": "module",

package/src/harness.js

@@ -98,6 +98,28 @@ const evaluated = new Map();
 const depText = new Map();
 // Evaluated dep bundles: key -> {exports, failed, error}.
 const depEvaluated = new Map();
+// Serializes dep-text walks (FIFO promise queue):
+// concurrent chunk loads walk the same shared bundles,
+// and ensureDepText's "already fetched" early-return
+// does not wait for an in-flight subtree walk — a
+// second walk can see a bundle's text present, skip its
+// subtree, and evaluate it while the first walk is
+// still fetching its transitive deps ("was not
+// pre-fetched", non-deterministic in which bundle). One
+// walk at a time closes the race; the recursion inside
+// a walk never re-enters the queue, so it cannot
+// deadlock. A failed walk rejects to its caller but
+// resolves the queue slot, so it never poisons later
+// walks.
+let depWalkQueue = Promise.resolve();
+function runDepWalk(fn) {
+  const run = depWalkQueue.then(fn);
+  depWalkQueue = run.then(
+    () => {},
+    () => {},
+  );
+  return run;
+}
 // Parsed JSON values: key `${env}\0${file}` -> value.
 const jsonCache = new Map();
 // Prefetched asset values: key `${env}\0${file}\0${type}` ->
@@ -220,16 +242,50 @@ async function syncVersion() {
 // document in a worker), and surfacing it would trip the
 // hot client's first-update overlay rule and force a full
 // reload on the next update instead of HMR.
+//
+// The re-import can install a second (browser) shim over
+// the dev shim's globals — client.browser.js imports
+// ./shim.js first, so any module importing the client
+// runtime installs it as a side effect — and the
+// client's chunkCache skips re-loading chunks, so a
+// poisoned global makes the next render require through
+// an empty shim ("has not been loaded yet"). Snapshot the
+// four shim globals before the re-import and restore
+// them before the push lands (finally, so a failed
+// import cannot leave them poisoned). A snapshot of
+// undefined restores by deleting the global, not by
+// assigning undefined (the shim was not installed yet).
+const SHIM_GLOBALS = [
+  "__webpack_require__",
+  "__webpack_chunk_load__",
+  "__webpack_get_script_filename__",
+  "__jundleFlight",
+];
+function snapshotShimGlobals() {
+  return SHIM_GLOBALS.map((name) => [name, globalThis[name]]);
+}
+function restoreShimGlobals(saved) {
+  for (const [name, value] of saved) {
+    if (value === undefined) delete globalThis[name];
+    else globalThis[name] = value;
+  }
+}
 async function pushSsrUpdates(clientKeys) {
   for (const key of clientKeys) {
     const [env, file] = key.split("\0");
     const url = `/@jundle/module?env=${encodeURIComponent(env)}&file=${encodeURIComponent(file)}`;
+    const saved = snapshotShimGlobals();
+    let rec;
+    let ok = false;
     try {
-      const rec = await ensureModuleByUrl(url);
-      globalThis.__jundleFlight?.updateModule?.(url, rec.exports);
+      rec = await ensureModuleByUrl(url);
+      ok = true;
     } catch (e) {
       console.error(`[jundle runner] SSR push ${url}: ${e && e.message ? e.message : String(e)}`);
+    } finally {
+      restoreShimGlobals(saved);
     }
+    if (ok) globalThis.__jundleFlight?.updateModule?.(url, rec.exports);
   }
 }
 
@@ -264,7 +320,12 @@ async function ensureText(url, visiting = new Set()) {
     if (edge.kind === "dev" || edge.kind === "client-ref" || edge.kind === "server-action") {
       await ensureText(edge.url, visiting);
     } else if (edge.kind === "dep") {
-      await ensureDepText(edge.url, new Set());
+      // Serialized through the dep walk queue: two
+      // concurrent dispatches walk the same shared
+      // bundles, and an unserialized walk can evaluate a
+      // bundle whose subtree another walk is still
+      // fetching (same race as loadChunk, below).
+      await runDepWalk(() => ensureDepText(edge.url, new Set()));
     } else if (edge.kind === "json") {
       const jk = devKey(edge.url);
       if (!jsonCache.has(jk)) {
@@ -529,6 +590,16 @@ function requireHook(spec, importerKey) {
       const key = `${importerEnv}\0${candidate}`;
       if (jsonCache.has(key)) return jsonCache.get(key);
     }
+    // Literal dynamic imports (import("./route")) compile
+    // to a require of the raw relative spec (the harness
+    // has no async __jundleImport), and the closure walk
+    // pre-fetches them via their dev edges — so resolve
+    // the spec the same way and evaluate the pre-fetched
+    // module. A spec with no pre-fetched text falls
+    // through to the loud error below (a truly-dynamic
+    // specifier has no static target to pre-fetch).
+    const devModuleKey = `${importerEnv}\0${normalized}`;
+    if (textCache.has(devModuleKey)) return evaluateDev(devModuleKey).exports;
   }
   throw new Error(
     `ModuleRunner: '${spec}' was not pre-loaded (the closure walk missed it); use a static, literal specifier for this import so the walk pre-loads it; dynamic specifiers are not pre-loaded.`,
@@ -554,6 +625,22 @@ const hostContext = {
     return (await ensureModuleByUrl(resolved.url)).exports;
   },
   loadChunk: async (chunkId) => {
+    // Dep chunk ids (the Flight client preloads dep
+    // client components by their bundle URL): fetch the
+    // dep text on demand — the closure walk does not
+    // pre-fetch dep client-ref bundles (their client-ref
+    // edges carry a prebundleSpec and are omitted) — then
+    // evaluate it, mirroring NodeRunner's hostContext.
+    // Serialized through the dep walk queue: concurrent
+    // chunk loads share transitive bundles, and an
+    // unserialized walk can evaluate a bundle whose
+    // subtree another walk is still fetching.
+    if (chunkId.startsWith("/@jundle/deps/")) {
+      return runDepWalk(async () => {
+        await ensureDepText(chunkId);
+        return evaluateDep(chunkId).exports;
+      });
+    }
     const u = new URL(chunkId, "http://dev");
     if (u.pathname !== "/@jundle/module")
       throw new Error(`ModuleRunner: refusing to load chunk (not a dev module URL): ${chunkId}`);