vinext 1.3.1 → 1.4.0

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.0",
   "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 {};

package/dist/build/route-classification-injector.js

@@ -1,59 +0,0 @@
-import { buildClassificationReplacement, buildReasonsReplacement } from "./route-classification-manifest.js";
-import { classifyLayoutByModuleGraph, isStaticModuleGraphResult, moduleGraphReason } from "./layout-classification.js";
-//#region src/build/route-classification-injector.ts
-const CLASS_STUB_RE = /function __VINEXT_CLASS\(routeIdx\)\s*\{\s*return null;?\s*\}/;
-const REASONS_STUB_RE = /function __VINEXT_CLASS_REASONS\(routeIdx\)\s*\{\s*return null;?\s*\}/;
-function identityPath(path) {
-	return path;
-}
-function findClassificationChunk(chunks) {
-	const chunksMentioningStub = chunks.filter((chunk) => chunk.code.includes("__VINEXT_CLASS"));
-	const chunksWithStubBody = chunksMentioningStub.filter((chunk) => CLASS_STUB_RE.test(chunk.code));
-	const chunkWithStubBody = chunksWithStubBody[0];
-	if (chunksMentioningStub.length === 0) return null;
-	if (chunkWithStubBody === void 0) throw new Error(`vinext: build-time classification — __VINEXT_CLASS is referenced in ${chunksMentioningStub.map((chunk) => chunk.fileName).join(", ")} but no chunk contains the stub body. The generator and the classification injector have drifted.`);
-	if (chunksWithStubBody.length > 1) throw new Error(`vinext: build-time classification — expected __VINEXT_CLASS stub in exactly one RSC chunk, found ${chunksWithStubBody.length}`);
-	return chunkWithStubBody;
-}
-function buildLayer2Classifications(options) {
-	const canonicalizeLayoutPath = options.canonicalizeLayoutPath ?? identityPath;
-	const layer2PerRoute = /* @__PURE__ */ new Map();
-	const graphCache = /* @__PURE__ */ new Map();
-	for (let routeIdx = 0; routeIdx < options.manifest.routes.length; routeIdx++) {
-		const route = options.manifest.routes[routeIdx];
-		const perRoute = /* @__PURE__ */ new Map();
-		for (let layoutIdx = 0; layoutIdx < route.layoutPaths.length; layoutIdx++) {
-			if (route.layer1.has(layoutIdx)) continue;
-			const layoutModuleId = canonicalizeLayoutPath(route.layoutPaths[layoutIdx]);
-			if (!options.moduleInfo.getModuleInfo(layoutModuleId)) continue;
-			let graphResult = graphCache.get(layoutModuleId);
-			if (graphResult === void 0) {
-				graphResult = classifyLayoutByModuleGraph(layoutModuleId, options.dynamicShimPaths, options.moduleInfo);
-				graphCache.set(layoutModuleId, graphResult);
-			}
-			if (isStaticModuleGraphResult(graphResult)) perRoute.set(layoutIdx, moduleGraphReason(graphResult));
-		}
-		if (perRoute.size > 0) layer2PerRoute.set(routeIdx, perRoute);
-	}
-	return layer2PerRoute;
-}
-function planRouteClassificationInjection(options) {
-	const target = findClassificationChunk(options.chunks);
-	if (!target) return { kind: "skip" };
-	if (options.enableDebugReasons && !REASONS_STUB_RE.test(target.code)) throw new Error("vinext: build-time classification — __VINEXT_CLASS_REASONS stub is missing alongside __VINEXT_CLASS. The generator and the classification injector have drifted.");
-	const layer2PerRoute = buildLayer2Classifications(options);
-	const patchedBody = `function __VINEXT_CLASS(routeIdx) { return (${buildClassificationReplacement(options.manifest, layer2PerRoute)})(routeIdx); }`;
-	let code = target.code.replace(CLASS_STUB_RE, patchedBody);
-	if (options.enableDebugReasons) {
-		const patchedReasonsBody = `function __VINEXT_CLASS_REASONS(routeIdx) { return (${buildReasonsReplacement(options.manifest, layer2PerRoute)})(routeIdx); }`;
-		code = code.replace(REASONS_STUB_RE, patchedReasonsBody);
-	}
-	return {
-		code,
-		fileName: target.fileName,
-		kind: "patch",
-		map: null
-	};
-}
-//#endregion
-export { planRouteClassificationInjection };

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

@@ -1,54 +0,0 @@
-import { AppRoute } from "../routing/app-route-graph.js";
-import { ClassificationReason, ModuleGraphStaticReason } from "./layout-classification-types.js";
-//#region src/build/route-classification-manifest.d.ts
-type Layer1Class = "static" | "dynamic";
-type RouteManifestEntry = {
-  /** Route pattern for diagnostics (e.g. "/blog/:slug"). */
-  pattern: string;
-  /** Absolute file paths for each layout, ordered root → leaf. */
-  layoutPaths: string[];
-  /** Layer 1 (segment config) results keyed by numeric layout index. */
-  layer1: Map<number, Layer1Class>;
-  /**
-   * Structured reasons for every Layer 1 decision, keyed by the same layout
-   * index. Always populated in lockstep with `layer1` so the debug channel
-   * can surface which segment-config field produced the decision.
-   */
-  layer1Reasons: Map<number, ClassificationReason>;
-};
-export type RouteClassificationManifest = {
-  routes: RouteManifestEntry[];
-};
-/**
- * Reads each layout's source at build time and runs Layer 1 segment-config
- * classification. Fails loudly if any layout file is missing — a missing
- * layout means the routing scan and the filesystem have drifted, and shipping
- * a build in that state would silently break layout rendering.
- */
-export declare function collectRouteClassificationManifest(routes: readonly AppRoute[]): RouteClassificationManifest;
-/**
- * Builds a JavaScript arrow-function expression that dispatches route index
- * to a pre-computed `Map<layoutIndex, "static" | "dynamic">` of build-time
- * classifications. The returned string is suitable for embedding into the
- * generated RSC entry via the `renderChunk` hook.
- *
- * `layer2PerRoute` is typed to only carry `"static"` entries — the
- * module-graph classifier can only prove static, so "needs-probe" results
- * are omitted by the caller before this map is constructed.
- */
-export declare function buildClassificationReplacement(manifest: RouteClassificationManifest, layer2PerRoute: ReadonlyMap<number, ReadonlyMap<number, ModuleGraphStaticReason>>): string;
-/**
- * Sibling of `buildClassificationReplacement`: emits a dispatch function
- * that returns `Map<layoutIndex, ClassificationReason>` per route.
- *
- * The runtime consults this map only when `VINEXT_DEBUG_CLASSIFICATION` is
- * set, and the plugin only patches this dispatcher into the built bundle when
- * that env var is present at build time.
- *
- * Layer 1 priority applies the same way as in `buildClassificationReplacement`:
- * a segment-config reason must override a module-graph reason for the same
- * layout index.
- */
-export declare function buildReasonsReplacement(manifest: RouteClassificationManifest, layer2PerRoute: ReadonlyMap<number, ReadonlyMap<number, ModuleGraphStaticReason>>): string;
-//#endregion
-export {};

package/dist/build/route-classification-manifest.js

@@ -1,143 +0,0 @@
-import { classifyLayoutSegmentConfig } from "./report.js";
-import fs from "node:fs";
-//#region src/build/route-classification-manifest.ts
-/**
-* Build-time layout classification manifest.
-*
-* Bridges the classifier in `./layout-classification.ts` with the RSC entry
-* codegen so that the per-layout static/dynamic classifications produced at
-* build time are visible to the runtime probe loop in
-* `server/app-page-execution.ts`.
-*
-* The runtime probe looks up entries by numeric `layoutIndex`, so this module
-* is responsible for flattening the classifier's string-keyed layout IDs into
-* a per-route, index-keyed structure that can be emitted from codegen.
-*/
-/**
-* Reads each layout's source at build time and runs Layer 1 segment-config
-* classification. Fails loudly if any layout file is missing — a missing
-* layout means the routing scan and the filesystem have drifted, and shipping
-* a build in that state would silently break layout rendering.
-*/
-function collectRouteClassificationManifest(routes) {
-	const manifestRoutes = [];
-	const sourceCache = /* @__PURE__ */ new Map();
-	for (const route of routes) {
-		const layer1 = /* @__PURE__ */ new Map();
-		const layer1Reasons = /* @__PURE__ */ new Map();
-		for (let layoutIndex = 0; layoutIndex < route.layouts.length; layoutIndex++) {
-			const layoutPath = route.layouts[layoutIndex];
-			let source = sourceCache.get(layoutPath);
-			if (source === void 0) try {
-				source = fs.readFileSync(layoutPath, "utf8");
-				sourceCache.set(layoutPath, source);
-			} catch (cause) {
-				throw new Error(`vinext: failed to read layout for route ${route.pattern} at ${layoutPath}`, { cause });
-			}
-			const result = classifyLayoutSegmentConfig(source);
-			if (result.kind === "static" || result.kind === "dynamic") {
-				layer1.set(layoutIndex, result.kind);
-				layer1Reasons.set(layoutIndex, result.reason);
-			}
-		}
-		manifestRoutes.push({
-			pattern: route.pattern,
-			layoutPaths: [...route.layouts],
-			layer1,
-			layer1Reasons
-		});
-	}
-	return { routes: manifestRoutes };
-}
-/**
-* Merges Layer 1 (segment config) and Layer 2 (module graph) into a single
-* per-route map, applying the Layer-1-wins priority rule.
-*
-* Layer 1 always takes priority over Layer 2 for the same layout index:
-* segment config is a user-authored guarantee, so a layout that explicitly
-* says `force-dynamic` must never be demoted to "static" because its module
-* graph happened to be clean.
-*/
-function mergeLayersForRoute(route, layer2) {
-	const merged = /* @__PURE__ */ new Map();
-	if (layer2) for (const [layoutIdx, reason] of layer2) merged.set(layoutIdx, {
-		kind: "static",
-		reason
-	});
-	for (const [layoutIdx, kind] of route.layer1) {
-		const reason = route.layer1Reasons.get(layoutIdx);
-		if (reason === void 0) throw new Error(`vinext: layout ${layoutIdx} in route ${route.pattern} has a Layer 1 decision without a reason`);
-		merged.set(layoutIdx, {
-			kind,
-			reason
-		});
-	}
-	return merged;
-}
-function serializeReasonExpression(reason) {
-	switch (reason.layer) {
-		case "segment-config": {
-			const value = reason.value === Infinity ? "Infinity" : JSON.stringify(reason.value);
-			return `{ layer: "segment-config", key: ${JSON.stringify(reason.key)}, value: ${value} }`;
-		}
-		case "module-graph": {
-			const props = [`layer: "module-graph"`, `result: ${JSON.stringify(reason.result)}`];
-			if (reason.firstShimMatch !== void 0) props.push(`firstShimMatch: ${JSON.stringify(reason.firstShimMatch)}`);
-			return `{ ${props.join(", ")} }`;
-		}
-		case "runtime-probe": {
-			const props = [`layer: "runtime-probe"`, `outcome: ${JSON.stringify(reason.outcome)}`];
-			if (reason.error !== void 0) props.push(`error: ${JSON.stringify(reason.error)}`);
-			return `{ ${props.join(", ")} }`;
-		}
-		case "no-classifier": return `{ layer: "no-classifier" }`;
-	}
-}
-function buildRouteDispatchReplacement(manifest, layer2PerRoute, serializeEntry) {
-	const cases = [];
-	for (let routeIdx = 0; routeIdx < manifest.routes.length; routeIdx++) {
-		const route = manifest.routes[routeIdx];
-		const merged = mergeLayersForRoute(route, layer2PerRoute.get(routeIdx));
-		if (merged.size === 0) continue;
-		const entries = [...merged.entries()].sort((a, b) => a[0] - b[0]).map(([idx, value]) => `[${idx}, ${serializeEntry(value)}]`).join(", ");
-		cases.push(`      case ${routeIdx}: return new Map([${entries}]);`);
-	}
-	return [
-		"(routeIdx) => {",
-		"    switch (routeIdx) {",
-		...cases,
-		"      default: return null;",
-		"    }",
-		"  }"
-	].join("\n");
-}
-/**
-* Builds a JavaScript arrow-function expression that dispatches route index
-* to a pre-computed `Map<layoutIndex, "static" | "dynamic">` of build-time
-* classifications. The returned string is suitable for embedding into the
-* generated RSC entry via the `renderChunk` hook.
-*
-* `layer2PerRoute` is typed to only carry `"static"` entries — the
-* module-graph classifier can only prove static, so "needs-probe" results
-* are omitted by the caller before this map is constructed.
-*/
-function buildClassificationReplacement(manifest, layer2PerRoute) {
-	return buildRouteDispatchReplacement(manifest, layer2PerRoute, (value) => JSON.stringify(value.kind));
-}
-/**
-* Sibling of `buildClassificationReplacement`: emits a dispatch function
-* that returns `Map<layoutIndex, ClassificationReason>` per route.
-*
-* The runtime consults this map only when `VINEXT_DEBUG_CLASSIFICATION` is
-* set, and the plugin only patches this dispatcher into the built bundle when
-* that env var is present at build time.
-*
-* Layer 1 priority applies the same way as in `buildClassificationReplacement`:
-* a segment-config reason must override a module-graph reason for the same
-* layout index.
-*/
-function buildReasonsReplacement(manifest, layer2PerRoute) {
-	return buildRouteDispatchReplacement(manifest, layer2PerRoute, (value) => serializeReasonExpression(value.reason));
-}
-//#endregion
-export { buildClassificationReplacement, buildReasonsReplacement, collectRouteClassificationManifest };

package/dist/server/app-browser-client-reuse-manifest.d.ts

@@ -1,11 +0,0 @@
-import { DEFAULT_CLIENT_REUSE_MANIFEST_LIMITS } from "./client-reuse-manifest.js";
-import { AppRouterState } from "./app-browser-state.js";
-//#region src/server/app-browser-client-reuse-manifest.d.ts
-type ClientReuseManifestLimits = typeof DEFAULT_CLIENT_REUSE_MANIFEST_LIMITS;
-type VisibleAppState = Pick<AppRouterState, "elements" | "visibleCommitVersion">;
-type CreateClientReuseManifestHeaderOptions = Readonly<{
-  limits?: ClientReuseManifestLimits;
-}>;
-export declare function createClientReuseManifestHeaderFromVisibleAppState(state: VisibleAppState, options?: CreateClientReuseManifestHeaderOptions): string | null;
-//#endregion
-export {};