@webjsdev/server 0.8.89 → 0.8.91

package/src/ssr/render.js

@@ -1,9 +1,9 @@
-import { resolve } from 'node:path';
 import { renderToString, isNotFound, isRedirect, isForbidden, isUnauthorized } from '@webjsdev/core';
 import { vendorPreloadTargets } from '../importmap.js';
 import {
-  componentPreloads, deduplicatedPreloads, reachedVendorSpecifiers, toUrlPath,
+  componentPreloads, pagePreloadHints, toUrlPath,
 } from './preloads.js';
+import { shippedBootModules, assembleBootModules } from './shipped-modules.js';
 import { seedingEnabled, collectSeeds, buildSeedScript, SEED_DROP_BLOCK } from '../action-seed.js';
 import {
   readRevalidate,
@@ -674,34 +674,21 @@ function reportBoundaryLayoutError(err, opts, cfg = {}) {
  * @returns {string[]}
  */
 function boundaryModuleUrls(boundaryFile, wrapLayouts, opts) {
-  /** @type {string[]} */
-  const urls = [];
-  const seen = new Set();
-  const push = (abs) => {
-    const u = toUrlPath(abs, opts.appDir);
-    if (!seen.has(u)) { seen.add(u); urls.push(u); }
-  };
-  for (const f of (boundaryFile ? [boundaryFile, ...wrapLayouts] : [...wrapLayouts])) {
-    if (opts.inertRouteModules && opts.inertRouteModules.has(f)) continue;
-    const emit = opts.importOnlyRouteModules && opts.importOnlyRouteModules.get(f);
-    if (emit) emit.forEach(push);
-    else push(f);
-  }
-  // instrumentation-client.{js,ts} (#848) rides the SAME first-import contract
-  // it has on the happy path: it runs before app modules so the app's client
-  // error reporting is installed before anything can throw. A boundary page is
-  // where that matters most, so it must not be the one place it is missing.
-  // The set is never empty by the time we get here (the boundary file is
-  // always pushed above, since only pages and layouts are fed to the elision
-  // analysis, so a boundary is never inert and never import-only), which is
-  // why this needs no non-empty guard.
-  if (opts.instrumentationClient) {
-    const u = toUrlPath(opts.instrumentationClient, opts.appDir);
-    const i = urls.indexOf(u);
-    if (i !== -1) urls.splice(i, 1);
-    urls.unshift(u);
-  }
-  return urls;
+  // The happy path's own assembly (`shipped-modules.js`), un-memoized because a
+  // boundary's file list is built per render. instrumentation-client.{js,ts}
+  // (#848) rides the SAME first-import contract it has on the happy path: it
+  // runs before app modules so the app's client error reporting is installed
+  // before anything can throw, and a boundary page is where that matters most.
+  // `lazyFiles` is deliberately not passed: a boundary render has no lazy map
+  // of its own to register a diverted frontier component with, so a `static
+  // lazy` component imported by a boundary is imported eagerly, as before.
+  return assembleBootModules(boundaryFile ? [boundaryFile, ...wrapLayouts] : wrapLayouts, {
+    appDir: opts.appDir,
+    inert: opts.inertRouteModules,
+    importOnly: opts.importOnlyRouteModules,
+    lazyFiles: undefined,
+    instrumentationClient: opts.instrumentationClient,
+  }).moduleUrls;
 }
 
 /**
@@ -1113,37 +1100,19 @@ export async function ssrPage(route, params, url, opts) {
     // lazy loader instead of imported, exactly as a shipping module's served
     // source defers its side-effect import of one, so the boot never fetches
     // it up front and a tag revealed later still loads on first sight.
-    const inert = opts.inertRouteModules;
-    const importOnly = opts.importOnlyRouteModules;
+    //
+    // The assembly itself lives in `shipped-modules.js` (#1644), shared with
+    // the Node listener's 103 Early Hints and memoized per route object and
+    // build epoch; nothing below mutates `moduleUrls`, which is what lets the
+    // memoized array be handed out as is.
     const lazyFiles = opts.lazyComponentFiles;
-    const moduleUrls = [];
-    /** @type {Record<string, string>} */
-    const frontierLazy = {};
-    {
-      const seen = new Set();
-      const push = (abs) => {
-        const u = toUrlPath(abs, opts.appDir);
-        const tags = lazyFiles && lazyFiles.get(abs);
-        if (tags) { for (const t of tags) frontierLazy[t] = u; return; }
-        if (!seen.has(u)) { seen.add(u); moduleUrls.push(u); }
-      };
-      for (const f of [route.file, ...route.layouts]) {
-        if (inert && inert.has(f)) continue;
-        const emit = importOnly && importOnly.get(f);
-        if (emit) emit.forEach(push);
-        else push(f);
-      }
-    }
-    // instrumentation-client.{js,ts} (#848): import it FIRST in the client boot
-    // so it runs before app modules (Next's instrumentation-client ordering).
-    // It ships even on an otherwise-static page (the app opted into client work),
-    // so it is prepended AFTER the component/page modules are collected.
-    if (opts.instrumentationClient) {
-      const u = toUrlPath(opts.instrumentationClient, opts.appDir);
-      const i = moduleUrls.indexOf(u);
-      if (i !== -1) moduleUrls.splice(i, 1);
-      moduleUrls.unshift(u);
-    }
+    const { moduleUrls, frontierLazy } = shippedBootModules(route, {
+      appDir: opts.appDir,
+      inert: opts.inertRouteModules,
+      importOnly: opts.importOnlyRouteModules,
+      lazyFiles,
+      instrumentationClient: opts.instrumentationClient,
+    });
     // Emit <link rel="modulepreload"> for every custom element that
     // actually rendered PLUS their transitive dependencies (from the
     // module graph). URLs are deduplicated so the browser never sees
@@ -1153,46 +1122,26 @@ export async function ssrPage(route, params, url, opts) {
     const { eager: eagerComponents, lazy: renderedLazy } =
       componentPreloads(suspenseCtx.usedComponents, opts.appDir, opts.elidableComponents, lazyFiles);
     const lazyComponents = { ...frontierLazy, ...renderedLazy };
-    // The preload walks skip a lazy component and the subtree reachable only
-    // through it (#1524), the same way they skip an elided one: the browser
-    // does not fetch it until the loader asks.
-    const preloadSkip = lazyFiles && lazyFiles.size
-      ? new Set([...(opts.elidableComponents || []), ...lazyFiles.keys()])
-      : opts.elidableComponents;
-    // The walk roots for BOTH preload passes are the BOOT's actually-shipped
-    // module set (`moduleUrls`, which already drops inert page/layout modules and
-    // substitutes an import-only page with its components), NOT the raw route
-    // entries `[route.file, ...route.layouts]`. Rooting at the raw entries would
-    // walk a dropped page's SSR-only subtree (a direct import OR a relative
-    // helper) and hint a `modulepreload` for a module nothing that ships imports,
-    // an over-fetch (#780, the app-module analog of the #754 vendor over-fetch).
-    const shippedRoots = moduleUrls.map((u) =>
-      resolve(opts.appDir, u.startsWith('/') ? u.slice(1) : u));
-    const preloads = deduplicatedPreloads(
-      eagerComponents,
+    // Both preload passes (the app-module hints and the vendor hints, #754)
+    // root at the BOOT's shipped set plus the rendered components and skip a
+    // lazy component (#1524) or an elided one and the subtree only it reaches;
+    // `pagePreloadHints` walks that closure ONCE for both (#1644), where the
+    // two passes used to walk it twice. The over-fetch rules (#780, #754) are
+    // documented on the helper.
+    const hints = pagePreloadHints({
+      graph: opts.moduleGraph,
+      appDir: opts.appDir,
       moduleUrls,
-      opts.moduleGraph,
-      shippedRoots,
-      opts.appDir,
-      opts.serverFiles,
-      preloadSkip,
-    );
+      eagerComponents,
+      elidableComponents: opts.elidableComponents,
+      lazyFiles,
+      serverFiles: opts.serverFiles,
+    });
+    const preloads = hints.preloads;
     // Vendor modulepreload (#754): flatten the npm CDN waterfall by hinting the
-    // vendor URLs the page's SHIPPED modules actually import, fetched in parallel
-    // instead of discovered level by level. Same shipped-module roots as the
-    // app-module walk above, so a vendor reached ONLY through a dropped module
-    // (a page's SSR-only direct import OR its SSR-only relative helper) is never
-    // preloaded (no over-fetch).
-    const vendorPreloads = vendorPreloadTargets(
-      reachedVendorSpecifiers(
-        opts.moduleGraph,
-        shippedRoots,
-        eagerComponents,
-        opts.appDir,
-        preloadSkip,
-        opts.serverFiles,
-      ),
-    );
+    // vendor URLs the page's SHIPPED modules actually import, fetched in
+    // parallel instead of discovered level by level.
+    const vendorPreloads = vendorPreloadTargets(hints.vendorSpecifiers);
     // Extract CSP nonce from request headers (if present).
     const nonce = getNonce();
     const wrapOpts = {

package/src/ssr/shipped-modules.js

@@ -0,0 +1,129 @@
+/**
+ * The boot's shipped-module assembly, shared by the SSR render and the 103
+ * Early Hints (#1644).
+ *
+ * For a matched route the client boot imports the page and its layouts MINUS
+ * the inert ones (a module that does no client work, #170), with an
+ * IMPORT-ONLY module (#605) replaced by the component frontier it exists to
+ * import, and a `static lazy` component in that frontier (#1524) diverted to
+ * the lazy loader instead of imported. `ssr/render.js` derived that list per
+ * request, and the Node listener's `routeFor` (the 103 Early Hints) carried a
+ * second copy of the same loop that had drifted: it knew nothing of lazy
+ * files, so a lazy frontier component was early-hinted although the boot
+ * never imports it.
+ *
+ * One function now owns the assembly, memoized per ROUTE OBJECT in a WeakMap
+ * (the route table is rebuilt per build, so a stale entry dies with its
+ * route, and a dynamic route cannot grow the memo the way a pathname key
+ * would) and validated against the build epoch (the inert / import-only /
+ * lazy sets are per-build inputs). The hinted url list, the same modules
+ * through `withBasePath` then `withAssetHash`, is memoized beside it so a
+ * warm GET costs one WeakMap lookup.
+ */
+import { buildEpoch } from '../build-epoch.js';
+import { withBasePath } from '../base-path.js';
+import { withAssetHash, assetHashMisses } from '../asset-hash.js';
+import { toUrlPath } from './preloads.js';
+
+/**
+ * @typedef {object} ShippedDeps
+ * @property {string} appDir
+ * @property {Set<string> | undefined} inert  inert page / layout files (never shipped)
+ * @property {Map<string, string[]> | undefined} importOnly  import-only module -> the component files emitted in its place
+ * @property {Map<string, string[]> | undefined} lazyFiles  lazy component file -> its tags
+ * @property {string | undefined} instrumentationClient  `instrumentation-client.*`, imported first when present
+ */
+
+/**
+ * @typedef {object} ShippedModules
+ * @property {string[]} moduleUrls  url paths the boot imports, in import order
+ * @property {Record<string, string>} frontierLazy  tag -> url for lazy components diverted out of the frontier
+ */
+
+/** @type {WeakMap<object, { epoch: number, value: ShippedModules, hinted: string[] | null, hintedBasePath: string }>} */
+const MEMO = new WeakMap();
+
+/**
+ * The modules the client boot imports for `route`, plus the lazy frontier it
+ * registers instead. Same object back for the same route within a build.
+ *
+ * @param {{ file: string, layouts: string[] }} route  the matched route (its object identity is the memo key)
+ * @param {ShippedDeps} deps
+ * @returns {ShippedModules}
+ */
+export function shippedBootModules(route, deps) {
+  const hit = MEMO.get(route);
+  if (hit && hit.epoch === buildEpoch()) return hit.value;
+  const value = assembleBootModules([route.file, ...route.layouts], deps);
+  MEMO.set(route, { epoch: buildEpoch(), value, hinted: null, hintedBasePath: '' });
+  return value;
+}
+
+/**
+ * The assembly itself, un-memoized: the one loop behind `shippedBootModules`
+ * (a matched page and its layouts) and the boundary render in `ssr/render.js`
+ * (an error / not-found / forbidden / unauthorized file and the layouts it is
+ * wrapped in, a per-render list with no stable object to key a memo on). One
+ * function so the two cannot drift, which is how the 103 Early Hints lost the
+ * lazy-frontier rule before #1644.
+ *
+ * @param {string[]} files  the route modules in import order (page or boundary first, then its layouts)
+ * @param {ShippedDeps} deps
+ * @returns {ShippedModules}
+ */
+export function assembleBootModules(files, deps) {
+  const { appDir, inert, importOnly, lazyFiles, instrumentationClient } = deps;
+  /** @type {string[]} */
+  const moduleUrls = [];
+  /** @type {Record<string, string>} */
+  const frontierLazy = {};
+  const seen = new Set();
+  const push = (/** @type {string} */ abs) => {
+    const u = toUrlPath(abs, appDir);
+    const tags = lazyFiles && lazyFiles.get(abs);
+    if (tags) { for (const t of tags) frontierLazy[t] = u; return; }
+    if (!seen.has(u)) { seen.add(u); moduleUrls.push(u); }
+  };
+  for (const f of files) {
+    if (inert && inert.has(f)) continue;
+    const emit = importOnly && importOnly.get(f);
+    if (emit) emit.forEach(push);
+    else push(f);
+  }
+  // instrumentation-client.{js,ts} (#848): import it FIRST in the client boot
+  // so it runs before app modules (Next's instrumentation-client ordering).
+  // It ships even on an otherwise-static page (the app opted into client work).
+  if (instrumentationClient) {
+    const u = toUrlPath(instrumentationClient, appDir);
+    const i = moduleUrls.indexOf(u);
+    if (i !== -1) moduleUrls.splice(i, 1);
+    moduleUrls.unshift(u);
+  }
+  return { moduleUrls, frontierLazy };
+}
+
+/**
+ * The 103 Early Hints url list for `route`: the SAME modules the boot
+ * imports, through `withBasePath` then `withAssetHash`, so the hint warms
+ * exactly the url the body requests (#243). Memoized beside the assembly.
+ *
+ * @param {{ file: string, layouts: string[] }} route
+ * @param {ShippedDeps} deps
+ * @param {string} basePath  the normalized `webjs.basePath` (`''` at a root mount)
+ * @returns {string[]}
+ */
+export function hintedBootModules(route, deps, basePath) {
+  const { moduleUrls } = shippedBootModules(route, deps);
+  const entry = /** @type {NonNullable<ReturnType<typeof MEMO.get>>} */ (MEMO.get(route));
+  if (entry.hinted && entry.hintedBasePath === basePath) return entry.hinted;
+  // Not stored when a hash read failed transiently while computing it
+  // (`assetHashMisses` moved): the list is served with the un-fingerprinted
+  // url, and the next request re-attempts the read (see `asset-hash.js`).
+  const missesBefore = assetHashMisses();
+  const hinted = moduleUrls.map((u) => withAssetHash(withBasePath(u, basePath), basePath));
+  if (assetHashMisses() === missesBefore) {
+    entry.hinted = hinted;
+    entry.hintedBasePath = basePath;
+  }
+  return hinted;
+}