@wular/pnext 0.0.1

package/src/compat/client/segment-prefetch.ts

@@ -0,0 +1,375 @@
+import {
+  decodeSegmentPayload,
+  recordSegment,
+  segmentPrefetchCovered,
+  takeSegment,
+} from './segment-cache';
+import { getStaleTimeMs } from '../segment/vary-key';
+
+const SEGMENT_PREFETCH_HEADER = 'next-router-segment-prefetch';
+const APP_SHELL_PREFETCH_HEADER = 'x-pnext-app-shell';
+const INDEX_SEGMENT_PATH = '/_index';
+const TREE_SEGMENT_PATH = '/_tree';
+const RSC_QUERY = '_rsc';
+const SEGMENT_CACHE_LIMIT = 64;
+
+type Priority = 'low' | 'high';
+
+interface SegmentEntry {
+  time: number;
+  staleTimeMs: number;
+}
+
+interface ScheduledPrefetch {
+  controller: AbortController;
+  priority: Priority;
+}
+
+const treeCache = new Map<string, SegmentEntry>();
+const scheduled = new WeakMap<Element, ScheduledPrefetch>();
+const watched = new WeakSet<Element>();
+let observer: IntersectionObserver | undefined;
+let installed = false;
+
+export function installSegmentPrefetchRuntime(): void {
+  if ((!process.browser && typeof window === 'undefined') || installed) return;
+  installed = true;
+  document.addEventListener('pointerover', onIntent, true);
+  document.addEventListener('touchstart', onIntent, { capture: true, passive: true });
+  document.addEventListener('focusin', onIntent, true);
+  watchLinks();
+}
+
+function watchLinks(): void {
+  scanLinks(document.documentElement);
+  const mutations = new MutationObserver(records => {
+    for (const record of records) {
+      for (const node of record.addedNodes) {
+        if (node instanceof Element) scanLinks(node);
+      }
+    }
+  });
+  mutations.observe(document.documentElement, { childList: true, subtree: true });
+}
+
+function scanLinks(root: Element): void {
+  const links = [...root.querySelectorAll<HTMLAnchorElement>('a[data-pnext-link]')];
+  if (root.matches('a[data-pnext-link]')) links.push(root as HTMLAnchorElement);
+  for (const link of links) {
+    if (watched.has(link)) continue;
+    if (link.getAttribute('data-prefetch') === 'false') continue;
+    watched.add(link);
+    observer ??= new IntersectionObserver(onVisibility);
+    observer.observe(link);
+  }
+}
+
+function onVisibility(entries: IntersectionObserverEntry[]): void {
+  for (const entry of entries) {
+    const link = entry.target;
+    if (entry.isIntersecting) {
+      // Revealing a link prefetches the BODY segment too, not just the route
+      // tree: Next's default prefetch fetches the route's static data, and the
+      // shared segment cache is fed from that body response (see
+      // `prefetchSegment`). A tree-only reveal left the cache empty, so the
+      // navigation that follows had nothing cached to paint.
+      schedule(link, 'low');
+    } else {
+      scheduled.get(link)?.controller.abort();
+      scheduled.delete(link);
+    }
+  }
+}
+
+function onIntent(event: Event): void {
+  const link = linkFromEvent(event);
+  if (!link || link.getAttribute('data-prefetch') === 'false') return;
+  scheduled.get(link)?.controller.abort();
+  scheduled.delete(link);
+  schedule(link, 'high');
+}
+
+function schedule(link: Element, priority: Priority): void {
+  const href = link.getAttribute('href');
+  if (!href || isBotUserAgent()) return;
+  const url = softUrl(href);
+  if (!url) return;
+  const current = scheduled.get(link);
+  if (current?.priority === 'high') return;
+  const controller = new AbortController();
+  scheduled.set(link, { controller, priority });
+  void prefetchSegments(url, { priority, signal: controller.signal })
+    // Best-effort: an aborted (link left viewport / superseded) or failed
+    // segment prefetch must never surface as an unhandled rejection — the
+    // client error runtime would swap the live page for the global error.
+    .catch(() => undefined)
+    .finally(() => {
+      if (scheduled.get(link)?.controller === controller) scheduled.delete(link);
+    });
+}
+
+async function prefetchSegments(
+  url: URL,
+  options: { priority: Priority; signal: AbortSignal },
+): Promise<void> {
+  const staleTimeMs = await prefetchSegment(url, TREE_SEGMENT_PATH, options);
+  if (options.signal.aborted) return;
+  await prefetchSegment(url, INDEX_SEGMENT_PATH, options, staleTimeMs);
+}
+
+async function prefetchSegment(
+  url: URL,
+  segment: string,
+  options: { priority: Priority; signal: AbortSignal },
+  fallbackStaleTimeMs = 30_000,
+): Promise<number> {
+  // Dedupe against the VARY-AWARE segment cache, never a second URL-keyed map in
+  // front of it: `recordSegment` files every body response under its vary key, so
+  // a route whose segments read no params already has an entry serving this URL
+  // and re-fetching it is the network request the suites assert never happens.
+  // The tree response carries no vary metadata, so it keeps its own pathname map.
+  if (segment === TREE_SEGMENT_PATH) {
+    const cached = treeCache.get(url.pathname);
+    if (cached && Date.now() - cached.time < cached.staleTimeMs) return cached.staleTimeMs;
+  } else {
+    // A hit alone is not a dedupe: `takeSegment` also returns PAINT-only
+    // entries (a postponed body, a shared shell, another URL's runtime
+    // sample), and those still have real content to fetch. Only a
+    // network-free hit dedupes here. (api/router.ts's
+    // `segmentVaryPrefetchSatisfied` uses the weaker `prefetchSatisfied`; this
+    // is the App-Shell scheduler, whose shells are shared by construction, so
+    // the weaker rule would dedupe away the shell fetch that primes them.)
+    const hit = takeSegment({
+      pathname: url.pathname,
+      search: url.search,
+      segmentPath: INDEX_SEGMENT_PATH,
+    });
+    if (hit?.networkFree === true) return fallbackStaleTimeMs;
+    // …plus the one case `takeSegment` deliberately refuses to share: a PPR
+    // SHELL (postponed, so neither complete nor `x-nextjs-prerender`) whose
+    // published vary set already covers this URL. Nothing about it would differ
+    // if we fetched it again.
+    const covered = segmentPrefetchCovered({
+      pathname: url.pathname,
+      search: url.search,
+      segmentPath: INDEX_SEGMENT_PATH,
+    });
+    if (covered) return fallbackStaleTimeMs;
+  }
+  const response = await fetch(withRscQuery(url.href), {
+    headers: {
+      rsc: '1',
+      'next-router-prefetch': '1',
+      [SEGMENT_PREFETCH_HEADER]: segment,
+    },
+    credentials: 'same-origin',
+    priority: options.priority,
+    signal: options.signal,
+  });
+  if (!response.ok) return fallbackStaleTimeMs;
+  const body = await response.text();
+  const staleTimeMs = getStaleTimeMs(headerStaleTimeSeconds(response));
+  // The RECORDED entry keeps the response's own window: a `stale: 0` /
+  // expireNow payload is born stale by contract, and clamping it would let a
+  // revalidated route serve pre-revalidation bytes for 30s. The floor exists
+  // to stop a prefetch LOOP, so it applies to the dedupe window only.
+  const rawSeconds = headerStaleTimeSeconds(response);
+  const recordStaleTimeMs = (Number.isFinite(rawSeconds) ? rawSeconds : 300) * 1000;
+  if (segment === TREE_SEGMENT_PATH) {
+    treeCache.set(url.pathname, { time: Date.now(), staleTimeMs });
+    trim(treeCache);
+  }
+  // The BODY response is the route's static stage. Recording it into the shared
+  // segment cache is the whole point of the prefetch: without it the payload was
+  // fetched, timed and thrown away, and the navigation that followed a reveal
+  // had nothing to paint (Segment-M2 fix-forward 3). The tree response carries no
+  // markup, so only the body segment is recorded.
+  if (segment === INDEX_SEGMENT_PATH) recordBodySegment(url, response, body, recordStaleTimeMs);
+  return staleTimeMs;
+}
+
+/** File one `/_index` body-prefetch response into the shared segment cache. */
+function recordBodySegment(
+  url: URL,
+  response: Response,
+  body: string,
+  staleTimeMs: number,
+): void {
+  const decoded = decodeSegmentPayload(body, INDEX_SEGMENT_PATH);
+  if (!decoded) return;
+  // Mirrors the router's own segment-prefetch bookkeeping (api/router.ts
+  // recordSegmentEntry): a runtime (request-sampled) shell reports its own
+  // completeness, everything else is complete unless the render postponed.
+  const runtime = response.headers.get('x-pnext-runtime-prefetch') === '1';
+  const complete = runtime
+    ? response.headers.get('x-pnext-runtime-complete') === '1'
+    : response.headers.get('x-pnext-segment-postponed') !== '1';
+  recordSegment({
+    segmentPath: INDEX_SEGMENT_PATH,
+    pathname: url.pathname,
+    search: url.search,
+    html: decoded.html,
+    staleTimeMs,
+    complete,
+    static: response.headers.get('x-nextjs-prerender') === '1',
+    runtime,
+    vary: decoded.vary,
+    route: decoded.route,
+    params: decoded.params,
+  });
+  // A per-URL static prerender of a params-reading route also primes the route's
+  // shared App Shell (no-op unless experimental.appShells is on).
+  scheduleAppShellPrefetch({
+    pathname: url.pathname,
+    route: decoded.route,
+    vary: decoded.vary,
+    static: response.headers.get('x-nextjs-prerender') === '1',
+    complete,
+    runtime,
+  });
+}
+
+/** The response's reported staleness in seconds, NaN when it reported none. */
+function headerStaleTimeSeconds(response: Response): number {
+  const header = response.headers.get('x-nextjs-stale-time');
+  return header === null ? Number.NaN : Number(header);
+}
+
+function withRscQuery(href: string, variant = ''): string {
+  const url = new URL(href, location.href);
+  if (url.searchParams.has(RSC_QUERY)) return url.href;
+  const hash = rscHash(url.pathname + url.search + (variant ? `#${variant}` : ''));
+  const separator = url.search ? '&' : '?';
+  return `${url.origin}${url.pathname}${url.search}${separator}${RSC_QUERY}=${hash}${url.hash}`;
+}
+
+function rscHash(input: string): string {
+  let hash = 0;
+  for (let index = 0; index < input.length; index++) {
+    hash = (Math.imul(31, hash) + input.charCodeAt(index)) | 0;
+  }
+  return (hash >>> 0).toString(36);
+}
+
+function linkFromEvent(event: Event): Element | null {
+  const target = event.target;
+  return target instanceof Element ? target.closest('a[data-pnext-link]') : null;
+}
+
+function softUrl(href: string): URL | null {
+  try {
+    const url = new URL(href, location.href);
+    return url.origin === location.origin ? url : null;
+  } catch {
+    return null;
+  }
+}
+
+function isBotUserAgent(): boolean {
+  return /Googlebot(?!-)|Googlebot$|bingbot|Slurp|DuckDuckBot|Baiduspider|YandexBot/i.test(
+    navigator.userAgent,
+  );
+}
+
+function trim(cache: Map<string, SegmentEntry>): void {
+  while (cache.size > SEGMENT_CACHE_LIMIT) {
+    const oldest = cache.keys().next().value;
+    if (oldest === undefined) return;
+    cache.delete(oldest);
+  }
+}
+
+// App Shells: the second (param-stripped) prefetch.
+//
+// Revealing a link fires the ordinary per-segment prefetch of that exact URL. Under
+// `experimental.appShells` a route whose segments DO read params gets a second request as well: the
+// route's shared App Shell, rendered with `params` hanging. Its vary set comes back EMPTY, so the client
+// files it at the fallback vary path and a navigation to any other param of the same route paints it
+// instantly while the per-URL response streams in.
+//
+// Only ever fired for a route the server answered with a COMPLETE STATIC per-URL prerender: a
+// runtime-prefetch route's own body prefetch already IS the shared shell, and a param-independent
+// response (empty vary set) already serves every URL.
+
+/** Routes whose shared shell has been requested; one request per route, ever. */
+const appShellRequested = new Set<string>();
+
+export interface AppShellPrefetchInput {
+  /** The URL whose per-segment prefetch just landed. */
+  pathname: string;
+  /** Route pattern the response reported (colon form), or null. */
+  route: string | null;
+  /** The response's vary set, or null when it published none. */
+  vary: readonly string[] | null;
+  static: boolean;
+  complete: boolean;
+  runtime: boolean;
+}
+
+export function scheduleAppShellPrefetch(input: AppShellPrefetchInput): void {
+  if (!appShellsEnabled()) return;
+  if (input.runtime || !input.static || !input.complete) return;
+  const route = input.route;
+  // A route with no dynamic segment has nothing to share across params, and a
+  // response that read no params is already the shared entry.
+  if (!route?.includes(':')) return;
+  if (!input.vary || input.vary.length === 0) return;
+  if (appShellRequested.has(route)) return;
+  appShellRequested.add(route);
+  void fetchAppShell(input.pathname).catch(() => {
+    // Best-effort: a failed shell prefetch just means the next navigation to an
+    // unprefetched param of this route waits for its own response.
+    appShellRequested.delete(route);
+  });
+}
+
+async function fetchAppShell(pathname: string): Promise<void> {
+  const response = await fetch(withRscQuery(pathname, 'app-shell'), {
+    headers: {
+      rsc: '1',
+      'next-router-prefetch': '1',
+      [SEGMENT_PREFETCH_HEADER]: INDEX_SEGMENT_PATH,
+      [APP_SHELL_PREFETCH_HEADER]: '1',
+    },
+    credentials: 'same-origin',
+    priority: 'low',
+  });
+  if (!response.ok) return;
+  const decoded = decodeSegmentPayload(await response.text(), INDEX_SEGMENT_PATH);
+  if (!decoded) return;
+  recordSegment({
+    segmentPath: INDEX_SEGMENT_PATH,
+    pathname,
+    search: '',
+    html: decoded.html,
+    // Recorded with the response's own window (NaN → the old 300s fallback):
+    // the 30s floor is a re-prefetch dedupe rule, not a payload lifetime.
+    staleTimeMs: (seconds => (Number.isFinite(seconds) ? seconds : 300) * 1000)(
+      headerStaleTimeSeconds(response),
+    ),
+    // A shell, by construction: the params-dependent subtree is still a hole,
+    // so a navigation paints it and then fetches the per-URL remainder.
+    complete: false,
+    static: response.headers.get('x-nextjs-prerender') === '1',
+    runtime: false,
+    vary: decoded.vary,
+    route: decoded.route,
+    params: decoded.params,
+  });
+}
+
+function appShellsEnabled(): boolean {
+  if (!process.browser && typeof window === 'undefined') return false;
+  return (window as { __PNEXT_APP_SHELLS__?: boolean }).__PNEXT_APP_SHELLS__ === true;
+}
+
+/** Test seam: forget which routes have already primed their shared shell. */
+export function resetAppShellPrefetches(): void {
+  appShellRequested.clear();
+}
+
+/** Drop all prefetch dedupe state — a revalidation invalidated every window. */
+export function resetSegmentPrefetchDedupe(): void {
+  treeCache.clear();
+  appShellRequested.clear();
+}

package/src/compat/client/trailing-slash.ts

@@ -0,0 +1,24 @@
+// Client trailing-slash helper (COMPAT - ships to the browser). Mirrors compat/client/base-path.ts.
+//
+// The server injects `window.__PNEXT_SKIP_TRAILING_SLASH__` when `next.config.skipTrailingSlashRedirect`
+// is set; the server render path reads the globalThis global set when next.config is loaded. With the
+// flag on, Link hrefs and client navigation preserve the author's exact trailing slash instead of
+// normalizing it. A pure-core app never sets the global, so hrefs go through the usual normalization.
+
+declare global {
+  interface Window {
+    __PNEXT_SKIP_TRAILING_SLASH__?: boolean;
+  }
+  var __PNEXT_SKIP_TRAILING_SLASH__: boolean | undefined;
+}
+
+/**
+ * True when `skipTrailingSlashRedirect` is configured. Isomorphic: the client
+ * reads the `window` global the render layer injects; the server reads the
+ * `globalThis` global set when next.config loads. Neither branch imports the
+ * esbuild-backed config loader, so this stays safe to ship to the browser.
+ */
+export function skipTrailingSlashRedirect(): boolean {
+  if (process.browser || typeof window !== 'undefined') return window.__PNEXT_SKIP_TRAILING_SLASH__ === true;
+  return globalThis.__PNEXT_SKIP_TRAILING_SLASH__ === true;
+}

package/src/compat/css/chunking.ts

@@ -0,0 +1,254 @@
+// CSS chunking (COMPAT - Next `experimental.cssChunking`).
+//
+// A faithful port of Next's webpack CssChunkingPlugin (strict variant). Next merges a route's ordered
+// CSS modules into as few <link> requests as possible without ever reordering a stylesheet relative to
+// any other route that shares it, splitting again when a chunk would grow past MAX_CSS_CHUNK_SIZE or
+// when a global stylesheet would leak into a route that does not import it.
+//
+// pnext ships one mode-blind build, so the STRICT algorithm runs: it produces the request counts the
+// css-order suite asserts for conflict routes - which only exercise the strict expectation - while
+// leaving the non-conflict routes at the same count strict and loose both expect.
+//
+// The result crosses the core boundary as `Map<routeId, string[][]>`: each inner array is one chunk's
+// ordered slice of that route's `cssImports`, and the slices partition the route's imports in order.
+// The output is per-route, which is invisible to the suite: it only checks each page's <link> count and
+// computed cascade order, never cross-page asset identity.
+
+import { statSync } from 'node:fs';
+import { getNextConfig } from '../next/config-loader';
+
+// Merge chunks until they pass this size; avoid merging past MAX. Mirrors Next.
+const MIN_CSS_CHUNK_SIZE = 30 * 1024;
+const MAX_CSS_CHUNK_SIZE = 100 * 1024;
+
+interface RouteCss {
+  id: string;
+  cssImports: string[];
+}
+
+function isGlobalCss(file: string) {
+  return !/\.module\.(?:css|scss|sass)$/.test(file);
+}
+
+function moduleSize(file: string) {
+  try {
+    return statSync(file).size;
+  } catch {
+    return 0;
+  }
+}
+
+// Partition every route's ordered CSS imports into shared chunks, then project
+// the global grouping back onto each route as ordered contiguous slices.
+export function nextPlanRouteCssChunks(routes: RouteCss[]): Map<string, string[][]> {
+  if (nextCssChunkingMode() === 'loose') return loosePlanRouteCssChunks(routes);
+
+  const sizes = new Map<string, number>();
+  const size = (file: string) => {
+    let value = sizes.get(file);
+    if (value === undefined) {
+      value = moduleSize(file);
+      sizes.set(file, value);
+    }
+    return value;
+  };
+
+  interface ChunkState {
+    modules: string[];
+    requests: number;
+  }
+
+  const chunkStates: ChunkState[] = [];
+  // file -> (chunkState -> index within that route's ordered import list)
+  const statesByModule = new Map<string, Map<ChunkState, number>>();
+  for (const route of routes) {
+    if (route.cssImports.length === 0) continue;
+    const state: ChunkState = { modules: route.cssImports, requests: route.cssImports.length };
+    chunkStates.push(state);
+    route.cssImports.forEach((file, index) => {
+      let byState = statesByModule.get(file);
+      if (!byState) {
+        byState = new Map();
+        statesByModule.set(file, byState);
+      }
+      // A file may repeat within a route; the last index wins (matches Next,
+      // where a module maps to a single position per chunk group).
+      byState.set(state, index);
+    });
+  }
+
+  // Process modules by ascending index-sum so shared prefixes seed chunks first.
+  const ordered = [...statesByModule.keys()].sort((a, b) => {
+    const sum = (file: string) => {
+      let total = 0;
+      for (const index of statesByModule.get(file)!.values()) total += index;
+      return total;
+    };
+    return sum(a) - sum(b) || (a < b ? -1 : 1);
+  });
+  const remaining = new Set(ordered);
+
+  const chunkOfModule = new Map<string, number>();
+  let nextChunkId = 0;
+
+  for (const startModule of remaining) {
+    let globalMode = isGlobalCss(startModule);
+    const claimed = new Map(statesByModule.get(startModule));
+    const chunkModules = new Set([startModule]);
+    let currentSize = size(startModule);
+
+    const potential = new Map<string, Map<ChunkState, number>>();
+    const enqueueNext = (state: ChunkState, index: number) => {
+      const next = state.modules[index + 1];
+      if (next && remaining.has(next) && !chunkModules.has(next)) {
+        potential.set(next, statesByModule.get(next)!);
+      }
+    };
+    for (const [state, index] of claimed) enqueueNext(state, index);
+
+    let progressed = true;
+    while (progressed) {
+      progressed = false;
+
+      // Prefer the candidate that collapses the highest-request chunk group.
+      const candidates = [...potential.entries()].map(([file, states]) => {
+        let maxRequests = 0;
+        for (const state of states.keys()) {
+          if (claimed.has(state)) maxRequests = Math.max(maxRequests, state.requests);
+        }
+        return { file, states, maxRequests };
+      });
+      candidates.sort((a, b) => b.maxRequests - a.maxRequests || (a.file < b.file ? -1 : 1));
+
+      for (const { file, states } of candidates) {
+        const fileSize = size(file);
+        if (currentSize + fileSize > MAX_CSS_CHUNK_SIZE) continue;
+
+        // Strict order preservation: in every route sharing this module its
+        // position must be exactly one past what we've claimed there, otherwise
+        // merging would reorder or interleave stylesheets.
+        let orderOk = true;
+        for (const [state, index] of states) {
+          const claimedIndex = claimed.get(state);
+          if (claimedIndex === undefined) {
+            // A route that doesn't yet overlap: only pull it in while the chunk
+            // is still under the min-size target (Next's merge-up-to-MIN rule).
+            if (currentSize >= MIN_CSS_CHUNK_SIZE) {
+              orderOk = false;
+              break;
+            }
+          } else if (claimedIndex + 1 !== index) {
+            orderOk = false;
+            break;
+          }
+        }
+        if (!orderOk) continue;
+
+        // A global stylesheet must never enter a route that doesn't import it,
+        // and once the chunk carries a global it can't spread to new routes.
+        const nextIsGlobal = isGlobalCss(file);
+        if (globalMode) {
+          let leaks = false;
+          for (const state of states.keys()) {
+            if (!claimed.has(state)) {
+              leaks = true;
+              break;
+            }
+          }
+          if (leaks) continue;
+        }
+        if (nextIsGlobal) {
+          let leaks = false;
+          for (const state of claimed.keys()) {
+            if (!states.has(state)) {
+              leaks = true;
+              break;
+            }
+          }
+          if (leaks) continue;
+        }
+
+        potential.delete(file);
+        currentSize += fileSize;
+        if (nextIsGlobal) globalMode = true;
+        for (const [state, index] of states) {
+          if (claimed.has(state)) state.requests--;
+          claimed.set(state, index);
+          enqueueNext(state, index);
+        }
+        chunkModules.add(file);
+        progressed = true;
+        break;
+      }
+    }
+
+    const chunkId = nextChunkId++;
+    for (const file of chunkModules) {
+      remaining.delete(file);
+      chunkOfModule.set(file, chunkId);
+    }
+  }
+
+  // Project the global grouping back to per-route ordered slices. A chunk's
+  // modules are contiguous in every route (guaranteed by the strict merge), so
+  // each route's imports break cleanly at chunk-id boundaries.
+  const plan = new Map<string, string[][]>();
+  for (const route of routes) {
+    if (route.cssImports.length < 2) continue;
+    const segments: string[][] = [];
+    let current: string[] = [];
+    let currentChunk = -1;
+    for (const file of route.cssImports) {
+      const chunkId = chunkOfModule.get(file) ?? -1;
+      if (chunkId !== currentChunk && current.length > 0) {
+        segments.push(current);
+        current = [];
+      }
+      current.push(file);
+      currentChunk = chunkId;
+    }
+    if (current.length > 0) segments.push(current);
+    // Single segment means core's default single-chunk path already suffices.
+    if (segments.length > 1) plan.set(route.id, segments);
+  }
+  return plan;
+}
+
+function nextCssChunkingMode(): 'loose' | 'strict' {
+  const experimental = getNextConfig().experimental as { cssChunking?: unknown } | undefined;
+  return experimental?.cssChunking === 'loose' || experimental?.cssChunking === undefined
+    ? 'loose'
+    : 'strict';
+}
+
+// Loose mode minimizes each route's stylesheet requests independently. A
+// global stylesheet begins a fresh chunk so it cannot move ahead of styles
+// imported before it; subsequent modules may share that chunk.
+function loosePlanRouteCssChunks(routes: RouteCss[]): Map<string, string[][]> {
+  const plan = new Map<string, string[][]>();
+
+  for (const route of routes) {
+    if (route.cssImports.length < 2) continue;
+
+    const segments: string[][] = [];
+    let current: string[] = [];
+    let currentSize = 0;
+    for (const file of route.cssImports) {
+      const size = moduleSize(file);
+      if (
+        current.length > 0 &&
+        (isGlobalCss(file) || currentSize + size > MAX_CSS_CHUNK_SIZE)
+      ) {
+        segments.push(current);
+        current = [];
+        currentSize = 0;
+      }
+      current.push(file);
+      currentSize += size;
+    }
+    if (current.length > 0) segments.push(current);
+    if (segments.length > 1) plan.set(route.id, segments);
+  }
+
+  return plan;
+}