@webjsdev/server 0.8.91 → 0.10.0

package/src/ssr/head.js

@@ -305,7 +305,7 @@ export function collectHoistedHeadTags(bodyHtml) {
  * (breaks the ES-module waterfall without a bundler) and any user-declared
  * `metadata.preload` entries.
  *
- * @param {{ metadata: Record<string,any>, moduleUrls: string[], dev: boolean, streaming: boolean, preloads?: string[], lazyComponents?: Record<string, string>, nonce?: string }} opts
+ * @param {{ metadata: Record<string,any>, moduleUrls: string[], dev: boolean, streaming: boolean, preloads?: string[], lazyComponents?: Record<string, string>, nonce?: string, pageUrl?: string }} opts
  */
 /**
  * Extract leading `<script>`, `<style>`, and `<link>` tags from the body
@@ -323,13 +323,161 @@ export function hoistHeadTags(headHtml, bodyHtml) {
   // streaming path so both hoist identically. See collectHoistedHeadTags.
   const { tags: hoisted, body: remaining } = collectHoistedHeadTags(bodyHtml);
   if (!hoisted.length) return { head: headHtml, body: bodyHtml };
-  const newHead = headHtml.replace('</head>', hoisted.join('\n') + '\n</head>');
+  const newHead = headHtml.replace('</head>', () => hoisted.join('\n') + '\n</head>');
   return { head: newHead, body: remaining };
 }
 
 /** Internal helper re-exported for unit testing. */
 export const _hoistHeadTags = hoistHeadTags;
 
+/**
+ * The attribute naming the boundary a hoisted stylesheet came from (#1669).
+ * Its value is the SEGMENT of the `wj:children` range the link was rendered
+ * in: a nested layout's own markup sits inside its parent's range, and a
+ * page's inside its own boundary or its innermost layout's. The client router
+ * switches the sheet off when it swaps that range and the incoming page no
+ * longer links the same file, so a section's stylesheet leaves with the
+ * section, and switches it back on when a later page links it again.
+ */
+export const STYLE_OWNER_ATTR = 'data-wj-style-owner';
+
+const BOUNDARY_OPEN = '<!--wj:children:';
+// One token of a leading run after a boundary marker: a comment that is not a
+// client-router marker, or a `<link>` tag (quote-aware, like the root hoist).
+// Sticky, so it matches at `lastIndex` without copying the rest of the body.
+const OWNED_RUN_TOKEN_RE =
+  /\s*(<!--(?!\/?wj:)[\s\S]*?-->|<link\b(?:[^>"']|"[^"]*"|'[^']*')*>)/iy;
+const LINK_TAG_RE = /<link\b(?:[^>"']|"[^"]*"|'[^']*')*>/gi;
+
+// One attribute after the tag name, read in order so a quoted value is
+// consumed whole and never mistaken for another attribute.
+const ATTR_RE = /\s*([^\s"'>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/y;
+
+/**
+ * A tag's attributes, lowercased names to raw values (the first of a repeated
+ * name wins, as in HTML).
+ * @param {string} tag
+ * @returns {Map<string, string>}
+ */
+function tagAttrs(tag) {
+  /** @type {Map<string, string>} */
+  const out = new Map();
+  const start = /^<[a-zA-Z][^\s/>]*/.exec(tag);
+  let pos = start ? start[0].length : 0;
+  for (;;) {
+    ATTR_RE.lastIndex = pos;
+    const m = ATTR_RE.exec(tag);
+    if (!m || m[0].length === 0) break;
+    pos += m[0].length;
+    const name = m[1].toLowerCase();
+    if (!out.has(name)) out.set(name, m[2] ?? m[3] ?? m[4] ?? '');
+  }
+  return out;
+}
+
+/**
+ * The identity of a stylesheet `<link>`, or null when the tag is not an
+ * active one (`rel` naming `stylesheet` and not `alternate`, with an href).
+ * The URL the href resolves to against the page's own URL (`base`), plus the
+ * `media` it applies under, so `./a.css` and `/a.css` on one page are one
+ * sheet and a print sheet and a screen sheet of one file are two. The router
+ * keys its sheets the same way (owned-styles.js). With no base the href is
+ * used as written.
+ * @param {string} tag
+ * @param {string} [base]
+ * @returns {string | null}
+ */
+function stylesheetTagKey(tag, base) {
+  const attrs = tagAttrs(tag);
+  const rel = (attrs.get('rel') || '').toLowerCase().split(/\s+/);
+  let href = attrs.get('href');
+  if (!rel.includes('stylesheet') || rel.includes('alternate') || !href) return null;
+  if (base) { try { href = new URL(href, base).href; } catch { /* keep as written */ } }
+  const media = (attrs.get('media') || '').trim();
+  return media && media !== 'all' ? `${href} ${media}` : href;
+}
+
+/**
+ * The keys (`stylesheetTagKey`) of every stylesheet `<link>` in an HTML string.
+ * @param {string} html
+ * @param {string} [base]  The page's URL, which hrefs resolve against.
+ * @returns {Set<string>}
+ */
+export function stylesheetKeys(html, base) {
+  const out = new Set();
+  for (const m of html.matchAll(LINK_TAG_RE)) {
+    const key = stylesheetTagKey(m[0], base);
+    if (key) out.add(key);
+  }
+  return out;
+}
+
+/**
+ * Hoist the stylesheet links at the start of each nested layout's and page's
+ * output into `<head>` (#1669). The root hoist (`collectHoistedHeadTags`) only
+ * reads the leading run of the WHOLE body and stops at the first boundary
+ * marker, so a section layout's `<link rel="stylesheet">` stayed in `<body>`,
+ * where it is not reliably render-blocking (#406). This reads the leading run
+ * after EVERY `<!--wj:children:...-->` open marker instead.
+ *
+ * Only `rel="stylesheet"` links move, each tagged with `STYLE_OWNER_ATTR` set
+ * to the marker's segment. Comments and other `<link>` tags in the run stay
+ * where they are and do not end it; anything else does. A stylesheet whose
+ * href and media are already in `seen` (the head so far, or an earlier
+ * hoist) is dropped rather than hoisted twice, since one URL linked twice is
+ * two active sheets the browser matches every rule against. Every framework
+ * the WebJs router takes cues from puts a route's sheet in the head and
+ * dedupes by href. Attributes are read in order (`tagAttrs`), so a name
+ * inside another attribute's quoted value is never mistaken for one.
+ *
+ * @param {string} bodyHtml
+ * @param {Set<string>} [seen]  Keys (`stylesheetKeys`) already linked in the head (mutated).
+ * @param {string} [base]  The page's URL, which hrefs resolve against for the key.
+ * @returns {{ tags: string[], body: string }}
+ */
+export function hoistOwnedStylesheets(bodyHtml, seen = new Set(), base) {
+  if (!bodyHtml.includes(BOUNDARY_OPEN)) return { tags: [], body: bodyHtml };
+  /** @type {string[]} */
+  const tags = [];
+  let out = '';
+  let pos = 0;
+  for (;;) {
+    const open = bodyHtml.indexOf(BOUNDARY_OPEN, pos);
+    if (open < 0) break;
+    const close = bodyHtml.indexOf('-->', open);
+    if (close < 0) break;
+    const markerEnd = close + 3;
+    out += bodyHtml.slice(pos, markerEnd);
+    // The route-key is everything after the LAST ':' (the router's own split,
+    // boundaries.js), so the segment is everything before it.
+    const rest = bodyHtml.slice(open + BOUNDARY_OPEN.length, close);
+    const cut = rest.lastIndexOf(':');
+    const segment = cut > 0 ? rest.slice(0, cut) : null;
+    pos = markerEnd;
+    if (!segment) continue;
+    let m;
+    for (;;) {
+      OWNED_RUN_TOKEN_RE.lastIndex = pos;
+      m = OWNED_RUN_TOKEN_RE.exec(bodyHtml);
+      if (!m) break;
+      const token = m[1];
+      const lead = m[0].slice(0, m[0].length - token.length);
+      pos += m[0].length;
+      const key = token.startsWith('<!--') ? null : stylesheetTagKey(token, base);
+      if (!key) {
+        out += lead + token;
+        continue;
+      }
+      out += lead;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const owner = ` ${STYLE_OWNER_ATTR}="${escapeAttr(segment)}">`;
+      tags.push(token.replace(/\s*\/?>$/, () => owner));
+    }
+  }
+  return { tags, body: out + bodyHtml.slice(pos) };
+}
+
 /**
  * The initial-load Suspense resolver: swaps each streamed
  * `<template data-webjs-resolve>` into its placeholder.
@@ -491,28 +639,22 @@ export function wrapHead(opts) {
   }
   metaTags.push(`<meta name="viewport" content="${escapeAttr(viewportStr || 'width=device-width,initial-scale=1')}">`);
 
-  if (m.themeColor) metaTags.push(`<meta name="theme-color" content="${escapeAttr(m.themeColor)}">`);
+  // themeColor: a string, a `{ color, media? }` descriptor, or an array of
+  // them (Next's viewport shape): one <meta> per descriptor.
+  for (const tc of themeColorList(m.themeColor)) {
+    const media = tc.media ? ` media="${escapeAttr(tc.media)}"` : '';
+    metaTags.push(`<meta name="theme-color" content="${escapeAttr(tc.color)}"${media}>`);
+  }
   if (m.colorScheme) metaTags.push(`<meta name="color-scheme" content="${escapeAttr(m.colorScheme)}">`);
 
-  // robots: { index, follow, googleBot, etc. }
+  // robots: a string or Next's object (index, follow, the directive keys, and
+  // a nested `googleBot` resolved the same way into <meta name="googlebot">).
   if (m.robots) {
-    if (typeof m.robots === 'string') {
-      metaTags.push(`<meta name="robots" content="${escapeAttr(m.robots)}">`);
-    } else if (typeof m.robots === 'object') {
-      const parts = [];
-      if (m.robots.index === false) parts.push('noindex');
-      else if (m.robots.index === true) parts.push('index');
-      if (m.robots.follow === false) parts.push('nofollow');
-      else if (m.robots.follow === true) parts.push('follow');
-      if (m.robots.noarchive) parts.push('noarchive');
-      if (m.robots.nosnippet) parts.push('nosnippet');
-      if (m.robots.noimageindex) parts.push('noimageindex');
-      if (parts.length) {
-        metaTags.push(`<meta name="robots" content="${escapeAttr(parts.join(', '))}">`);
-      }
-      if (typeof m.robots.googleBot === 'string') {
-        metaTags.push(`<meta name="googlebot" content="${escapeAttr(m.robots.googleBot)}">`);
-      }
+    const basic = resolveRobotsValue(m.robots);
+    if (basic) metaTags.push(`<meta name="robots" content="${escapeAttr(basic)}">`);
+    if (typeof m.robots === 'object') {
+      const gb = resolveRobotsValue(m.robots.googleBot);
+      if (gb) metaTags.push(`<meta name="googlebot" content="${escapeAttr(gb)}">`);
     }
   }
 
@@ -722,8 +864,8 @@ export function wrapHead(opts) {
   // above. `vendorPreloadTargets` still excludes core deliberately; this hint
   // is emitted from the head builder, not the vendor path.
   //
-  // Gated on the boot actually shipping something. A fully elided page ships no
-  // boot module and must not be handed a preload for a runtime it never loads
+  // Gated on the boot actually shipping something. A page with no component
+  // ships no boot module and must not be handed a preload for a runtime it never loads
   // (#780), which also keeps it off `global-error.{js,ts}`, whose document is
   // returned verbatim with no importmap and no boot script.
   if (opts.moduleUrls.length || lazyEntries) {
@@ -961,6 +1103,13 @@ export function wrapHead(opts) {
   // conditional line makes the CSP-off document one newline shorter than the
   // CSP-on one, and the framework guarantees the two render identically
   // apart from the nonce itself.
+  //
+  // The dev reload client goes BEFORE the boot script (#1689): module scripts
+  // run in document order, and it installs the hot client (the template
+  // interner core's `html()` reads) that has to exist before the first
+  // component module evaluates. It sits on the boot's own line and the blank
+  // line after the boot is where it used to be, so a production document,
+  // which has no reload client, is unchanged.
   const title = m.title || 'webjs app';
 
   return `<!doctype html>
@@ -974,10 +1123,64 @@ ${metaTags.join('\n')}
 ${publicEnvShim({ dev: opts.dev, nonce: opts.nonce })}${embedScriptTag({ dev: opts.dev, nonce: opts.nonce })}${clientRouterEnabled() ? '' : `\n<script${n}>window.__WEBJS_CLIENT_ROUTER__=false;</script>`}
 ${importMapTag({ nonce: opts.nonce })}
 ${linkTags.join('\n')}
-${scriptTags.length ? scriptTags.join('\n') + '\n' : ''}${boot}
-${reload}
+${reload}${scriptTags.length ? scriptTags.join('\n') + '\n' : ''}${boot}
+
 ${suspenseBoot}
 </head>
 <body>
 `;
 }
+
+/** Next's robot directive keys, in its emit order. */
+const ROBOTS_KEYS = [
+  'noarchive', 'nosnippet', 'noimageindex', 'nocache', 'notranslate', 'indexifembedded',
+  'nositelinkssearchbox', 'unavailable_after', 'max-video-preview', 'max-image-preview', 'max-snippet',
+];
+
+/**
+ * A port of Next.js's `resolveRobotsValue` (resolve-basics.ts): a string
+ * passes through; an object becomes `index` / `noindex`, `follow` /
+ * `nofollow`, then each set directive key (`key` for `true`,
+ * `key:value` otherwise).
+ * @param {unknown} robots
+ * @returns {string | null}
+ */
+export function resolveRobotsValue(robots) {
+  if (!robots) return null;
+  if (typeof robots === 'string') return robots;
+  if (typeof robots !== 'object') return null;
+  const r = /** @type {Record<string, unknown>} */ (robots);
+  const values = [];
+  if (r.index) values.push('index');
+  else if (typeof r.index === 'boolean') values.push('noindex');
+  if (r.follow) values.push('follow');
+  else if (typeof r.follow === 'boolean') values.push('nofollow');
+  for (const key of ROBOTS_KEYS) {
+    const value = r[key];
+    if (typeof value !== 'undefined' && value !== false) {
+      values.push(typeof value === 'boolean' ? key : `${key}:${value}`);
+    }
+  }
+  return values.length ? values.join(', ') : null;
+}
+
+/**
+ * Normalize Next's `themeColor` (a string, a descriptor, or an array of
+ * descriptors) to a list of `{ color, media? }`.
+ * @param {unknown} v
+ * @returns {{ color: string, media?: string }[]}
+ */
+export function themeColorList(v) {
+  if (!v) return [];
+  if (typeof v === 'string') return [{ color: v }];
+  const list = Array.isArray(v) ? v : [v];
+  /** @type {{ color: string, media?: string }[]} */
+  const out = [];
+  for (const d of list) {
+    if (typeof d === 'string') out.push({ color: d });
+    else if (d && typeof d === 'object' && typeof d.color === 'string') {
+      out.push(typeof d.media === 'string' ? { color: d.color, media: d.media } : { color: d.color });
+    }
+  }
+  return out;
+}

package/src/ssr/preloads.js

@@ -31,21 +31,16 @@ export function toUrlPath(file, appDir) {
  * are NOT preloaded: they're loaded by the IntersectionObserver-based
  * lazy-loader when the element enters the viewport.
  *
- * Elidable (display-only) components are skipped entirely: their imports
- * are stripped from the served source, so preloading their module would
- * fetch JS the browser never executes.
- *
  * A tag counts as lazy when its class says so at runtime (`isLazy`) OR its
  * file declares `static lazy = true` in source (`lazyFiles`, #1524), the same
  * per-file verdict the served-source rewrite uses, so the two never disagree.
  *
  * @param {Set<string>} usedTags
  * @param {string} appDir
- * @param {Set<string>} [elidable]  absolute paths of elidable component files
  * @param {Map<string, string[]>} [lazyFiles]  lazy component file -> its tags
  * @returns {{ eager: string[], lazy: Record<string, string> }}
  */
-export function componentPreloads(usedTags, appDir, elidable, lazyFiles) {
+export function componentPreloads(usedTags, appDir, lazyFiles) {
   const eager = [];
   /** @type {Record<string, string>} */
   const lazy = {};
@@ -55,7 +50,6 @@ export function componentPreloads(usedTags, appDir, elidable, lazyFiles) {
     try {
       const abs = fileURLToPath(fileUrl);
       if (!abs.startsWith(appDir)) continue;
-      if (elidable && elidable.has(abs)) continue;
       const url = toUrlPath(abs, appDir);
       if (isLazy(tag) || (lazyFiles && lazyFiles.has(abs))) {
         lazy[tag] = url;
@@ -90,13 +84,13 @@ export function componentPreloads(usedTags, appDir, elidable, lazyFiles) {
  * @param {import('../module-graph.js').ModuleGraph | undefined} graph
  * @param {string[]} entryFiles     absolute paths of the SHIPPED page/layout modules (from `moduleUrls`)
  * @param {string} appDir
- * @param {Set<string>} [elidableComponents]  absolute paths to skip in the walk
  * @param {Set<string>} [serverFiles]  the action / server-file index, never preloaded
+ * @param {Set<string>} [skip]  absolute paths to skip in the walk (the lazy files)
  * @param {string[]} [precomputedDeps]  the transitive closure `pagePreloadHints` already walked for
  *   THESE roots and THIS skip set. Omitted, the walk runs here (a direct caller)
  * @returns {string[]}
  */
-export function deduplicatedPreloads(componentUrls, moduleUrls, graph, entryFiles, appDir, serverFiles, elidableComponents, precomputedDeps) {
+export function deduplicatedPreloads(componentUrls, moduleUrls, graph, entryFiles, appDir, serverFiles, skip, precomputedDeps) {
   const seen = new Set(moduleUrls);
   const result = [];
 
@@ -133,10 +127,9 @@ export function deduplicatedPreloads(componentUrls, moduleUrls, graph, entryFile
         const abs = resolve(appDir, url.startsWith('/') ? url.slice(1) : url);
         allEntries.push(abs);
       }
-      // Skip elidable components and any subtree reachable only through
-      // them: their imports are stripped from served source, so the
-      // browser never fetches these modules.
-      deps = transitiveDeps(graph, allEntries, appDir, elidableComponents);
+      // Skip the lazy components and any subtree reachable only through
+      // them: the lazy loader fetches those on first sight, not up front.
+      deps = transitiveDeps(graph, allEntries, appDir, skip);
     }
     for (const dep of deps) {
       if (byIndex(dep)) continue;
@@ -153,11 +146,11 @@ export function deduplicatedPreloads(componentUrls, moduleUrls, graph, entryFile
 /**
  * Collect the bare npm vendor specifiers the page's SHIPPED modules import
  * (#754). The walk ROOTS are the boot's actually-shipped module set: the caller
- * passes `entryFiles` = the absolute paths of `moduleUrls` (which already drops
- * inert page/layout modules and substitutes an import-only page with its
- * components), plus `componentUrls` = the rendered components. From those roots
- * it walks the transitive app-graph closure (elidable components and the subtree
- * reachable only through them excluded), and collects each reached file's bare
+ * passes `entryFiles` = the absolute paths of `moduleUrls` (the components each
+ * route module renders, never a route module itself, #1686), plus
+ * `componentUrls` = the rendered components. From those roots it walks the
+ * transitive app-graph closure (the lazy components and the subtree reachable
+ * only through them excluded), and collects each reached file's bare
  * imports, excluding server files. The specifiers are resolved to `modulepreload`
  * targets via the vendor importmap; a specifier not in the map (unpinned /
  * unreached) drops out there.
@@ -166,35 +159,34 @@ export function deduplicatedPreloads(componentUrls, moduleUrls, graph, entryFile
  * dropped from the boot, whether a dropped page's SSR-only DIRECT vendor import
  * or its SSR-only RELATIVE HELPER's vendor, is never collected: the dropped
  * module is not a root, and nothing that ships imports it (pages/layouts are not
- * importable). So the canonical SSR-only-dependency pattern (which elision keeps
- * off the client) is never preloaded (no over-fetch).
+ * importable). So the canonical SSR-only-dependency pattern is never preloaded
+ * (no over-fetch).
  *
  * @param {import('../module-graph.js').ModuleGraph | undefined} graph
  * @param {string[]} entryFiles  absolute paths of the SHIPPED page/layout modules (from `moduleUrls`)
  * @param {string[]} componentUrls  rendered eager component URL paths
  * @param {string} appDir
- * @param {Set<string>} [elidableComponents]
+ * @param {Set<string>} [skip]  absolute paths to skip in the walk (the lazy files)
  * @param {Set<string>} [serverFiles]  the action / server-file index (`'use server'`, incl. no-`.server.` files)
  * @param {string[]} [precomputedDeps]  the transitive closure `pagePreloadHints` already walked for
  *   THESE roots and THIS skip set. Omitted, the walk runs here (a direct caller)
  * @returns {Set<string>}
  */
-export function reachedVendorSpecifiers(graph, entryFiles, componentUrls, appDir, elidableComponents, serverFiles, precomputedDeps) {
+export function reachedVendorSpecifiers(graph, entryFiles, componentUrls, appDir, skip, serverFiles, precomputedDeps) {
   /** @type {Set<string>} */
   const specs = new Set();
   if (!graph) return specs;
   const bare = bareImports(graph);
   if (!bare.size) return specs;
-  // Roots = the SHIPPED page/layout modules (already inert-dropped + import-only
-  // expanded by the caller) + the rendered components, keyed by the graph's own
-  // absolute paths. Walk their non-elided transitive closure, unless
+  // Roots = the boot's shipped modules + the rendered components, keyed by the
+  // graph's own absolute paths. Walk their transitive closure, unless
   // `pagePreloadHints` already walked it for this render (#1644).
   const allEntries = [...entryFiles];
   for (const url of componentUrls) {
     allEntries.push(resolve(appDir, url.startsWith('/') ? url.slice(1) : url));
   }
   const files = new Set(allEntries);
-  for (const dep of precomputedDeps || transitiveDeps(graph, allEntries, appDir, elidableComponents)) files.add(dep);
+  for (const dep of precomputedDeps || transitiveDeps(graph, allEntries, appDir, skip)) files.add(dep);
   for (const file of files) {
     // A server file is never served to the browser (its source is an RPC /
     // throw-at-load stub), so a vendor it imports never ships and must NOT be
@@ -211,28 +203,23 @@ export function reachedVendorSpecifiers(graph, entryFiles, componentUrls, appDir
 }
 
 /**
- * The skip set for the preload walks: the elidable components plus, when the
- * app has `static lazy` components (#1524), every lazy file. Built once per
- * lazy map (a per-build object), since it was rebuilt per render (#1644).
- * @type {WeakMap<Map<string, string[]>, WeakMap<Set<string>, Set<string>>>}
+ * The skip set for the preload walks: every `static lazy` component file
+ * (#1524). Built once per lazy map (a per-build object), since it was rebuilt
+ * per render (#1644).
+ * @type {WeakMap<Map<string, string[]>, Set<string>>}
  */
 const SKIP_MEMO = new WeakMap();
-const NO_ELIDABLE = new Set();
 
 /**
- * @param {Set<string> | undefined} elidable
  * @param {Map<string, string[]> | undefined} lazyFiles
  * @returns {Set<string> | undefined}
  */
-function preloadSkipSet(elidable, lazyFiles) {
-  if (!lazyFiles || !lazyFiles.size) return elidable;
-  const key = elidable || NO_ELIDABLE;
-  let byElidable = SKIP_MEMO.get(lazyFiles);
-  if (!byElidable) { byElidable = new WeakMap(); SKIP_MEMO.set(lazyFiles, byElidable); }
-  let skip = byElidable.get(key);
+function preloadSkipSet(lazyFiles) {
+  if (!lazyFiles || !lazyFiles.size) return undefined;
+  let skip = SKIP_MEMO.get(lazyFiles);
   if (!skip) {
-    skip = new Set([...(elidable || []), ...lazyFiles.keys()]);
-    byElidable.set(key, skip);
+    skip = new Set(lazyFiles.keys());
+    SKIP_MEMO.set(lazyFiles, skip);
   }
   return skip;
 }
@@ -245,8 +232,8 @@ function preloadSkipSet(elidable, lazyFiles) {
  * walks it once and hands the closure to both.
  *
  * The walk roots are the BOOT's actually-shipped module set (`moduleUrls`,
- * inert modules already dropped and an import-only page already substituted)
- * plus the rendered eager components, NOT the raw route entries: rooting at
+ * the component frontier of each route module, #1686) plus the rendered eager
+ * components, NOT the raw route entries: rooting at
  * the raw entries would walk a dropped page's SSR-only subtree and hint a
  * `modulepreload` for a module nothing that ships imports (#780, the
  * app-module analog of the #754 vendor over-fetch).
@@ -256,15 +243,14 @@ function preloadSkipSet(elidable, lazyFiles) {
  *   appDir: string,
  *   moduleUrls: string[],
  *   eagerComponents: string[],
- *   elidableComponents: Set<string> | undefined,
  *   lazyFiles: Map<string, string[]> | undefined,
  *   serverFiles: Set<string> | undefined,
  * }} input
  * @returns {{ preloads: string[], vendorSpecifiers: Set<string>, skip: Set<string> | undefined }}
  */
 export function pagePreloadHints(input) {
-  const { graph, appDir, moduleUrls, eagerComponents, elidableComponents, lazyFiles, serverFiles } = input;
-  const skip = preloadSkipSet(elidableComponents, lazyFiles);
+  const { graph, appDir, moduleUrls, eagerComponents, lazyFiles, serverFiles } = input;
+  const skip = preloadSkipSet(lazyFiles);
   const shippedRoots = moduleUrls.map((u) => resolve(appDir, u.startsWith('/') ? u.slice(1) : u));
   /** @type {string[] | undefined} */
   let deps;