vinext 0.0.41 → 0.0.42

package/README.md

@@ -558,7 +558,6 @@ These are intentional exclusions:
 
 - **Image optimization doesn't happen at build time.** Remote images work via `@unpic/react` (auto-detects 28 CDN providers). Local images are routed through a `/_vinext/image` endpoint that can resize and transcode on Cloudflare Workers (via the Images binding) in production, but no build-time optimization or static resizing occurs.
 - **Google Fonts are loaded from the CDN, not self-hosted.** No `size-adjust` fallback font metrics. Local fonts work but `@font-face` CSS is injected at runtime, not extracted at build time.
-- **`useSelectedLayoutSegment(s)`** derives segments from the pathname rather than being truly layout-aware. May differ from Next.js in edge cases with parallel routes.
 - **Route segment config** — `runtime` and `preferredRegion` are ignored (everything runs in the same environment).
 - **Node.js production server (`vinext start`)** works for testing but is less complete than Workers deployment. Cloudflare Workers is the primary target.
 - **Native Node modules (sharp, resvg, satori, lightningcss, @napi-rs/canvas)** crash Vite's RSC dev environment. Dynamic OG image/icon routes using these work in production builds but not in dev mode. These are auto-stubbed during `vinext deploy`.

package/dist/build/client-build-config.d.ts

@@ -0,0 +1,119 @@
+import { UserConfig } from "vite";
+
+//#region src/build/client-build-config.d.ts
+/**
+ * Create a manualChunks function for client builds.
+ *
+ * Splits the client bundle into:
+ * - "framework" — React, ReactDOM, and scheduler (loaded on every page)
+ * - "vinext"    — vinext shims (router, head, link, etc.)
+ *
+ * All other vendor code is left to Rollup's default chunk-splitting
+ * algorithm. Rollup automatically deduplicates shared modules into
+ * common chunks based on the import graph — no manual intervention
+ * needed.
+ *
+ * Why not split every npm package into its own chunk?
+ * - Per-package splitting (`vendor-X`) creates 50-200+ chunks for a
+ *   typical app, far exceeding the ~25-request sweet spot for HTTP/2.
+ * - gzip/brotli compress small files poorly — each file restarts with
+ *   an empty dictionary, losing ~5-15% total compressed size vs fewer
+ *   larger chunks (Khan Academy measured +2.5% wire size with 10x
+ *   more files containing less raw code).
+ * - ES module evaluation has per-module overhead that compounds on
+ *   mobile devices.
+ * - No major Vite-based framework (Remix, SvelteKit, Astro, TanStack)
+ *   uses per-package splitting. Next.js only isolates packages >160KB.
+ * - Rollup's graph-based splitting already handles the common case
+ *   well: shared dependencies between routes get their own chunks,
+ *   and route-specific code stays in route chunks.
+ */
+declare function createClientManualChunks(shimsDir: string): (id: string) => string | undefined;
+/**
+ * Rollup output config with manualChunks for client code-splitting.
+ * Used by both CLI builds and multi-environment builds.
+ *
+ * experimentalMinChunkSize merges tiny shared chunks (< 10KB) back into
+ * their importers. This reduces HTTP request count and improves gzip
+ * compression efficiency — small files restart the compression dictionary,
+ * adding ~5-15% wire overhead vs fewer larger chunks.
+ */
+declare function createClientOutputConfig(clientManualChunks: (id: string) => string | undefined): {
+  manualChunks: (id: string) => string | undefined;
+  experimentalMinChunkSize: number;
+};
+declare function createClientCodeSplittingConfig(clientManualChunks: (id: string) => string | undefined): {
+  minSize: number;
+  groups: {
+    name(moduleId: string): string | null;
+  }[];
+};
+/**
+ * Rollup treeshake configuration for production client builds.
+ *
+ * Uses the 'recommended' preset as a safe base, then overrides
+ * moduleSideEffects to strip unused re-exports from npm packages.
+ *
+ * The 'no-external' value for moduleSideEffects means:
+ * - Local project modules: preserve side effects (CSS imports, polyfills)
+ * - node_modules packages: treat as side-effect-free unless exports are used
+ *
+ * This is the single highest-impact optimization for large barrel-exporting
+ * libraries like mermaid, @mui/material, lucide-react, etc. These libraries
+ * re-export hundreds of sub-modules through barrel files. Without this,
+ * Rollup preserves every sub-module even when only a few exports are consumed.
+ *
+ * Why 'no-external' instead of false (global side-effect-free)?
+ * - User code may rely on import-time side effects (e.g., `import './global.css'`)
+ * - 'no-external' is safe for app code while still enabling aggressive DCE for deps
+ *
+ * Why not the 'smallest' preset?
+ * - 'smallest' also sets propertyReadSideEffects: false and
+ *   tryCatchDeoptimization: false, which can break specific libraries
+ *   that rely on property access side effects or try/catch for feature detection
+ * - 'recommended' + 'no-external' gives most of the benefit with less risk
+ *
+ * @deprecated Use getClientTreeshakeConfigForVite(viteMajorVersion) instead
+ * for Vite version compatibility. Kept for backward compatibility.
+ */
+declare const clientTreeshakeConfig: {
+  preset: "recommended";
+  moduleSideEffects: "no-external";
+};
+/**
+ * Returns treeshake configuration appropriate for the Vite version.
+ *
+ * Rollup (Vite 7) supports presets like "recommended" which set multiple
+ * treeshake options at once. Rolldown (Vite 8+) doesn't support presets,
+ * so we only return moduleSideEffects for Vite 8+.
+ *
+ * The Rollup "recommended" preset sets:
+ * - annotations: true (Rolldown default is also true)
+ * - manualPureFunctions: [] (Rolldown default is also [])
+ * - propertyReadSideEffects: true (Rolldown equivalent is 'always', the default)
+ * - unknownGlobalSideEffects: false (Rolldown default is true — this is a known acceptable
+ *   divergence. Slightly less aggressive DCE on unknown globals, acceptable for client bundles)
+ * - correctVarValueBeforeDeclaration and tryCatchDeoptimization (Rolldown handles these differently)
+ *
+ * The key optimization is moduleSideEffects: "no-external", which is supported
+ * by both bundlers and provides the DCE benefits for barrel-exporting libraries.
+ * It treats node_modules as side-effect-free (enabling aggressive DCE) while
+ * preserving side effects in local code.
+ */
+declare function getClientTreeshakeConfigForVite(viteMajorVersion: number): {
+  moduleSideEffects: "no-external";
+  preset?: undefined;
+} | {
+  preset: "recommended";
+  moduleSideEffects: "no-external";
+};
+type VinextBuildConfig = NonNullable<UserConfig["build"]>;
+type VinextBuildBundlerOptions = NonNullable<VinextBuildConfig["rolldownOptions"]>;
+type VinextBuildConfigWithLegacy = VinextBuildConfig & {
+  rollupOptions?: VinextBuildBundlerOptions;
+};
+declare function getBuildBundlerOptions(build: UserConfig["build"] | undefined): VinextBuildBundlerOptions | undefined;
+declare function withBuildBundlerOptions(viteMajorVersion: number, bundlerOptions: VinextBuildBundlerOptions): Partial<VinextBuildConfigWithLegacy>;
+//#endregion
+export { clientTreeshakeConfig, createClientCodeSplittingConfig, createClientManualChunks, createClientOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfigForVite, withBuildBundlerOptions };
+//# sourceMappingURL=client-build-config.d.ts.map

package/dist/build/client-build-config.js

@@ -0,0 +1,149 @@
+//#region src/build/client-build-config.ts
+/**
+* Extract the npm package name from a module ID (file path).
+* Returns null if not in node_modules.
+*
+* Handles scoped packages (@org/pkg) and pnpm-style paths
+* (node_modules/.pnpm/pkg@ver/node_modules/pkg).
+*/
+function getPackageName(id) {
+	const nmIdx = id.lastIndexOf("node_modules/");
+	if (nmIdx === -1) return null;
+	const rest = id.slice(nmIdx + 13);
+	if (rest.startsWith("@")) {
+		const parts = rest.split("/");
+		return parts.length >= 2 ? parts[0] + "/" + parts[1] : null;
+	}
+	return rest.split("/")[0] || null;
+}
+/**
+* Create a manualChunks function for client builds.
+*
+* Splits the client bundle into:
+* - "framework" — React, ReactDOM, and scheduler (loaded on every page)
+* - "vinext"    — vinext shims (router, head, link, etc.)
+*
+* All other vendor code is left to Rollup's default chunk-splitting
+* algorithm. Rollup automatically deduplicates shared modules into
+* common chunks based on the import graph — no manual intervention
+* needed.
+*
+* Why not split every npm package into its own chunk?
+* - Per-package splitting (`vendor-X`) creates 50-200+ chunks for a
+*   typical app, far exceeding the ~25-request sweet spot for HTTP/2.
+* - gzip/brotli compress small files poorly — each file restarts with
+*   an empty dictionary, losing ~5-15% total compressed size vs fewer
+*   larger chunks (Khan Academy measured +2.5% wire size with 10x
+*   more files containing less raw code).
+* - ES module evaluation has per-module overhead that compounds on
+*   mobile devices.
+* - No major Vite-based framework (Remix, SvelteKit, Astro, TanStack)
+*   uses per-package splitting. Next.js only isolates packages >160KB.
+* - Rollup's graph-based splitting already handles the common case
+*   well: shared dependencies between routes get their own chunks,
+*   and route-specific code stays in route chunks.
+*/
+function createClientManualChunks(shimsDir) {
+	return function clientManualChunks(id) {
+		if (id.includes("node_modules")) {
+			const pkg = getPackageName(id);
+			if (!pkg) return void 0;
+			if (pkg === "react" || pkg === "react-dom" || pkg === "scheduler") return "framework";
+			return;
+		}
+		if (id.startsWith(shimsDir)) return "vinext";
+	};
+}
+/**
+* Rollup output config with manualChunks for client code-splitting.
+* Used by both CLI builds and multi-environment builds.
+*
+* experimentalMinChunkSize merges tiny shared chunks (< 10KB) back into
+* their importers. This reduces HTTP request count and improves gzip
+* compression efficiency — small files restart the compression dictionary,
+* adding ~5-15% wire overhead vs fewer larger chunks.
+*/
+function createClientOutputConfig(clientManualChunks) {
+	return {
+		manualChunks: clientManualChunks,
+		experimentalMinChunkSize: 1e4
+	};
+}
+function createClientCodeSplittingConfig(clientManualChunks) {
+	return {
+		minSize: 1e4,
+		groups: [{ name(moduleId) {
+			return clientManualChunks(moduleId) ?? null;
+		} }]
+	};
+}
+/**
+* Rollup treeshake configuration for production client builds.
+*
+* Uses the 'recommended' preset as a safe base, then overrides
+* moduleSideEffects to strip unused re-exports from npm packages.
+*
+* The 'no-external' value for moduleSideEffects means:
+* - Local project modules: preserve side effects (CSS imports, polyfills)
+* - node_modules packages: treat as side-effect-free unless exports are used
+*
+* This is the single highest-impact optimization for large barrel-exporting
+* libraries like mermaid, @mui/material, lucide-react, etc. These libraries
+* re-export hundreds of sub-modules through barrel files. Without this,
+* Rollup preserves every sub-module even when only a few exports are consumed.
+*
+* Why 'no-external' instead of false (global side-effect-free)?
+* - User code may rely on import-time side effects (e.g., `import './global.css'`)
+* - 'no-external' is safe for app code while still enabling aggressive DCE for deps
+*
+* Why not the 'smallest' preset?
+* - 'smallest' also sets propertyReadSideEffects: false and
+*   tryCatchDeoptimization: false, which can break specific libraries
+*   that rely on property access side effects or try/catch for feature detection
+* - 'recommended' + 'no-external' gives most of the benefit with less risk
+*
+* @deprecated Use getClientTreeshakeConfigForVite(viteMajorVersion) instead
+* for Vite version compatibility. Kept for backward compatibility.
+*/
+const clientTreeshakeConfig = {
+	preset: "recommended",
+	moduleSideEffects: "no-external"
+};
+/**
+* Returns treeshake configuration appropriate for the Vite version.
+*
+* Rollup (Vite 7) supports presets like "recommended" which set multiple
+* treeshake options at once. Rolldown (Vite 8+) doesn't support presets,
+* so we only return moduleSideEffects for Vite 8+.
+*
+* The Rollup "recommended" preset sets:
+* - annotations: true (Rolldown default is also true)
+* - manualPureFunctions: [] (Rolldown default is also [])
+* - propertyReadSideEffects: true (Rolldown equivalent is 'always', the default)
+* - unknownGlobalSideEffects: false (Rolldown default is true — this is a known acceptable
+*   divergence. Slightly less aggressive DCE on unknown globals, acceptable for client bundles)
+* - correctVarValueBeforeDeclaration and tryCatchDeoptimization (Rolldown handles these differently)
+*
+* The key optimization is moduleSideEffects: "no-external", which is supported
+* by both bundlers and provides the DCE benefits for barrel-exporting libraries.
+* It treats node_modules as side-effect-free (enabling aggressive DCE) while
+* preserving side effects in local code.
+*/
+function getClientTreeshakeConfigForVite(viteMajorVersion) {
+	if (viteMajorVersion >= 8) return { moduleSideEffects: "no-external" };
+	return {
+		preset: "recommended",
+		moduleSideEffects: "no-external"
+	};
+}
+function getBuildBundlerOptions(build) {
+	const buildConfig = build;
+	return buildConfig?.rolldownOptions ?? buildConfig?.rollupOptions;
+}
+function withBuildBundlerOptions(viteMajorVersion, bundlerOptions) {
+	return viteMajorVersion >= 8 ? { rolldownOptions: bundlerOptions } : { rollupOptions: bundlerOptions };
+}
+//#endregion
+export { clientTreeshakeConfig, createClientCodeSplittingConfig, createClientManualChunks, createClientOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfigForVite, withBuildBundlerOptions };
+
+//# sourceMappingURL=client-build-config.js.map

package/dist/build/client-build-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-build-config.js","names":[],"sources":["../../src/build/client-build-config.ts"],"sourcesContent":["import type { UserConfig } from \"vite\";\n\n/**\n * Extract the npm package name from a module ID (file path).\n * Returns null if not in node_modules.\n *\n * Handles scoped packages (@org/pkg) and pnpm-style paths\n * (node_modules/.pnpm/pkg@ver/node_modules/pkg).\n */\nfunction getPackageName(id: string): string | null {\n  const nmIdx = id.lastIndexOf(\"node_modules/\");\n  if (nmIdx === -1) return null;\n  const rest = id.slice(nmIdx + \"node_modules/\".length);\n  if (rest.startsWith(\"@\")) {\n    // Scoped package: @org/pkg\n    const parts = rest.split(\"/\");\n    return parts.length >= 2 ? parts[0] + \"/\" + parts[1] : null;\n  }\n  return rest.split(\"/\")[0] || null;\n}\n\n/**\n * Create a manualChunks function for client builds.\n *\n * Splits the client bundle into:\n * - \"framework\" — React, ReactDOM, and scheduler (loaded on every page)\n * - \"vinext\"    — vinext shims (router, head, link, etc.)\n *\n * All other vendor code is left to Rollup's default chunk-splitting\n * algorithm. Rollup automatically deduplicates shared modules into\n * common chunks based on the import graph — no manual intervention\n * needed.\n *\n * Why not split every npm package into its own chunk?\n * - Per-package splitting (`vendor-X`) creates 50-200+ chunks for a\n *   typical app, far exceeding the ~25-request sweet spot for HTTP/2.\n * - gzip/brotli compress small files poorly — each file restarts with\n *   an empty dictionary, losing ~5-15% total compressed size vs fewer\n *   larger chunks (Khan Academy measured +2.5% wire size with 10x\n *   more files containing less raw code).\n * - ES module evaluation has per-module overhead that compounds on\n *   mobile devices.\n * - No major Vite-based framework (Remix, SvelteKit, Astro, TanStack)\n *   uses per-package splitting. Next.js only isolates packages >160KB.\n * - Rollup's graph-based splitting already handles the common case\n *   well: shared dependencies between routes get their own chunks,\n *   and route-specific code stays in route chunks.\n */\nexport function createClientManualChunks(shimsDir: string) {\n  return function clientManualChunks(id: string): string | undefined {\n    // React framework — always loaded, shared across all pages.\n    // Isolating React into its own chunk is the single highest-value\n    // split: it's ~130KB compressed, loaded on every page, and its\n    // content hash rarely changes between deploys.\n    if (id.includes(\"node_modules\")) {\n      const pkg = getPackageName(id);\n      if (!pkg) return undefined;\n      if (pkg === \"react\" || pkg === \"react-dom\" || pkg === \"scheduler\") {\n        return \"framework\";\n      }\n      // Let Rollup handle all other vendor code via its default\n      // graph-based splitting. This produces a reasonable number of\n      // shared chunks (typically 5-15) based on actual import patterns,\n      // with good compression efficiency.\n      return undefined;\n    }\n\n    // vinext shims — small runtime, shared across all pages.\n    // Use the absolute shims directory path to avoid matching user files\n    // that happen to have \"/shims/\" in their path.\n    if (id.startsWith(shimsDir)) {\n      return \"vinext\";\n    }\n\n    return undefined;\n  };\n}\n\n/**\n * Rollup output config with manualChunks for client code-splitting.\n * Used by both CLI builds and multi-environment builds.\n *\n * experimentalMinChunkSize merges tiny shared chunks (< 10KB) back into\n * their importers. This reduces HTTP request count and improves gzip\n * compression efficiency — small files restart the compression dictionary,\n * adding ~5-15% wire overhead vs fewer larger chunks.\n */\nexport function createClientOutputConfig(clientManualChunks: (id: string) => string | undefined) {\n  return {\n    manualChunks: clientManualChunks,\n    experimentalMinChunkSize: 10_000,\n  };\n}\n\nexport function createClientCodeSplittingConfig(\n  clientManualChunks: (id: string) => string | undefined,\n) {\n  return {\n    minSize: 10_000,\n    groups: [\n      {\n        name(moduleId: string) {\n          return clientManualChunks(moduleId) ?? null;\n        },\n      },\n    ],\n  };\n}\n\n/**\n * Rollup treeshake configuration for production client builds.\n *\n * Uses the 'recommended' preset as a safe base, then overrides\n * moduleSideEffects to strip unused re-exports from npm packages.\n *\n * The 'no-external' value for moduleSideEffects means:\n * - Local project modules: preserve side effects (CSS imports, polyfills)\n * - node_modules packages: treat as side-effect-free unless exports are used\n *\n * This is the single highest-impact optimization for large barrel-exporting\n * libraries like mermaid, @mui/material, lucide-react, etc. These libraries\n * re-export hundreds of sub-modules through barrel files. Without this,\n * Rollup preserves every sub-module even when only a few exports are consumed.\n *\n * Why 'no-external' instead of false (global side-effect-free)?\n * - User code may rely on import-time side effects (e.g., `import './global.css'`)\n * - 'no-external' is safe for app code while still enabling aggressive DCE for deps\n *\n * Why not the 'smallest' preset?\n * - 'smallest' also sets propertyReadSideEffects: false and\n *   tryCatchDeoptimization: false, which can break specific libraries\n *   that rely on property access side effects or try/catch for feature detection\n * - 'recommended' + 'no-external' gives most of the benefit with less risk\n *\n * @deprecated Use getClientTreeshakeConfigForVite(viteMajorVersion) instead\n * for Vite version compatibility. Kept for backward compatibility.\n */\nexport const clientTreeshakeConfig = {\n  preset: \"recommended\" as const,\n  moduleSideEffects: \"no-external\" as const,\n};\n\n/**\n * Returns treeshake configuration appropriate for the Vite version.\n *\n * Rollup (Vite 7) supports presets like \"recommended\" which set multiple\n * treeshake options at once. Rolldown (Vite 8+) doesn't support presets,\n * so we only return moduleSideEffects for Vite 8+.\n *\n * The Rollup \"recommended\" preset sets:\n * - annotations: true (Rolldown default is also true)\n * - manualPureFunctions: [] (Rolldown default is also [])\n * - propertyReadSideEffects: true (Rolldown equivalent is 'always', the default)\n * - unknownGlobalSideEffects: false (Rolldown default is true — this is a known acceptable\n *   divergence. Slightly less aggressive DCE on unknown globals, acceptable for client bundles)\n * - correctVarValueBeforeDeclaration and tryCatchDeoptimization (Rolldown handles these differently)\n *\n * The key optimization is moduleSideEffects: \"no-external\", which is supported\n * by both bundlers and provides the DCE benefits for barrel-exporting libraries.\n * It treats node_modules as side-effect-free (enabling aggressive DCE) while\n * preserving side effects in local code.\n */\nexport function getClientTreeshakeConfigForVite(viteMajorVersion: number) {\n  if (viteMajorVersion >= 8) {\n    // Rolldown (Vite 8+) - no preset support, only specific options.\n    // Rolldown's built-in defaults already cover what Rollup's 'recommended'\n    // preset provides (annotations, correctContext, tryCatchDeoptimization).\n    return {\n      moduleSideEffects: \"no-external\" as const,\n    };\n  }\n  // Rollup (Vite 7) - supports presets for convenient option grouping\n  return {\n    preset: \"recommended\" as const,\n    moduleSideEffects: \"no-external\" as const,\n  };\n}\n\ntype VinextBuildConfig = NonNullable<UserConfig[\"build\"]>;\ntype VinextBuildBundlerOptions = NonNullable<VinextBuildConfig[\"rolldownOptions\"]>;\ntype VinextBuildConfigWithLegacy = VinextBuildConfig & {\n  rollupOptions?: VinextBuildBundlerOptions;\n};\n\nexport function getBuildBundlerOptions(\n  build: UserConfig[\"build\"] | undefined,\n): VinextBuildBundlerOptions | undefined {\n  const buildConfig = build as VinextBuildConfigWithLegacy | undefined;\n  return buildConfig?.rolldownOptions ?? buildConfig?.rollupOptions;\n}\n\nexport function withBuildBundlerOptions(\n  viteMajorVersion: number,\n  bundlerOptions: VinextBuildBundlerOptions,\n): Partial<VinextBuildConfigWithLegacy> {\n  return viteMajorVersion >= 8\n    ? { rolldownOptions: bundlerOptions }\n    : { rollupOptions: bundlerOptions };\n}\n"],"mappings":";;;;;;;;AASA,SAAS,eAAe,IAA2B;CACjD,MAAM,QAAQ,GAAG,YAAY,gBAAgB;AAC7C,KAAI,UAAU,GAAI,QAAO;CACzB,MAAM,OAAO,GAAG,MAAM,QAAQ,GAAuB;AACrD,KAAI,KAAK,WAAW,IAAI,EAAE;EAExB,MAAM,QAAQ,KAAK,MAAM,IAAI;AAC7B,SAAO,MAAM,UAAU,IAAI,MAAM,KAAK,MAAM,MAAM,KAAK;;AAEzD,QAAO,KAAK,MAAM,IAAI,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B/B,SAAgB,yBAAyB,UAAkB;AACzD,QAAO,SAAS,mBAAmB,IAAgC;AAKjE,MAAI,GAAG,SAAS,eAAe,EAAE;GAC/B,MAAM,MAAM,eAAe,GAAG;AAC9B,OAAI,CAAC,IAAK,QAAO,KAAA;AACjB,OAAI,QAAQ,WAAW,QAAQ,eAAe,QAAQ,YACpD,QAAO;AAMT;;AAMF,MAAI,GAAG,WAAW,SAAS,CACzB,QAAO;;;;;;;;;;;;AAgBb,SAAgB,yBAAyB,oBAAwD;AAC/F,QAAO;EACL,cAAc;EACd,0BAA0B;EAC3B;;AAGH,SAAgB,gCACd,oBACA;AACA,QAAO;EACL,SAAS;EACT,QAAQ,CACN,EACE,KAAK,UAAkB;AACrB,UAAO,mBAAmB,SAAS,IAAI;KAE1C,CACF;EACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BH,MAAa,wBAAwB;CACnC,QAAQ;CACR,mBAAmB;CACpB;;;;;;;;;;;;;;;;;;;;;AAsBD,SAAgB,gCAAgC,kBAA0B;AACxE,KAAI,oBAAoB,EAItB,QAAO,EACL,mBAAmB,eACpB;AAGH,QAAO;EACL,QAAQ;EACR,mBAAmB;EACpB;;AASH,SAAgB,uBACd,OACuC;CACvC,MAAM,cAAc;AACpB,QAAO,aAAa,mBAAmB,aAAa;;AAGtD,SAAgB,wBACd,kBACA,gBACsC;AACtC,QAAO,oBAAoB,IACvB,EAAE,iBAAiB,gBAAgB,GACnC,EAAE,eAAe,gBAAgB"}

package/dist/build/layout-classification-types.d.ts

@@ -0,0 +1,62 @@
+//#region src/build/layout-classification-types.d.ts
+/**
+ * Shared types for the layout classification pipeline.
+ *
+ * Kept in a leaf module so both `report.ts` (which implements segment-config
+ * classification) and `layout-classification.ts` (which composes the full
+ * pipeline) can import them without forming a cycle.
+ *
+ * The wire contract between build and runtime is intentionally narrow: the
+ * runtime only cares about the `"static" | "dynamic"` decision for a layout.
+ * Reasons live in a sidecar structure so operators can trace how each
+ * decision was made without bloating the hot-path payload.
+ */
+/**
+ * Structured record of which classifier layer produced a decision and what
+ * evidence it used. Kept as a discriminated union so each layer can carry
+ * its own diagnostic shape without the consumer having to fall back to
+ * stringly-typed `reason` fields.
+ */
+type ClassificationReason = {
+  layer: "segment-config";
+  key: "dynamic" | "revalidate";
+  value: string | number;
+} | {
+  layer: "module-graph";
+  result: "static" | "needs-probe";
+  firstShimMatch?: string;
+} | {
+  layer: "runtime-probe";
+  outcome: "static" | "dynamic";
+  error?: string;
+} | {
+  layer: "no-classifier";
+};
+type ModuleGraphStaticReason = {
+  layer: "module-graph";
+  result: "static";
+  firstShimMatch?: string;
+};
+/**
+ * Build-time classification outcome for a single layout. Tagged with `kind`
+ * so callers can branch exhaustively and carry diagnostic reasons alongside
+ * the decision.
+ *
+ * `absent` means no classifier layer had anything to say — the caller should
+ * defer to the next layer (or to the runtime probe).
+ */
+type LayoutBuildClassification = {
+  kind: "absent";
+} | {
+  kind: "static";
+  reason: ClassificationReason;
+} | {
+  kind: "dynamic";
+  reason: ClassificationReason;
+} | {
+  kind: "needs-probe";
+  reason: ClassificationReason;
+};
+//#endregion
+export { ClassificationReason, LayoutBuildClassification, ModuleGraphStaticReason };
+//# sourceMappingURL=layout-classification-types.d.ts.map

package/dist/build/layout-classification-types.js

@@ -0,0 +1 @@
+export {};

package/dist/build/layout-classification.d.ts

@@ -0,0 +1,60 @@
+import { ClassificationReason, LayoutBuildClassification, ModuleGraphStaticReason } from "./layout-classification-types.js";
+
+//#region src/build/layout-classification.d.ts
+type ModuleGraphClassification = "static" | "needs-probe";
+type ModuleGraphClassificationResult = {
+  result: ModuleGraphClassification; /** First dynamic shim module ID encountered during BFS, when any. */
+  firstShimMatch?: string;
+};
+type ModuleInfoProvider = {
+  getModuleInfo(id: string): {
+    importedIds: string[];
+    dynamicImportedIds: string[];
+  } | null;
+};
+type LayoutEntry = {
+  /** Rollup/Vite module ID for the layout file. */moduleId: string; /** Directory depth from the app root, used to build the stable layout ID. */
+  treePosition: number; /** Segment config source code extracted at build time, or null when absent. */
+  segmentConfig?: {
+    code: string;
+  } | null;
+};
+type RouteForClassification = {
+  layouts: readonly LayoutEntry[];
+  routeSegments: string[];
+};
+/**
+ * BFS traversal of a layout's dependency tree. If any transitive import
+ * resolves to a dynamic shim path (headers, cache, server), the layout
+ * cannot be proven static at build time and needs a runtime probe.
+ *
+ * The returned object carries the classification plus the first matching
+ * shim module ID (when any). Operators use the shim ID via the debug
+ * channel to trace why a layout was flagged for probing.
+ */
+declare function classifyLayoutByModuleGraph(layoutModuleId: string, dynamicShimPaths: ReadonlySet<string>, moduleInfo: ModuleInfoProvider): ModuleGraphClassificationResult;
+declare function moduleGraphReason(graphResult: ModuleGraphClassificationResult & {
+  result: "static";
+}): ModuleGraphStaticReason;
+declare function moduleGraphReason(graphResult: ModuleGraphClassificationResult): ClassificationReason;
+declare function isStaticModuleGraphResult(graphResult: ModuleGraphClassificationResult): graphResult is ModuleGraphClassificationResult & {
+  result: "static";
+};
+/**
+ * Classifies all layouts across all routes using a two-layer strategy:
+ *
+ * 1. Segment config (Layer 1) — short-circuits to "static" or "dynamic"
+ * 2. Module graph (Layer 2) — BFS for dynamic shim imports → "static" or "needs-probe"
+ *
+ * Shared layouts (same file appearing in multiple routes) are classified once
+ * and deduplicated by layout ID.
+ *
+ * @internal Not called by production code. The `generateBundle` hook in
+ * `index.ts` calls `classifyLayoutByModuleGraph` directly and composes
+ * via the numeric-index manifest in `route-classification-manifest.ts`.
+ * Used only by `tests/layout-classification.test.ts`.
+ */
+declare function classifyAllRouteLayouts(routes: readonly RouteForClassification[], dynamicShimPaths: ReadonlySet<string>, moduleInfo: ModuleInfoProvider): Map<string, LayoutBuildClassification>;
+//#endregion
+export { type ClassificationReason, type LayoutBuildClassification, ModuleGraphClassification, ModuleGraphClassificationResult, type ModuleGraphStaticReason, ModuleInfoProvider, classifyAllRouteLayouts, classifyLayoutByModuleGraph, isStaticModuleGraphResult, moduleGraphReason };
+//# sourceMappingURL=layout-classification.d.ts.map

package/dist/build/layout-classification.js

@@ -0,0 +1,98 @@
+import { classifyLayoutSegmentConfig } from "./report.js";
+import { createAppPageTreePath } from "../server/app-page-route-wiring.js";
+//#region src/build/layout-classification.ts
+/**
+* Layout classification — determines whether each layout in an App Router
+* route tree is static or dynamic via two complementary detection layers:
+*
+*   Layer 1: Segment config (`export const dynamic`, `export const revalidate`)
+*   Layer 2: Module graph traversal (checks for transitive dynamic shim imports)
+*
+* Layer 3 (probe-based runtime detection) is handled separately in
+* `app-page-execution.ts` at request time.
+*
+* Every result is carried as a `LayoutBuildClassification` tagged variant so
+* operators can trace which layer produced a decision via the structured
+* `ClassificationReason` sidecar without that metadata leaking onto the wire.
+*/
+/**
+* BFS traversal of a layout's dependency tree. If any transitive import
+* resolves to a dynamic shim path (headers, cache, server), the layout
+* cannot be proven static at build time and needs a runtime probe.
+*
+* The returned object carries the classification plus the first matching
+* shim module ID (when any). Operators use the shim ID via the debug
+* channel to trace why a layout was flagged for probing.
+*/
+function classifyLayoutByModuleGraph(layoutModuleId, dynamicShimPaths, moduleInfo) {
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [layoutModuleId];
+	let head = 0;
+	while (head < queue.length) {
+		const currentId = queue[head++];
+		if (visited.has(currentId)) continue;
+		visited.add(currentId);
+		if (dynamicShimPaths.has(currentId)) return {
+			result: "needs-probe",
+			firstShimMatch: currentId
+		};
+		const info = moduleInfo.getModuleInfo(currentId);
+		if (!info) continue;
+		for (const importedId of info.importedIds) if (!visited.has(importedId)) queue.push(importedId);
+		for (const dynamicId of info.dynamicImportedIds) if (!visited.has(dynamicId)) queue.push(dynamicId);
+	}
+	return { result: "static" };
+}
+function moduleGraphReason(graphResult) {
+	if (graphResult.firstShimMatch === void 0) return {
+		layer: "module-graph",
+		result: graphResult.result
+	};
+	return {
+		layer: "module-graph",
+		result: graphResult.result,
+		firstShimMatch: graphResult.firstShimMatch
+	};
+}
+function isStaticModuleGraphResult(graphResult) {
+	return graphResult.result === "static";
+}
+/**
+* Classifies all layouts across all routes using a two-layer strategy:
+*
+* 1. Segment config (Layer 1) — short-circuits to "static" or "dynamic"
+* 2. Module graph (Layer 2) — BFS for dynamic shim imports → "static" or "needs-probe"
+*
+* Shared layouts (same file appearing in multiple routes) are classified once
+* and deduplicated by layout ID.
+*
+* @internal Not called by production code. The `generateBundle` hook in
+* `index.ts` calls `classifyLayoutByModuleGraph` directly and composes
+* via the numeric-index manifest in `route-classification-manifest.ts`.
+* Used only by `tests/layout-classification.test.ts`.
+*/
+function classifyAllRouteLayouts(routes, dynamicShimPaths, moduleInfo) {
+	const result = /* @__PURE__ */ new Map();
+	for (const route of routes) for (const layout of route.layouts) {
+		const layoutId = `layout:${createAppPageTreePath(route.routeSegments, layout.treePosition)}`;
+		if (result.has(layoutId)) continue;
+		if (layout.segmentConfig) {
+			const configResult = classifyLayoutSegmentConfig(layout.segmentConfig.code);
+			if (configResult.kind !== "absent") {
+				result.set(layoutId, configResult);
+				continue;
+			}
+		}
+		const graphResult = classifyLayoutByModuleGraph(layout.moduleId, dynamicShimPaths, moduleInfo);
+		const reason = moduleGraphReason(graphResult);
+		result.set(layoutId, {
+			kind: graphResult.result,
+			reason
+		});
+	}
+	return result;
+}
+//#endregion
+export { classifyAllRouteLayouts, classifyLayoutByModuleGraph, isStaticModuleGraphResult, moduleGraphReason };
+
+//# sourceMappingURL=layout-classification.js.map

package/dist/build/layout-classification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-classification.js","names":[],"sources":["../../src/build/layout-classification.ts"],"sourcesContent":["/**\n * Layout classification — determines whether each layout in an App Router\n * route tree is static or dynamic via two complementary detection layers:\n *\n *   Layer 1: Segment config (`export const dynamic`, `export const revalidate`)\n *   Layer 2: Module graph traversal (checks for transitive dynamic shim imports)\n *\n * Layer 3 (probe-based runtime detection) is handled separately in\n * `app-page-execution.ts` at request time.\n *\n * Every result is carried as a `LayoutBuildClassification` tagged variant so\n * operators can trace which layer produced a decision via the structured\n * `ClassificationReason` sidecar without that metadata leaking onto the wire.\n */\n\nimport { classifyLayoutSegmentConfig } from \"./report.js\";\nimport { createAppPageTreePath } from \"../server/app-page-route-wiring.js\";\nimport type {\n  ClassificationReason,\n  LayoutBuildClassification,\n  ModuleGraphStaticReason,\n} from \"./layout-classification-types.js\";\n\nexport type {\n  ClassificationReason,\n  LayoutBuildClassification,\n  ModuleGraphStaticReason,\n} from \"./layout-classification-types.js\";\n\nexport type ModuleGraphClassification = \"static\" | \"needs-probe\";\n\nexport type ModuleGraphClassificationResult = {\n  result: ModuleGraphClassification;\n  /** First dynamic shim module ID encountered during BFS, when any. */\n  firstShimMatch?: string;\n};\n\nexport type ModuleInfoProvider = {\n  getModuleInfo(id: string): {\n    importedIds: string[];\n    dynamicImportedIds: string[];\n  } | null;\n};\n\ntype LayoutEntry = {\n  /** Rollup/Vite module ID for the layout file. */\n  moduleId: string;\n  /** Directory depth from the app root, used to build the stable layout ID. */\n  treePosition: number;\n  /** Segment config source code extracted at build time, or null when absent. */\n  segmentConfig?: { code: string } | null;\n};\n\ntype RouteForClassification = {\n  layouts: readonly LayoutEntry[];\n  routeSegments: string[];\n};\n\n/**\n * BFS traversal of a layout's dependency tree. If any transitive import\n * resolves to a dynamic shim path (headers, cache, server), the layout\n * cannot be proven static at build time and needs a runtime probe.\n *\n * The returned object carries the classification plus the first matching\n * shim module ID (when any). Operators use the shim ID via the debug\n * channel to trace why a layout was flagged for probing.\n */\nexport function classifyLayoutByModuleGraph(\n  layoutModuleId: string,\n  dynamicShimPaths: ReadonlySet<string>,\n  moduleInfo: ModuleInfoProvider,\n): ModuleGraphClassificationResult {\n  const visited = new Set<string>();\n  const queue: string[] = [layoutModuleId];\n  let head = 0;\n\n  while (head < queue.length) {\n    const currentId = queue[head++]!;\n\n    if (visited.has(currentId)) continue;\n    visited.add(currentId);\n\n    if (dynamicShimPaths.has(currentId)) {\n      return { result: \"needs-probe\", firstShimMatch: currentId };\n    }\n\n    const info = moduleInfo.getModuleInfo(currentId);\n    if (!info) continue;\n\n    for (const importedId of info.importedIds) {\n      if (!visited.has(importedId)) queue.push(importedId);\n    }\n    for (const dynamicId of info.dynamicImportedIds) {\n      if (!visited.has(dynamicId)) queue.push(dynamicId);\n    }\n  }\n\n  return { result: \"static\" };\n}\n\nexport function moduleGraphReason(\n  graphResult: ModuleGraphClassificationResult & { result: \"static\" },\n): ModuleGraphStaticReason;\nexport function moduleGraphReason(\n  graphResult: ModuleGraphClassificationResult,\n): ClassificationReason;\nexport function moduleGraphReason(\n  graphResult: ModuleGraphClassificationResult,\n): ClassificationReason {\n  if (graphResult.firstShimMatch === undefined) {\n    return { layer: \"module-graph\", result: graphResult.result };\n  }\n  return {\n    layer: \"module-graph\",\n    result: graphResult.result,\n    firstShimMatch: graphResult.firstShimMatch,\n  };\n}\n\nexport function isStaticModuleGraphResult(\n  graphResult: ModuleGraphClassificationResult,\n): graphResult is ModuleGraphClassificationResult & { result: \"static\" } {\n  return graphResult.result === \"static\";\n}\n\n/**\n * Classifies all layouts across all routes using a two-layer strategy:\n *\n * 1. Segment config (Layer 1) — short-circuits to \"static\" or \"dynamic\"\n * 2. Module graph (Layer 2) — BFS for dynamic shim imports → \"static\" or \"needs-probe\"\n *\n * Shared layouts (same file appearing in multiple routes) are classified once\n * and deduplicated by layout ID.\n *\n * @internal Not called by production code. The `generateBundle` hook in\n * `index.ts` calls `classifyLayoutByModuleGraph` directly and composes\n * via the numeric-index manifest in `route-classification-manifest.ts`.\n * Used only by `tests/layout-classification.test.ts`.\n */\nexport function classifyAllRouteLayouts(\n  routes: readonly RouteForClassification[],\n  dynamicShimPaths: ReadonlySet<string>,\n  moduleInfo: ModuleInfoProvider,\n): Map<string, LayoutBuildClassification> {\n  const result = new Map<string, LayoutBuildClassification>();\n\n  for (const route of routes) {\n    for (const layout of route.layouts) {\n      const layoutId = `layout:${createAppPageTreePath(route.routeSegments, layout.treePosition)}`;\n\n      if (result.has(layoutId)) continue;\n\n      // Layer 1: segment config\n      if (layout.segmentConfig) {\n        const configResult = classifyLayoutSegmentConfig(layout.segmentConfig.code);\n        if (configResult.kind !== \"absent\") {\n          result.set(layoutId, configResult);\n          continue;\n        }\n      }\n\n      // Layer 2: module graph\n      const graphResult = classifyLayoutByModuleGraph(\n        layout.moduleId,\n        dynamicShimPaths,\n        moduleInfo,\n      );\n      const reason = moduleGraphReason(graphResult);\n      result.set(layoutId, { kind: graphResult.result, reason });\n    }\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAmEA,SAAgB,4BACd,gBACA,kBACA,YACiC;CACjC,MAAM,0BAAU,IAAI,KAAa;CACjC,MAAM,QAAkB,CAAC,eAAe;CACxC,IAAI,OAAO;AAEX,QAAO,OAAO,MAAM,QAAQ;EAC1B,MAAM,YAAY,MAAM;AAExB,MAAI,QAAQ,IAAI,UAAU,CAAE;AAC5B,UAAQ,IAAI,UAAU;AAEtB,MAAI,iBAAiB,IAAI,UAAU,CACjC,QAAO;GAAE,QAAQ;GAAe,gBAAgB;GAAW;EAG7D,MAAM,OAAO,WAAW,cAAc,UAAU;AAChD,MAAI,CAAC,KAAM;AAEX,OAAK,MAAM,cAAc,KAAK,YAC5B,KAAI,CAAC,QAAQ,IAAI,WAAW,CAAE,OAAM,KAAK,WAAW;AAEtD,OAAK,MAAM,aAAa,KAAK,mBAC3B,KAAI,CAAC,QAAQ,IAAI,UAAU,CAAE,OAAM,KAAK,UAAU;;AAItD,QAAO,EAAE,QAAQ,UAAU;;AAS7B,SAAgB,kBACd,aACsB;AACtB,KAAI,YAAY,mBAAmB,KAAA,EACjC,QAAO;EAAE,OAAO;EAAgB,QAAQ,YAAY;EAAQ;AAE9D,QAAO;EACL,OAAO;EACP,QAAQ,YAAY;EACpB,gBAAgB,YAAY;EAC7B;;AAGH,SAAgB,0BACd,aACuE;AACvE,QAAO,YAAY,WAAW;;;;;;;;;;;;;;;;AAiBhC,SAAgB,wBACd,QACA,kBACA,YACwC;CACxC,MAAM,yBAAS,IAAI,KAAwC;AAE3D,MAAK,MAAM,SAAS,OAClB,MAAK,MAAM,UAAU,MAAM,SAAS;EAClC,MAAM,WAAW,UAAU,sBAAsB,MAAM,eAAe,OAAO,aAAa;AAE1F,MAAI,OAAO,IAAI,SAAS,CAAE;AAG1B,MAAI,OAAO,eAAe;GACxB,MAAM,eAAe,4BAA4B,OAAO,cAAc,KAAK;AAC3E,OAAI,aAAa,SAAS,UAAU;AAClC,WAAO,IAAI,UAAU,aAAa;AAClC;;;EAKJ,MAAM,cAAc,4BAClB,OAAO,UACP,kBACA,WACD;EACD,MAAM,SAAS,kBAAkB,YAAY;AAC7C,SAAO,IAAI,UAAU;GAAE,MAAM,YAAY;GAAQ;GAAQ,CAAC;;AAI9D,QAAO"}

package/dist/build/report.d.ts

@@ -1,3 +1,4 @@
+import { LayoutBuildClassification } from "./layout-classification-types.js";
 import { Route } from "../routing/pages-router.js";
 import { AppRoute } from "../routing/app-router.js";
 import { PrerenderResult } from "./prerender.js";
@@ -49,6 +50,19 @@ declare function extractExportConstNumber(code: string, name: string): number |
  *   null     — no `revalidate` key found (fully static)
  */
 declare function extractGetStaticPropsRevalidate(code: string): number | false | null;
+/**
+ * Classifies a layout file by its segment config exports (`dynamic`, `revalidate`).
+ *
+ * Returns a tagged `LayoutBuildClassification` carrying both the decision and
+ * the specific segment-config field that produced it. `{ kind: "absent" }`
+ * means no segment config is present and the caller should defer to the next
+ * layer (module graph analysis).
+ *
+ * Unlike page classification, positive `revalidate` values are not meaningful
+ * for layout skip decisions — ISR is a page-level concept. Only the extremes
+ * (`revalidate = 0` → dynamic, `revalidate = Infinity` → static) are decisive.
+ */
+declare function classifyLayoutSegmentConfig(code: string): LayoutBuildClassification;
 /**
  * Classifies a Pages Router page file by reading its source and examining
  * which data-fetching exports it contains.
@@ -111,5 +125,5 @@ declare function printBuildReport(options: {
   prerenderResult?: PrerenderResult;
 }): Promise<void>;
 //#endregion
-export { RouteRow, RouteType, buildReportRows, classifyAppRoute, classifyPagesRoute, extractExportConstNumber, extractExportConstString, extractGetStaticPropsRevalidate, findDir, formatBuildReport, hasNamedExport, printBuildReport };
+export { RouteRow, RouteType, buildReportRows, classifyAppRoute, classifyLayoutSegmentConfig, classifyPagesRoute, extractExportConstNumber, extractExportConstString, extractGetStaticPropsRevalidate, findDir, formatBuildReport, hasNamedExport, printBuildReport };
 //# sourceMappingURL=report.d.ts.map

package/dist/build/report.js

@@ -408,6 +408,55 @@ function findMatchingToken(code, start, openToken, closeToken) {
 	return -1;
 }
 /**
+* Classifies a layout file by its segment config exports (`dynamic`, `revalidate`).
+*
+* Returns a tagged `LayoutBuildClassification` carrying both the decision and
+* the specific segment-config field that produced it. `{ kind: "absent" }`
+* means no segment config is present and the caller should defer to the next
+* layer (module graph analysis).
+*
+* Unlike page classification, positive `revalidate` values are not meaningful
+* for layout skip decisions — ISR is a page-level concept. Only the extremes
+* (`revalidate = 0` → dynamic, `revalidate = Infinity` → static) are decisive.
+*/
+function classifyLayoutSegmentConfig(code) {
+	const dynamicValue = extractExportConstString(code, "dynamic");
+	if (dynamicValue === "force-dynamic") return {
+		kind: "dynamic",
+		reason: {
+			layer: "segment-config",
+			key: "dynamic",
+			value: "force-dynamic"
+		}
+	};
+	if (dynamicValue === "force-static" || dynamicValue === "error") return {
+		kind: "static",
+		reason: {
+			layer: "segment-config",
+			key: "dynamic",
+			value: dynamicValue
+		}
+	};
+	const revalidateValue = extractExportConstNumber(code, "revalidate");
+	if (revalidateValue === Infinity) return {
+		kind: "static",
+		reason: {
+			layer: "segment-config",
+			key: "revalidate",
+			value: Infinity
+		}
+	};
+	if (revalidateValue === 0) return {
+		kind: "dynamic",
+		reason: {
+			layer: "segment-config",
+			key: "revalidate",
+			value: 0
+		}
+	};
+	return { kind: "absent" };
+}
+/**
 * Classifies a Pages Router page file by reading its source and examining
 * which data-fetching exports it contains.
 *
@@ -603,6 +652,6 @@ async function printBuildReport(options) {
 	}
 }
 //#endregion
-export { buildReportRows, classifyAppRoute, classifyPagesRoute, extractExportConstNumber, extractExportConstString, extractGetStaticPropsRevalidate, findDir, formatBuildReport, hasNamedExport, printBuildReport };
+export { buildReportRows, classifyAppRoute, classifyLayoutSegmentConfig, classifyPagesRoute, extractExportConstNumber, extractExportConstString, extractGetStaticPropsRevalidate, findDir, formatBuildReport, hasNamedExport, printBuildReport };
 
 //# sourceMappingURL=report.js.map