@uniflowed/vite 0.0.0-alpha.39 → 0.0.0-alpha.40

package/driver.js

@@ -1862,6 +1862,25 @@ serve({ handle: fetch, staticDir, beginRequest, routing${cron.option} }).catch((
 `;
 }
 
+/**
+ * The oldest Bun that can run what this adapter writes.
+ *
+ * Kept equal to `uf_runtime`'s `BUN_MINIMUM` by
+ * `the_bun_entry_refuses_a_bun_older_than_the_declared_minimum`, which reads
+ * the number out of the artefact rather than out of this file — two places
+ * holding one version is exactly the shape that lets them disagree.
+ *
+ * Why there is a floor at all: React's published server build contains a
+ * labelled statement in `else` position — `else a: if (…)`, in every
+ * `react-dom-server*.production.js` including the `bun` one — and Bun's engine
+ * rejects it with `Cannot find scope for the label 'a'` before this release.
+ * Bun 1.3.13 rejects the built `handler.js`; 1.3.14 imports it and serves it.
+ * It is ordinary ES that Node runs, uf does not emit it, and the `bun` export
+ * condition does not avoid it, so there is nothing for uf to lower. See
+ * ubugeeei-prod/uf#1048.
+ */
+const MINIMUM_BUN = "1.3.14";
+
 /**
  * The source of `server.js`: the Bun socket around that handler.
  *
@@ -1869,6 +1888,16 @@ serve({ handle: fetch, staticDir, beginRequest, routing${cron.option} }).catch((
  * `serve` from — `@uniflowed/server/bun` exports the same signature on
  * purpose, so that the two adapters are one contract and a project moving
  * between them changes a flag and nothing else.
+ *
+ * # Why the handler is imported dynamically
+ *
+ * The one place this is *not* `nodeEntrySource`'s twin. A static
+ * `import … from "./handler.js"` is linked before a single statement of this
+ * file runs, so a version check written above it would never execute: Bun
+ * would fail parsing `handler.js` and the sentence explaining why would never
+ * be reached. `await import()` puts the check first, which is the same move
+ * `denoEntrySource` makes to get its globals in before the handler is
+ * evaluated.
  */
 function bunEntrySource(handlerSpecifier, schedules) {
   const cron = scheduleLines("@uniflowed/server/schedule", schedules);
@@ -1878,11 +1907,42 @@ import { fileURLToPath } from "node:url";
 
 import { serve } from "@uniflowed/server/bun";
 ${cron.imports}
+// The Bun this build needs. React's server build carries a labelled statement
+// in \`else\` position that Bun's engine rejects before this release, so an
+// older Bun cannot parse \`handler.js\` at all — see ubugeeei-prod/uf#1048.
+//
+// This runs *before* the handler is imported, and that ordering is the whole
+// point: a static import would be linked first and the parse would fail with
+// Bun's message rather than this one.
+const MINIMUM_BUN = ${JSON.stringify(MINIMUM_BUN)};
+
+function ufBunIsOlderThanMinimum(version) {
+  const actual = String(version).split(".");
+  const floor = MINIMUM_BUN.split(".");
+  for (let index = 0; index < floor.length; index += 1) {
+    const mine = Number.parseInt(actual[index], 10);
+    const want = Number.parseInt(floor[index], 10);
+    if (!Number.isFinite(mine)) return true;
+    if (mine !== want) return mine < want;
+  }
+  return false;
+}
+
+if (typeof Bun !== "undefined" && ufBunIsOlderThanMinimum(Bun.version)) {
+  process.stderr.write(
+    \`uf: this build needs Bun \${MINIMUM_BUN} or newer, and this is Bun \${Bun.version}. \` +
+      "React's server build uses a labelled statement Bun rejects before " +
+      \`\${MINIMUM_BUN}, so \\\`handler.js\\\` beside this file cannot be parsed here. \` +
+      "Upgrade with \`bun upgrade\`, or build with \`--adapter node\` and run it on Node.\\n",
+  );
+  process.exit(1);
+}
+
 // \`beginRequest\` comes from the handler beside this file rather than from
 // \`@uniflowed/server/bun\` above, because the request has to be established in
 // the storage the *application* reads, which is the copy bundled into
 // \`handler.js\`. See ubugeeei-prod/uf#389.
-import { beginRequest, fetch, routing } from ${JSON.stringify(handlerSpecifier)};
+const { beginRequest, fetch, routing } = await import(${JSON.stringify(handlerSpecifier)});
 
 // Resolved from this file and not from the working directory: a process
 // manager, a container entrypoint and a person in a shell each start a server

package/internal/flight.js

@@ -581,10 +581,21 @@ export function loadClientModule(url) {
  * @param {Map<string, string>} chunkUrls
  */
 export function builtReferencesSource(chunkUrls) {
-  const entries = [...chunkUrls].map(
-    ([file, url]) => `  [${JSON.stringify(url)}, () => import(${JSON.stringify(file)})],`,
-  );
-  return `const table = new Map([
+  const imports = [];
+  const entries = [];
+  let staticIndex = 0;
+  for (const [file, url] of chunkUrls) {
+    if (serverBundleAlreadyImportsClientReference(file)) {
+      const name = `staticReference${staticIndex}`;
+      staticIndex += 1;
+      imports.push(`import * as ${name} from ${JSON.stringify(file)};`);
+      entries.push(`  [${JSON.stringify(url)}, () => Promise.resolve(${name})],`);
+    } else {
+      entries.push(`  [${JSON.stringify(url)}, () => import(${JSON.stringify(file)})],`);
+    }
+  }
+  const prelude = imports.length === 0 ? "" : `${imports.join("\n")}\n`;
+  return `${prelude}const table = new Map([
 ${entries.join("\n")}
 ]);
 export function loadClientModule(url) {
@@ -599,6 +610,28 @@ export function loadClientModule(url) {
 `;
 }
 
+/**
+ * Router internals that are client modules and also already in the server
+ * bundle through the router's own synchronous imports.
+ *
+ * They still need entries in the client-reference table, because a Flight
+ * payload can name their chunks. Loading them with `import()`, however, makes
+ * Rollup print INEFFECTIVE_DYNAMIC_IMPORT: the dynamic import cannot split a
+ * module the server chunk has already imported. Return the namespace the
+ * server loaded anyway.
+ */
+function serverBundleAlreadyImportsClientReference(file) {
+  const normalized = file.split(path.sep).join("/");
+  return ROUTER_CLIENT_REFERENCES_IN_SERVER.some((suffix) => normalized.endsWith(suffix));
+}
+
+const ROUTER_CLIENT_REFERENCES_IN_SERVER = Object.freeze([
+  "/@uniflowed/router/internal/boundaries.js",
+  "/@uniflowed/router/internal/error-view.js",
+  "/packages/router/internal/boundaries.js",
+  "/packages/router/internal/error-view.js",
+]);
+
 /**
  * `virtual:uf/client` for an application React Server Components render.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniflowed/vite",
-  "version": "0.0.0-alpha.39",
+  "version": "0.0.0-alpha.40",
   "description": "Vite, driven by uf.config.js: every Flow module through `uf transform`, MDX, the file-system router and static rendering as Vite plugins.",
   "type": "module",
   "license": "MIT",
@@ -34,10 +34,10 @@
   "dependencies": {
     "@mdx-js/rollup": "^3.1.1",
     "@shikijs/rehype": "^3.23.0",
-    "@uniflowed/host": "0.0.0-alpha.39",
-    "@uniflowed/router": "0.0.0-alpha.39",
-    "@uniflowed/server": "0.0.0-alpha.39",
-    "@uniflowed/validator": "0.0.0-alpha.39",
+    "@uniflowed/host": "0.0.0-alpha.40",
+    "@uniflowed/router": "0.0.0-alpha.40",
+    "@uniflowed/server": "0.0.0-alpha.40",
+    "@uniflowed/validator": "0.0.0-alpha.40",
     "estree-util-value-to-estree": "^3.5.0",
     "rehype-slug": "^6.0.0",
     "remark-frontmatter": "^5.0.0",