@jundle/cloudflare 0.0.1-13 → 0.0.1-15

package/package.json

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

package/src/harness.js

@@ -146,8 +146,10 @@ async function fetchJson(url) {
 
 // Pull-based invalidation (SPEC §16.11): one loopback fetch per
 // dispatch. Evicts invalidated dev-module keys (evaluated +
-// text) and JSON values for edited JSON files, then advances
-// the seen version. The dev server prunes acked batches.
+// text) and JSON values for edited JSON files, and rebuilt
+// dep files (dep text + evaluated deps, plus every app
+// module — SPEC §16.5), then advances the seen version.
+// The dev server prunes acked batches.
 // After eviction, pushes fresh SSR-variant instances for the
 // browser-env subset (see pushSsrUpdates) before the entry
 // re-imports, so the entry's decode already sees them.
@@ -168,6 +170,37 @@ async function syncVersion() {
       if (k.split("\0")[1] === file) assetValueCache.delete(k);
     }
   }
+  // Dep invalidation (SPEC §16.5, §16.11): an on-demand
+  // unification run rebuilt existing dep bundles (same
+  // URL, new bytes) or remapped existing specs (the old
+  // files are dead). Evict the changed dep text —
+  // bundle-dir units share the entry's `file\0rel`
+  // prefix — then clear every evaluated module, app and
+  // dep alike (mirrors NodeRunner.invalidateAll).
+  // Evaluated app modules may hold the old dep exports,
+  // the closure walk prunes cached subtrees, and dep
+  // modules hold state coupled to the app modules (the
+  // Flight client's chunk map assumes the shim's cache
+  // outlives it — clearing the shim without the client
+  // makes the client require a chunk the fresh shim
+  // never loaded). Only the TEXT eviction is targeted:
+  // unchanged dep text is still valid input, so it
+  // stays cached and no re-fetch is needed for it. The
+  // fresh text is fetched lazily by the next entry
+  // import, not eagerly here: a re-fetch failure after
+  // the version advanced would leave the dep
+  // permanently broken until restart.
+  const depFiles = data.depFiles || [];
+  if (depFiles.length > 0) {
+    for (const file of depFiles) {
+      for (const k of depText.keys()) {
+        if (k === file || k.startsWith(`${file}\0`)) depText.delete(k);
+      }
+    }
+    evaluated.clear();
+    textCache.clear();
+    depEvaluated.clear();
+  }
   await pushSsrUpdates(data.clientInvalidated || []);
 }
 
@@ -187,16 +220,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);
   }
 }