vinext 1.3.1 → 1.4.1

package/dist/utils/cache-life-profiles.js

@@ -0,0 +1,111 @@
+import { isUnknownRecord } from "./record.js";
+//#region src/utils/cache-life-profiles.ts
+/** Next.js's built-in profiles (`defaultConfig.cacheLife` in config-shared.ts). */
+const BUILT_IN_CACHE_LIFE_PROFILES = {
+	default: {
+		revalidate: 900,
+		expire: 4294967294
+	},
+	seconds: {
+		stale: 30,
+		revalidate: 1,
+		expire: 60
+	},
+	minutes: {
+		stale: 300,
+		revalidate: 60,
+		expire: 3600
+	},
+	hours: {
+		stale: 300,
+		revalidate: 3600,
+		expire: 86400
+	},
+	days: {
+		stale: 300,
+		revalidate: 86400,
+		expire: 604800
+	},
+	weeks: {
+		stale: 300,
+		revalidate: 604800,
+		expire: 2592e3
+	},
+	max: {
+		stale: 300,
+		revalidate: 2592e3,
+		expire: 31536e3
+	}
+};
+const CACHE_LIFE_FIELDS = [
+	"stale",
+	"revalidate",
+	"expire"
+];
+function copyBuiltInProfiles() {
+	const profiles = {};
+	for (const [name, profile] of Object.entries(BUILT_IN_CACHE_LIFE_PROFILES)) profiles[name] = { ...profile };
+	return profiles;
+}
+/**
+* Merge next.config `cacheLife` profiles over the built-ins, as Next.js does
+* in `assignDefaultsAndValidate` (server/config.ts): a user profile replaces
+* the built-in of the same name whole, and only `default` gets its missing
+* fields filled: `stale` from `staleTimes.static`, `revalidate` from the
+* built-in, `expire` from `expireTime`. That includes the built-in `default`,
+* whose `stale` is unset in Next.js's defaults too. The other profiles keep
+* their gaps, which the "use cache" store resolves from `default`.
+*
+* Next.js only schema-checks these profiles (fields must be numbers) and
+* warns; `revalidate > expire` is checked for `cacheLife({...})` calls, not
+* for config profiles.
+*/
+function resolveCacheLifeProfiles(userProfiles, defaults, warn) {
+	const profiles = copyBuiltInProfiles();
+	for (const [name, rawProfile] of Object.entries(isUnknownRecord(userProfiles) ? userProfiles : {})) {
+		if (!isUnknownRecord(rawProfile)) {
+			warn(`[vinext] Invalid next.config option \`cacheLife.${name}\`: expected an object.`);
+			continue;
+		}
+		const profile = {};
+		for (const field of CACHE_LIFE_FIELDS) {
+			const value = rawProfile[field];
+			if (value === void 0) continue;
+			if (typeof value !== "number" || Number.isNaN(value)) {
+				warn(`[vinext] Invalid next.config option \`cacheLife.${name}.${field}\`: expected a number of seconds.`);
+				continue;
+			}
+			profile[field] = value;
+		}
+		profiles[name] = profile;
+	}
+	const defaultProfile = profiles.default;
+	defaultProfile.stale ??= defaults.staticStaleTime;
+	defaultProfile.revalidate ??= BUILT_IN_CACHE_LIFE_PROFILES.default.revalidate;
+	defaultProfile.expire ??= defaults.expireTime;
+	return profiles;
+}
+function encodeNonFiniteNumber(_key, value) {
+	return value === Infinity || value === -Infinity ? String(value) : value;
+}
+function decodeNonFiniteNumber(_key, value) {
+	return value === "Infinity" || value === "-Infinity" ? Number(value) : value;
+}
+/** Serialize resolved profiles for the `__VINEXT_CACHE_LIFE_PROFILES` define. */
+function serializeCacheLifeProfiles(profiles) {
+	return JSON.stringify(profiles, encodeNonFiniteNumber);
+}
+/**
+* Read the `__VINEXT_CACHE_LIFE_PROFILES` define. When absent, the profiles a
+* next.config without `cacheLife` resolves to.
+*/
+function parseCacheLifeProfiles(serialized) {
+	if (!serialized) {
+		const profiles = copyBuiltInProfiles();
+		profiles.default.stale = 300;
+		return profiles;
+	}
+	return JSON.parse(serialized, decodeNonFiniteNumber);
+}
+//#endregion
+export { BUILT_IN_CACHE_LIFE_PROFILES, parseCacheLifeProfiles, resolveCacheLifeProfiles, serializeCacheLifeProfiles };

package/dist/utils/middleware-request-headers.d.ts

@@ -7,7 +7,17 @@ type MiddlewareHeaderSource = Headers | Record<string, MiddlewareHeaderValue>;
  * under their literal protocol-header names on both the request and response.
  */
 export declare function getUnconsumedMiddlewareRequestHeaders(source: MiddlewareHeaderSource): Map<string, string>;
-/** Whether middleware changed the headers seen by downstream application code. */
+/**
+ * `baseHeaders` with only Next.js's generic merge of ordinary middleware
+ * response headers applied, without the request-header protocol.
+ */
+export declare function applyMiddlewareResponseHeadersToRequest(baseHeaders: Headers, middlewareHeaders: MiddlewareHeaderSource): Headers;
+/**
+ * Whether middleware changed the headers seen by downstream application code
+ * through its request-header protocol. Ordinary response headers are copied to
+ * the request as well, but like a client's own headers they do not opt a
+ * render out of the shared response stage.
+ */
 export declare function hasMiddlewareRequestHeaderOverrides(source: MiddlewareHeaderSource | null): boolean;
 export declare function encodeMiddlewareRequestHeaders(targetHeaders: Headers, requestHeaders: Headers): void;
 /**
@@ -16,8 +26,9 @@ export declare function encodeMiddlewareRequestHeaders(targetHeaders: Headers, r
  * middleware. Never re-add absent headers from the base request — that would
  * resurrect credentials the app explicitly stripped before an external
  * rewrite. Next.js treats the empty value emitted for `new Headers()` as no
- * override. Any unconsumed `x-middleware-request-*` values are subsequently
- * copied to the request under their literal protocol-header names.
+ * override. Any unconsumed `x-middleware-request-*` values and every other
+ * truthy middleware response header are subsequently copied to the request
+ * under their literal names, replacing values the client sent.
  */
 export declare function buildRequestHeadersFromMiddlewareResponse(baseHeaders: Headers, middlewareHeaders: MiddlewareHeaderSource): Headers | null;
 export declare function shouldKeepMiddlewareHeader(key: string): boolean;

package/dist/utils/middleware-request-headers.js

@@ -34,7 +34,52 @@ function getUnconsumedMiddlewareRequestHeaders(source) {
 	for (const [key, value] of getForwardedRequestHeaders(source)) if (value && !overriddenHeaders?.has(key)) unconsumedHeaders.set(`${MIDDLEWARE_REQUEST_HEADER_PREFIX}${key}`, value);
 	return unconsumedHeaders;
 }
-/** Whether middleware changed the headers seen by downstream application code. */
+const UNMERGED_MIDDLEWARE_RESPONSE_HEADERS = /* @__PURE__ */ new Set([
+	"accept-encoding",
+	"connection",
+	"content-encoding",
+	"content-length",
+	"expect",
+	"keep-alive",
+	"keepalive",
+	"transfer-encoding"
+]);
+/**
+* Return the truthy ordinary middleware response headers. Next.js's generic
+* middleware-header merge writes each of them to the request too, so a value
+* middleware sets replaces one the client sent under the same name. The
+* `x-middleware-*` namespace carries vinext's middleware protocol and is
+* handled separately.
+*/
+function getMergedMiddlewareResponseHeaders(source) {
+	const mergedHeaders = new Headers();
+	const entries = source instanceof Headers ? source : Object.entries(source).flatMap(([key, value]) => Array.isArray(value) ? value.map((item) => [key, item]) : [[key, value]]);
+	for (const [key, value] of entries) {
+		const lowerKey = key.toLowerCase();
+		if (value && !lowerKey.startsWith("x-middleware-") && !UNMERGED_MIDDLEWARE_RESPONSE_HEADERS.has(lowerKey)) mergedHeaders.append(lowerKey, value);
+	}
+	return mergedHeaders;
+}
+function applyMergedMiddlewareHeaders(targetHeaders, unconsumedHeaders, mergedHeaders) {
+	for (const [key, value] of unconsumedHeaders) targetHeaders.set(key, value);
+	for (const key of new Set(mergedHeaders.keys())) targetHeaders.delete(key);
+	for (const [key, value] of mergedHeaders) targetHeaders.append(key, value);
+}
+/**
+* `baseHeaders` with only Next.js's generic merge of ordinary middleware
+* response headers applied, without the request-header protocol.
+*/
+function applyMiddlewareResponseHeadersToRequest(baseHeaders, middlewareHeaders) {
+	const nextHeaders = new Headers(baseHeaders);
+	applyMergedMiddlewareHeaders(nextHeaders, /* @__PURE__ */ new Map(), getMergedMiddlewareResponseHeaders(middlewareHeaders));
+	return nextHeaders;
+}
+/**
+* Whether middleware changed the headers seen by downstream application code
+* through its request-header protocol. Ordinary response headers are copied to
+* the request as well, but like a client's own headers they do not opt a
+* render out of the shared response stage.
+*/
 function hasMiddlewareRequestHeaderOverrides(source) {
 	if (!source) return false;
 	return Boolean(getMiddlewareHeaderValue(source, "x-middleware-override-headers")) || getUnconsumedMiddlewareRequestHeaders(source).size > 0;
@@ -50,17 +95,19 @@ function encodeMiddlewareRequestHeaders(targetHeaders, requestHeaders) {
 * middleware. Never re-add absent headers from the base request — that would
 * resurrect credentials the app explicitly stripped before an external
 * rewrite. Next.js treats the empty value emitted for `new Headers()` as no
-* override. Any unconsumed `x-middleware-request-*` values are subsequently
-* copied to the request under their literal protocol-header names.
+* override. Any unconsumed `x-middleware-request-*` values and every other
+* truthy middleware response header are subsequently copied to the request
+* under their literal names, replacing values the client sent.
 */
 function buildRequestHeadersFromMiddlewareResponse(baseHeaders, middlewareHeaders) {
 	const forwardedHeaders = getForwardedRequestHeaders(middlewareHeaders);
 	const unconsumedHeaders = getUnconsumedMiddlewareRequestHeaders(middlewareHeaders);
+	const mergedHeaders = getMergedMiddlewareResponseHeaders(middlewareHeaders);
 	const rawOverrideHeader = getMiddlewareHeaderValue(middlewareHeaders, MIDDLEWARE_OVERRIDE_HEADERS);
 	if (!rawOverrideHeader) {
-		if (unconsumedHeaders.size === 0) return null;
+		if (unconsumedHeaders.size === 0 && mergedHeaders.keys().next().done) return null;
 		const nextHeaders = new Headers(baseHeaders);
-		for (const [key, value] of unconsumedHeaders) nextHeaders.set(key, value);
+		applyMergedMiddlewareHeaders(nextHeaders, unconsumedHeaders, mergedHeaders);
 		return nextHeaders;
 	}
 	const overrideHeaderNames = parseOverrideHeaderNames(rawOverrideHeader);
@@ -69,11 +116,11 @@ function buildRequestHeadersFromMiddlewareResponse(baseHeaders, middlewareHeader
 		const value = forwardedHeaders.get(key);
 		if (value !== void 0) nextHeaders.set(key, value);
 	}
-	for (const [key, value] of unconsumedHeaders) nextHeaders.set(key, value);
+	applyMergedMiddlewareHeaders(nextHeaders, unconsumedHeaders, mergedHeaders);
 	return nextHeaders;
 }
 function shouldKeepMiddlewareHeader(key) {
 	return key === "x-middleware-override-headers" || key === "x-middleware-cache" || key === "x-middleware-set-cookie" || key.startsWith("x-middleware-request-");
 }
 //#endregion
-export { buildRequestHeadersFromMiddlewareResponse, encodeMiddlewareRequestHeaders, getUnconsumedMiddlewareRequestHeaders, hasMiddlewareRequestHeaderOverrides, shouldKeepMiddlewareHeader };
+export { applyMiddlewareResponseHeadersToRequest, buildRequestHeadersFromMiddlewareResponse, encodeMiddlewareRequestHeaders, getUnconsumedMiddlewareRequestHeaders, hasMiddlewareRequestHeaderOverrides, shouldKeepMiddlewareHeader };

package/dist/utils/project.d.ts

@@ -58,6 +58,8 @@ export declare function findViteConfigPath(root: string): string | undefined;
 export declare function formatMissingCloudflarePluginError(options: {
   isAppRouter: boolean;
   configFile?: string;
+  /** False when configFile is not the root vite.config.* that `vinext init` updates. */
+  initUpdatesConfig?: boolean;
 }): string;
 export type ProjectInfo = {
   root: string;
@@ -78,8 +80,6 @@ export type ProjectInfo = {
   hasMDX: boolean;
   /** CodeHike is a dependency */
   hasCodeHike: boolean;
-  /** Native Node modules that need stubbing for Workers */
-  nativeModulesToStub: string[];
 };
 /** Check whether a wrangler config file exists in the given directory. */
 export declare function hasWranglerConfig(root: string): boolean;

package/dist/utils/project.js

@@ -196,7 +196,7 @@ function findViteConfigPath(root) {
 function formatMissingCloudflarePluginError(options) {
 	const cfArg = options.isAppRouter ? "{\n      viteEnvironment: { name: \"rsc\", childEnvironments: [\"ssr\"] },\n    }" : "";
 	const configRef = options.configFile ? options.configFile : "your Vite config";
-	return `[vinext] Missing @cloudflare/vite-plugin in ${configRef}.\n\n  Cloudflare Workers builds require the cloudflare() plugin.\n  Run \`vinext init --platform=cloudflare\` to update ${configRef}.\n\n  Expected plugin shape:\n\n    cloudflare(${cfArg})`;
+	return `[vinext] Missing @cloudflare/vite-plugin in ${configRef}.\n\n  Cloudflare Workers builds require the cloudflare() plugin.\n  ${options.initUpdatesConfig === false ? `Add it to ${configRef}.` : `Run \`vinext init --platform=cloudflare\` to update ${configRef}.`}\n\n  Expected plugin shape:\n\n    cloudflare(${cfArg})`;
 }
 /** Check whether a wrangler config file exists in the given directory. */
 function hasWranglerConfig(root) {
@@ -251,12 +251,10 @@ function detectProject(root) {
 		}
 	}
 	hasISR = hasISR || detectCacheComponents(root);
-	const allDeps = {
+	const hasCodeHike = "codehike" in {
 		...pkg?.dependencies,
 		...pkg?.devDependencies
 	};
-	const hasCodeHike = "codehike" in allDeps;
-	const nativeModulesToStub = detectNativeModules(allDeps);
 	return {
 		root,
 		isAppRouter,
@@ -271,8 +269,7 @@ function detectProject(root) {
 		hasISR,
 		hasTypeModule,
 		hasMDX,
-		hasCodeHike,
-		nativeModulesToStub
+		hasCodeHike
 	};
 }
 const ISR_PATTERN = /export\s+(?:const\s+revalidate\s*=|(?:async\s+)?function\s+getStaticProps\b|const\s+getStaticProps\s*=|\{[^}]*\bgetStaticProps\b[^}]*\})/;
@@ -357,16 +354,6 @@ function detectCacheComponents(root) {
 	}
 	return false;
 }
-const NATIVE_MODULES_TO_STUB = [
-	"@resvg/resvg-js",
-	"satori",
-	"lightningcss",
-	"@napi-rs/canvas",
-	"sharp"
-];
-function detectNativeModules(allDeps) {
-	return NATIVE_MODULES_TO_STUB.filter((mod) => mod in allDeps);
-}
 /**
 * Check if a package is resolvable from a given root directory using Node's
 * module resolution. Handles hoisting, pnpm symlinks, monorepos, and Yarn PnP.

package/dist/utils/regex.d.ts

@@ -1,3 +1,8 @@
 //#region src/utils/regex.d.ts
 export declare function escapeRegExp(value: string): string;
+/**
+ * Return the literal a RegExp matches when it is just `^literal$` (as built
+ * from `escapeRegExp`), or null for any other pattern.
+ */
+export declare function exactRegExpLiteral(pattern: RegExp): string | null;
 //#endregion

package/dist/utils/regex.js

@@ -2,5 +2,15 @@
 function escapeRegExp(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+const EXACT_REGEXP_SOURCE_RE = /^\^((?:\\[.*+?^${}()|[\]\\/]|[^.*+?^${}()|[\]\\])*)\$$/;
+/**
+* Return the literal a RegExp matches when it is just `^literal$` (as built
+* from `escapeRegExp`), or null for any other pattern.
+*/
+function exactRegExpLiteral(pattern) {
+	if (pattern.flags !== "") return null;
+	const body = EXACT_REGEXP_SOURCE_RE.exec(pattern.source)?.[1];
+	return body === void 0 ? null : body.replace(/\\(.)/g, "$1");
+}
 //#endregion
-export { escapeRegExp };
+export { escapeRegExp, exactRegExpLiteral };

package/dist/utils/text-stream.d.ts

@@ -15,13 +15,18 @@
  */
 export declare function readStreamAsText(stream: ReadableStream<Uint8Array>): Promise<string>;
 /**
- * Drain a UTF-8 byte stream up to `maxBytes` of *raw* input, returning the
- * decoded text. If the raw size limit is exceeded, cancellation is signalled
- * and `onLimitExceeded` is invoked; it MUST throw — its return type is
- * `never` to enforce that. Each caller passes its own error type.
+ * Drain a byte stream up to `maxBytes` of *raw* input, returning the decoded
+ * text (UTF-8 unless the caller passes its own `decoder`). If the raw size
+ * limit is exceeded, cancellation is signalled and `onLimitExceeded` is
+ * invoked; it MUST throw — its return type is `never` to enforce that. Each
+ * caller passes its own error type.
  *
  * The size check is on raw bytes (pre-decode) to bound memory before
  * paying the decoder cost.
  */
-export declare function readStreamAsTextWithLimit(stream: ReadableStream<Uint8Array>, maxBytes: number, onLimitExceeded: () => never): Promise<string>;
+export declare function readStreamAsTextWithLimit(stream: ReadableStream<Uint8Array>, maxBytes: number, onLimitExceeded: () => never, decoder?: {
+  decode(input?: Uint8Array, options?: {
+    stream?: boolean;
+  }): string;
+}): Promise<string>;
 //#endregion

package/dist/utils/text-stream.js

@@ -30,17 +30,17 @@ async function readStreamAsText(stream) {
 	}
 }
 /**
-* Drain a UTF-8 byte stream up to `maxBytes` of *raw* input, returning the
-* decoded text. If the raw size limit is exceeded, cancellation is signalled
-* and `onLimitExceeded` is invoked; it MUST throw — its return type is
-* `never` to enforce that. Each caller passes its own error type.
+* Drain a byte stream up to `maxBytes` of *raw* input, returning the decoded
+* text (UTF-8 unless the caller passes its own `decoder`). If the raw size
+* limit is exceeded, cancellation is signalled and `onLimitExceeded` is
+* invoked; it MUST throw — its return type is `never` to enforce that. Each
+* caller passes its own error type.
 *
 * The size check is on raw bytes (pre-decode) to bound memory before
 * paying the decoder cost.
 */
-async function readStreamAsTextWithLimit(stream, maxBytes, onLimitExceeded) {
+async function readStreamAsTextWithLimit(stream, maxBytes, onLimitExceeded, decoder = new TextDecoder()) {
 	const reader = stream.getReader();
-	const decoder = new TextDecoder();
 	const chunks = [];
 	let totalSize = 0;
 	try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vinext",
-  "version": "1.3.1",
+  "version": "1.4.1",
   "description": "Run Next.js apps on Vite. Drop-in replacement for the next CLI.",
   "homepage": "https://vinext.dev/",
   "license": "MIT",
@@ -240,6 +240,7 @@
     "@vitejs/plugin-react": "^6.1.0",
     "@vitejs/plugin-rsc": "^0.5.38",
     "am-i-vibing": "^0.5.0",
+    "iconv-lite": "0.4.24",
     "ignore": "5.3.2",
     "image-size": "2.0.4",
     "pathslash": "^0.1.0",

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

@@ -1,60 +0,0 @@
-//#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.
- */
-export 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";
-};
-export 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).
- */
-export type LayoutBuildClassification = {
-  kind: "absent";
-} | {
-  kind: "static";
-  reason: ClassificationReason;
-} | {
-  kind: "dynamic";
-  reason: ClassificationReason;
-} | {
-  kind: "needs-probe";
-  reason: ClassificationReason;
-};
-//#endregion

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

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

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

@@ -1,62 +0,0 @@
-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;
-};
-export 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.
- */
-export declare function classifyLayoutByModuleGraph(layoutModuleId: string, dynamicShimPaths: ReadonlySet<string>, moduleInfo: ModuleInfoProvider): ModuleGraphClassificationResult;
-export declare function moduleGraphReason(graphResult: ModuleGraphClassificationResult & {
-  result: "static";
-}): ModuleGraphStaticReason;
-export declare function moduleGraphReason(graphResult: ModuleGraphClassificationResult): ClassificationReason;
-export 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 `renderChunk` 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`.
- */
-export declare function classifyAllRouteLayouts(routes: readonly RouteForClassification[], dynamicShimPaths: ReadonlySet<string>, moduleInfo: ModuleInfoProvider): Map<string, LayoutBuildClassification>;
-//#endregion
-export {};

package/dist/build/layout-classification.js

@@ -1,98 +0,0 @@
-import { classifyLayoutSegmentConfig } from "./report.js";
-import { AppElementsWire } from "../server/app-elements-wire.js";
-import "../server/app-elements.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 `renderChunk` 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 = AppElementsWire.encodeLayoutId(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 };

package/dist/build/route-classification-injector.d.ts

@@ -1,33 +0,0 @@
-import { ModuleInfoProvider } from "./layout-classification.js";
-import { RouteClassificationManifest } from "./route-classification-manifest.js";
-//#region src/build/route-classification-injector.d.ts
-/**
- * Build-time route classification injection.
- *
- * Codegen describes route shape by emitting stable `__VINEXT_CLASS` stubs and
- * per-route call sites. This module owns the behavioral side of replacing
- * those stubs with build-time decisions once the final RSC module graph exists.
- */
-type RouteClassificationChunk = {
-  code: string;
-  fileName: string;
-};
-type RouteClassificationInjectionPlan = {
-  kind: "skip";
-} | {
-  code: string;
-  fileName: string;
-  kind: "patch";
-  map: null;
-};
-type PlanRouteClassificationInjectionOptions = {
-  canonicalizeLayoutPath?: (path: string) => string;
-  chunks: readonly RouteClassificationChunk[];
-  dynamicShimPaths: ReadonlySet<string>;
-  enableDebugReasons: boolean;
-  manifest: RouteClassificationManifest;
-  moduleInfo: ModuleInfoProvider;
-};
-export declare function planRouteClassificationInjection(options: PlanRouteClassificationInjectionOptions): RouteClassificationInjectionPlan;
-//#endregion
-export {};