@jundle/cloudflare 0.0.1-15 → 0.0.1-16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jundle/cloudflare",
-  "version": "0.0.1-15",
+  "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}` ->
@@ -298,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)) {
@@ -563,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.`,
@@ -588,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}`);