vinext 1.3.0 → 1.3.1

package/dist/plugins/rsc-client-reference-loaders.js

@@ -1,15 +1,25 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { magicStringTransformResult, omitUnusedBuildSourcemap } from "./transform-result.js";
+import { resolveShimRuntimeModule } from "../entries/runtime-entry-module.js";
 import { CLIENT_REFERENCE_GROUP_MAX_COST_BYTES, collectClientReferencePreloadPlan, collectClientReferenceRouteSignatures, measureClientReferenceGroupCosts, planClientReferenceGroups, readClientModuleBindings } from "../build/client-reference-groups.js";
-import { hasUserClientChunkGroups } from "../build/client-build-config.js";
+import { collectAsyncModules, createSideEffectsDeclarationCheck } from "../build/client-reference-async.js";
+import { RESOLVED_EAGER_CLIENT_REFERENCES_ID, hasUserClientChunkGroups } from "../build/client-build-config.js";
 import fs from "node:fs";
 import { isCSSRequest } from "vite";
+import { randomBytes } from "node:crypto";
+import MagicString from "magic-string";
 //#region src/plugins/rsc-client-reference-loaders.ts
 const CLIENT_REFERENCES_ID = "\0virtual:vite-rsc/client-references";
 const RESOLVED_ID_PROXY_PREFIX = "virtual:vite-rsc/resolved-id/";
 const RESOLVED_CLIENT_REFERENCE_GROUP_PREFIX = `\0virtual:vinext-client-reference-group-`;
+/** Prefixes the module that registers one client reference outside every group. */
+const RESOLVED_CLIENT_REFERENCE_MODULE_PREFIX = `\0virtual:vinext-client-reference-module/`;
 const CLIENT_REFERENCES_ID_RE = /^\0virtual:vite-rsc\/client-references$/;
-const CLIENT_REFERENCE_GROUP_RE = /^virtual:vinext-client-reference-group-/;
-const RESOLVED_CLIENT_REFERENCE_GROUP_RE = /^\0virtual:vinext-client-reference-group-/;
+const CLIENT_REFERENCE_MODULE_RE = /^virtual:vinext-client-reference-(?:group-|module\/)|^virtual:vinext-client-reference-(?:chunks|eager)$/;
+const RESOLVED_CLIENT_REFERENCE_MODULE_RE = /^\0virtual:vinext-client-reference-(?:group-|module\/)|^\0virtual:vinext-client-reference-(?:chunks|eager)$/;
+const CLIENT_REFERENCE_CHUNKS_ID = "virtual:vinext-client-reference-chunks";
+const RESOLVED_CLIENT_REFERENCE_CHUNKS_ID = `\0${CLIENT_REFERENCE_CHUNKS_ID}`;
+const NO_ROUTE_CLIENT_REFERENCES_EXPORT = "export const routeClientReferences = null;\n";
 /**
 * Whether the cost estimate loads a module. Rolldown keeps externals and
 * unresolved `require()`s in `importedIds` under their specifier (a bare name
@@ -47,50 +57,73 @@ function withResolvedIdProxy(resolvedId) {
 function sortedRenderedExports(meta) {
 	return meta.renderedExports.slice().sort();
 }
-function groupExportName(slotIndex, exportIndex) {
-	return `r${slotIndex}_${exportIndex}`;
+/**
+* The exports of a client reference, read from the module namespace `binding`.
+* Keep them lazy. In async or cyclic client module evaluation, eagerly copying
+* module namespace values can observe an uninitialized binding.
+*/
+function generateClientReferenceObject(meta, binding) {
+	const exports = sortedRenderedExports(meta).map((name) => `  get ${JSON.stringify(name)}() { return ${binding}[${JSON.stringify(name)}]; },`).join("\n");
+	return exports ? `{\n${exports}\n}` : "{}";
 }
-function generateClientReferenceObject(meta, slot) {
-	const exports = sortedRenderedExports(meta).map((name, exportIndex) => {
-		const value = slot ? `m.${groupExportName(slot.index, exportIndex)}` : `m[${JSON.stringify(name)}]`;
-		return `      get ${JSON.stringify(name)}() { return ${value}; },`;
-	}).join("\n");
-	return exports ? `{\n${exports}\n    }` : "{}";
+function generateClientReferenceLoaders(metas) {
+	return `export default {\n${metas.slice().sort((a, b) => a.referenceKey.localeCompare(b.referenceKey)).map((meta) => [
+		`${JSON.stringify(meta.referenceKey)}: async () => {`,
+		`  const m = await import(${JSON.stringify(withResolvedIdProxy(meta.importId))});`,
+		`  return ${generateClientReferenceObject(meta, "m")};`,
+		`},`
+	].join("\n")).join("\n")}\n};\n`;
 }
-function generateClientReferenceLoaders(metas, slots = /* @__PURE__ */ new Map()) {
-	return `export default {\n${metas.slice().sort((a, b) => a.referenceKey.localeCompare(b.referenceKey)).map((meta) => {
-		const slot = slots.get(meta);
-		const source = slot ? slot.groupId : withResolvedIdProxy(meta.importId);
-		return [
-			`  ${JSON.stringify(meta.referenceKey)}: async () => {`,
-			`    const m = await import(${JSON.stringify(source)});`,
-			`    return ${generateClientReferenceObject(meta, slot)};`,
-			`  },`
-		].join("\n");
-	}).join("\n")}\n};\n`;
+/**
+* The client build's client-references module, which the App browser entry
+* imports. It names no client reference chunk, so the entry neither grows nor
+* changes its hash with the app's client references: each reference's Flight
+* row names the chunks it loads (see shims/internal/client-reference-loader.ts).
+*/
+function generateBrowserClientReferencesModule(loaderPath, eager) {
+	return `${eager ? `import ${JSON.stringify(RESOLVED_EAGER_CLIENT_REFERENCES_ID.slice(1))};\n` : ""}export { clientReferences as default } from ${JSON.stringify(loaderPath)};\n`;
 }
 /**
-* Re-export only each member's rendered exports, as live bindings, so unused
-* exports and their dependencies still tree-shake as they do with direct
-* loaders. A member without rendered exports is imported for its side effects.
+* A client build module that registers client references as it evaluates:
+* a route group's members, the references in chunks every page loads, or one
+* other reference outside every group. It imports
+* only each member's rendered exports, so unused exports and their
+* dependencies still tree-shake as they do with direct loaders. A member
+* without rendered exports is imported for its side effects. The last member
+* is imported last (see build/client-reference-chunks.ts).
 */
-function generateClientReferenceGroupModule(metas) {
-	return `${metas.map((meta, slotIndex) => {
+function generateClientReferenceModule(metas, loaderPath) {
+	const imports = metas.map((meta, index) => {
 		const source = JSON.stringify(withResolvedIdProxy(meta.importId));
-		const specifiers = sortedRenderedExports(meta).map((name, exportIndex) => {
-			return `${/^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name)} as ${groupExportName(slotIndex, exportIndex)}`;
-		});
-		return specifiers.length > 0 ? `export { ${specifiers.join(", ")} } from ${source};` : `import ${source};`;
-	}).join("\n")}\n`;
+		return meta.renderedExports.length > 0 ? `import * as m${index} from ${source};` : `import ${source};`;
+	});
+	const registrations = metas.map((meta, index) => `registerClientReference(${JSON.stringify(meta.referenceKey)}, ${generateClientReferenceObject(meta, `m${index}`)});`);
+	return [
+		`import { registerClientReference } from ${JSON.stringify(loaderPath)};`,
+		...imports,
+		...registrations,
+		""
+	].join("\n");
+}
+/**
+* The browser never loads this module. Its dynamic imports make each client
+* reference module a chunk of its own that only a Flight row names.
+*/
+function generateClientReferenceChunksModule(moduleIds) {
+	return `export default [\n${moduleIds.map((id) => `  () => import(${JSON.stringify(id.slice(1))}),`).join("\n")}\n];\n`;
 }
 /**
 * The SSR build's `routeClientReferences` export: the reference keys each route
 * preloads before it renders (see server/app-client-reference-preloader.ts),
 * stored as indices into `references`. Client references the plan doesn't know
-* join `always`.
+* join `always`. `async` holds `asyncPlaceholder`, which renderChunk replaces
+* with the candidates whose SSR modules evaluate asynchronously.
 */
-function generateRouteClientReferencesExport(plan, metaEntries) {
-	if (!plan) return "export const routeClientReferences = null;\n";
+function generateRouteClientReferencesExport(plan, metaEntries, asyncPlaceholder) {
+	if (!plan) return {
+		code: NO_ROUTE_CLIENT_REFERENCES_EXPORT,
+		asyncCandidates: []
+	};
 	const metaById = new Map(metaEntries);
 	const references = [];
 	const indices = /* @__PURE__ */ new Map();
@@ -105,14 +138,28 @@ function generateRouteClientReferencesExport(plan, metaEntries) {
 		}
 		return [index];
 	});
+	const always = toIndices([...plan.preloads.always, ...metaEntries.map(([referenceId]) => referenceId).filter((referenceId) => !plan.referenceIds.has(referenceId))]);
+	const files = plan.preloads.files.map(toIndices);
+	const asyncCandidates = plan.preloads.staticOnly.flatMap((referenceId) => {
+		const index = indices.get(referenceId);
+		const meta = metaById.get(referenceId);
+		return index === void 0 || !meta ? [] : [{
+			index,
+			importId: meta.importId
+		}];
+	});
 	const manifest = {
 		references,
-		always: toIndices([...plan.preloads.always, ...metaEntries.map(([referenceId]) => referenceId).filter((referenceId) => !plan.referenceIds.has(referenceId))]),
-		files: plan.preloads.files.map(toIndices),
+		always,
+		files,
 		routes: Object.fromEntries(plan.preloads.routes),
-		routeless: plan.preloads.routeless
+		routeless: plan.preloads.routeless,
+		async: asyncPlaceholder
+	};
+	return {
+		code: `export const routeClientReferences = ${JSON.stringify(manifest)};\n`,
+		asyncCandidates
 	};
-	return `export const routeClientReferences = ${JSON.stringify(manifest)};\n`;
 }
 /**
 * Replaces @vitejs/plugin-rsc's client-reference facades with per-reference
@@ -126,13 +173,17 @@ function generateRouteClientReferencesExport(plan, metaEntries) {
 function createRscClientReferenceLoadersPlugin(options = {}) {
 	const { routes: routeOptions } = options;
 	const grouping = routeOptions && options.grouping;
+	const loaderPath = resolveShimRuntimeModule("internal/client-reference-loader");
 	let rscApi;
 	let root = "";
 	let groupingEnabled = false;
 	let routeSignatures = /* @__PURE__ */ new Map();
 	// @vitejs/plugin-rsc also builds before the SSR environment.
 	let preloadPlan = null;
-	const groupModules = /* @__PURE__ */ new Map();
+	const referenceModules = /* @__PURE__ */ new Map();
+	let asyncCandidates = [];
+	const asyncPlaceholder = `__vinext_async_client_references_${randomBytes(8).toString("hex")}__`;
+	const asyncPlaceholderRe = new RegExp(`(["'])${asyncPlaceholder}\\1`, "g");
 	return {
 		name: "vinext:rsc-client-reference-loaders",
 		enforce: "post",
@@ -152,7 +203,10 @@ function createRscClientReferenceLoadersPlugin(options = {}) {
 				routeSignatures = /* @__PURE__ */ new Map();
 				preloadPlan = null;
 			}
-			if (this.environment.name === "client") groupModules.clear();
+			if (this.environment.name === "client") {
+				referenceModules.clear();
+				options.onClientReferenceModules?.(/* @__PURE__ */ new Map());
+			}
 		},
 		buildEnd(error) {
 			if (error || !routeOptions) return;
@@ -185,15 +239,15 @@ function createRscClientReferenceLoadersPlugin(options = {}) {
 			});
 		},
 		resolveId: {
-			filter: { id: CLIENT_REFERENCE_GROUP_RE },
+			filter: { id: CLIENT_REFERENCE_MODULE_RE },
 			handler(source) {
-				return groupModules.has(`\0${source}`) ? `\0${source}` : null;
+				return referenceModules.has(`\0${source}`) ? `\0${source}` : null;
 			}
 		},
 		load: {
-			filter: { id: RESOLVED_CLIENT_REFERENCE_GROUP_RE },
+			filter: { id: RESOLVED_CLIENT_REFERENCE_MODULE_RE },
 			handler(id) {
-				return groupModules.get(id) ?? null;
+				return referenceModules.get(id) ?? null;
 			}
 		},
 		transform: {
@@ -204,16 +258,23 @@ function createRscClientReferenceLoadersPlugin(options = {}) {
 				const isServer = this.environment.config.consumer === "server";
 				const metaEntries = Object.entries(manager.clientReferenceMetaMap).filter(([, meta]) => meta.serverChunk);
 				const metas = metaEntries.map(([, meta]) => meta);
-				const routeClientReferencesExport = isServer ? generateRouteClientReferencesExport(preloadPlan, metaEntries) : "";
+				let routeClientReferencesExport = "";
+				if (isServer) {
+					const generated = generateRouteClientReferencesExport(preloadPlan, metaEntries, asyncPlaceholder);
+					routeClientReferencesExport = generated.code;
+					asyncCandidates = generated.asyncCandidates;
+				}
 				if (metas.length === 0) return isServer ? {
 					code: `${code}\n${routeClientReferencesExport}`,
 					map: null
 				} : null;
 				for (const [id, meta] of metaEntries) meta.groupChunkId = id;
-				const slots = /* @__PURE__ */ new Map();
+				const isClientBuild = this.environment.name === "client" && this.environment.mode === "build";
+				const moduleKeys = /* @__PURE__ */ new Map();
+				const grouped = /* @__PURE__ */ new Set();
 				const referenceIds = new Set(metaEntries.map(([referenceId]) => referenceId));
 				const referenceKeys = new Map(metaEntries.map(([referenceId, meta]) => [referenceId, meta.referenceKey]));
-				if (grouping && groupingEnabled && this.environment.name === "client" && this.environment.mode === "build" && planClientReferenceGroups({
+				if (grouping && groupingEnabled && isClientBuild && planClientReferenceGroups({
 					referenceIds,
 					referenceKeys,
 					signatures: routeSignatures,
@@ -241,7 +302,6 @@ function createRscClientReferenceLoadersPlugin(options = {}) {
 						addResolution(resolved);
 					}));
 					const { external } = this.environment.config.build.rolldownOptions;
-					const moduleInfos = /* @__PURE__ */ new Map();
 					const excludedById = /* @__PURE__ */ new Map();
 					const isExcludedById = (moduleId) => {
 						let excluded = excludedById.get(moduleId);
@@ -261,9 +321,7 @@ function createRscClientReferenceLoadersPlugin(options = {}) {
 									importedIds: []
 								};
 							}
-							const info = await this.load(resolutions.get(moduleId) ?? { id: moduleId });
-							moduleInfos.set(moduleId, info);
-							const { code, importedIds } = info;
+							const { code, importedIds } = await this.load(resolutions.get(moduleId) ?? { id: moduleId });
 							if (code === null) return {
 								code,
 								importedIds
@@ -303,12 +361,6 @@ function createRscClientReferenceLoadersPlugin(options = {}) {
 						isSideEffectFree: (moduleId) => packages.get(moduleId)?.moduleSideEffects === false,
 						isExcluded: (moduleId) => externalIds.has(moduleId) || isExcludedById(moduleId)
 					});
-					for (const [referenceId, meta] of metaEntries) {
-						const moduleId = references.get(referenceId);
-						const info = moduleId === void 0 ? void 0 : moduleInfos.get(moduleId);
-						if (!info || info.inputFormat === "cjs") continue;
-						if (meta.renderedExports.some((name) => !info.exports.includes(name))) costs.set(referenceId, null);
-					}
 					const groups = planClientReferenceGroups({
 						referenceIds,
 						referenceKeys,
@@ -320,21 +372,71 @@ function createRscClientReferenceLoadersPlugin(options = {}) {
 					for (const group of groups) {
 						const groupMetas = group.referenceIds.map((referenceId) => metaById.get(referenceId));
 						const resolvedGroupId = `${RESOLVED_CLIENT_REFERENCE_GROUP_PREFIX}${group.key}`;
-						groupModules.set(resolvedGroupId, generateClientReferenceGroupModule(groupMetas));
-						groupMetas.forEach((meta, index) => {
+						referenceModules.set(resolvedGroupId, generateClientReferenceModule(groupMetas, loaderPath));
+						moduleKeys.set(resolvedGroupId, groupMetas.map((meta) => meta.referenceKey));
+						for (const meta of groupMetas) {
 							meta.groupChunkId = resolvedGroupId;
-							slots.set(meta, {
-								groupId: resolvedGroupId.slice(1),
-								index
-							});
-						});
+							grouped.add(meta);
+						}
 					}
 				}
+				if (isClientBuild) {
+					const eager = [];
+					for (const [referenceId, meta] of metaEntries) {
+						if (grouped.has(meta)) continue;
+						if (grouping && groupingEnabled && grouping.isAlwaysLoadedClientModule(referenceId)) {
+							eager.push(meta);
+							continue;
+						}
+						const fileName = path.basename(meta.importId).replace(/\.[^.]*$/, "");
+						const moduleId = `${RESOLVED_CLIENT_REFERENCE_MODULE_PREFIX}${meta.referenceKey}/${fileName}`;
+						referenceModules.set(moduleId, generateClientReferenceModule([meta], loaderPath));
+						moduleKeys.set(moduleId, [meta.referenceKey]);
+						meta.groupChunkId = moduleId;
+					}
+					if (eager.length > 0) referenceModules.set(RESOLVED_EAGER_CLIENT_REFERENCES_ID, generateClientReferenceModule(eager, loaderPath));
+					referenceModules.set(RESOLVED_CLIENT_REFERENCE_CHUNKS_ID, generateClientReferenceChunksModule([...moduleKeys.keys()].sort()));
+					this.emitFile({
+						type: "chunk",
+						id: CLIENT_REFERENCE_CHUNKS_ID,
+						preserveSignature: "strict"
+					});
+					options.onClientReferenceModules?.(moduleKeys);
+					return {
+						code: generateBrowserClientReferencesModule(loaderPath, eager.length > 0),
+						map: null
+					};
+				}
 				return {
-					code: generateClientReferenceLoaders(metas, slots) + routeClientReferencesExport,
+					code: generateClientReferenceLoaders(metas) + routeClientReferencesExport,
 					map: null
 				};
 			}
+		},
+		async renderChunk(code, _chunk, _outputOptions, meta) {
+			if (this.environment.config.consumer !== "server") return null;
+			if (!code.includes(asyncPlaceholder)) return null;
+			const roots = /* @__PURE__ */ new Map();
+			await Promise.all(asyncCandidates.map(async ({ index, importId }) => {
+				let id = importId;
+				if (!importId.startsWith("\0") && !path.isAbsolute(importId)) {
+					const resolved = await this.resolve(importId);
+					id = resolved && !resolved.external ? resolved.id : void 0;
+				}
+				if (id === void 0) return;
+				let list = roots.get(id);
+				if (!list) roots.set(id, list = []);
+				list.push(index);
+			}));
+			const asyncIndices = [...collectAsyncModules({
+				roots: [...roots.keys()],
+				getModuleInfo: (id) => this.getModuleInfo(id),
+				chunks: Object.values(meta.chunks),
+				declaresSideEffects: createSideEffectsDeclarationCheck()
+			})].flatMap((id) => roots.get(id)).sort((a, b) => a - b);
+			const output = new MagicString(code);
+			for (const match of code.matchAll(asyncPlaceholderRe)) output.overwrite(match.index, match.index + match[0].length, JSON.stringify(asyncIndices));
+			return omitUnusedBuildSourcemap(this.environment, magicStringTransformResult(output));
 		}
 	};
 }
@@ -353,7 +455,7 @@ function createRouteClientReferencesFallbackPlugin() {
 			handler(code) {
 				if (this.environment.config.consumer !== "server") return null;
 				return {
-					code: `${code}\n${generateRouteClientReferencesExport(null, [])}`,
+					code: `${code}\n${NO_ROUTE_CLIENT_REFERENCES_EXPORT}`,
 					map: null
 				};
 			}
@@ -361,4 +463,4 @@ function createRouteClientReferencesFallbackPlugin() {
 	};
 }
 //#endregion
-export { createRouteClientReferencesFallbackPlugin, createRscClientReferenceLoadersPlugin };
+export { RESOLVED_CLIENT_REFERENCE_CHUNKS_ID, RESOLVED_CLIENT_REFERENCE_MODULE_PREFIX, createRouteClientReferencesFallbackPlugin, createRscClientReferenceLoadersPlugin };

package/dist/plugins/rsc-client-shim-excludes.js

@@ -18,7 +18,9 @@ const VINEXT_OPTIMIZE_DEPS_EXCLUDE = Object.freeze([
 const SSR_EXTERNAL_REACT_ENTRIES = Object.freeze([
 	"react",
 	"react-dom",
+	"react-dom/server",
 	"react-dom/server.edge",
+	"react-dom/static",
 	"react-dom/static.edge",
 	"react/jsx-runtime",
 	"react/jsx-dev-runtime",

package/dist/plugins/sass.d.ts

@@ -102,4 +102,5 @@ export declare function createSassAwareFileSystemLoader(): {
   };
   setResolvedConfig: (config: ResolvedConfig) => void;
 };
-//#endregion
+//#endregion
+export {};

package/dist/plugins/strip-server-exports.d.ts

@@ -18,4 +18,5 @@ type StripServerExportsResult = {
  * - crates/next-custom-transforms/src/transforms/strip_page_exports.rs
  */
 export declare function stripServerExports(code: string): StripServerExportsResult | null;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/styled-jsx.d.ts

@@ -11,4 +11,5 @@ type StyledJsxPluginOptions = {
   importModule?: (url: string) => Promise<NextSwcModule>;
 };
 export declare function createStyledJsxPlugin(initialProjectRoot: string, options?: StyledJsxPluginOptions): Plugin;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/transform-result.d.ts

@@ -28,4 +28,5 @@ export declare function omitUnusedBuildSourcemap<TMap = ReturnType<MagicString["
   code: string;
   map: TMap | null;
 } | null;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/typeof-window.d.ts

@@ -25,4 +25,5 @@ export declare function getTypeofWindowReplacement(environment: EnvironmentLike)
 export declare function mayFoldChangeScannedImports(code: string): boolean;
 export declare function replaceTypeofWindow(code: string, replacement: WindowType, id?: string): MagicStringTransformResult<import("magic-string").SourceMap> | null;
 export declare function replaceConsumerEnvironmentConditions(code: string, replacements: ConsumerEnvironmentReplacements, id?: string): MagicStringTransformResult<import("magic-string").SourceMap> | null;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/worker-image-imports.js

@@ -42,7 +42,7 @@ function createWorkerImageImportsPlugin(options = {}) {
 				let dimensions = dimensionCache.get(imagePath);
 				if (!dimensions) {
 					try {
-						const { imageSize } = await import("../deps/.pnpm/image-size@2.0.2/deps/image-size/dist/index.js");
+						const { imageSize } = await import("../deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/index.js");
 						const result = imageSize(fs.readFileSync(imagePath));
 						dimensions = {
 							width: result.width ?? 0,

package/dist/plugins/worker-use-server.d.ts

@@ -22,4 +22,5 @@ export declare function createWorkerUseServerPlugins(options: {
   rscPluginModule: Promise<RscPluginModule>;
   rscPluginPath: string;
 }): Promise<Plugin[]>;
-//#endregion
+//#endregion
+export {};

package/dist/routing/app-route-graph.d.ts

@@ -44,6 +44,30 @@ type InterceptingRoute = {
   notFoundBranchSegments?: string[];
   /** Tree position relative to the normalized interception branch. */
   notFoundTreePosition?: number | null;
+  /** Nearest forbidden convention inside the interception branch. */
+  forbiddenPath?: string | null;
+  /** Tree position relative to the normalized interception branch. */
+  forbiddenTreePosition?: number | null;
+  /** Nearest unauthorized convention inside the interception branch. */
+  unauthorizedPath?: string | null;
+  /** Tree position relative to the normalized interception branch. */
+  unauthorizedTreePosition?: number | null;
+  /** Every not-found convention inside the interception branch, outermost first. */
+  notFoundPaths?: string[];
+  /** Tree positions for notFoundPaths in the normalized interception branch. */
+  notFoundTreePositions?: number[];
+  /** Every forbidden convention inside the interception branch, outermost first. */
+  forbiddenPaths?: string[];
+  /** Tree positions for forbiddenPaths in the normalized interception branch. */
+  forbiddenTreePositions?: number[];
+  /** Every unauthorized convention inside the interception branch, outermost first. */
+  unauthorizedPaths?: string[];
+  /** Tree positions for unauthorizedPaths in the normalized interception branch. */
+  unauthorizedTreePositions?: number[];
+  /** Every error convention inside the interception branch, outermost first. */
+  errorPaths?: string[];
+  /** Tree positions for errorPaths in the normalized interception branch. */
+  errorTreePositions?: number[];
   /** Parameter names for dynamic segments */
   params: string[];
   /**
@@ -89,6 +113,10 @@ type ParallelSlot = {
   notFoundPath?: string | null;
   /** Tree position of that convention relative to the slot root. */
   notFoundTreePosition?: number | null;
+  /** Every not-found convention from the slot root to its active page, outermost first. */
+  notFoundPaths?: string[];
+  /** Slot-root-relative tree positions aligned with notFoundPaths. */
+  notFoundTreePositions?: number[];
   /** Intercepting routes within this slot */
   interceptingRoutes: InterceptingRoute[];
   /**
@@ -191,6 +219,18 @@ export type AppRoute = {
   unauthorizedTreePosition?: number | null;
   /** Unauthorized component paths per layout level (aligned with layouts array). */
   unauthorizedPaths: (string | null)[];
+  /**
+   * Not-found, forbidden and unauthorized component paths for every segment
+   * from app/ to the route's directory, including segments without a layout,
+   * aligned with the matching tree positions. A layout's notFound() is caught
+   * by the deepest of these above the layout's own segment.
+   */
+  segmentNotFoundPaths?: string[];
+  segmentNotFoundTreePositions?: number[];
+  segmentForbiddenPaths?: string[];
+  segmentForbiddenTreePositions?: number[];
+  segmentUnauthorizedPaths?: string[];
+  segmentUnauthorizedTreePositions?: number[];
   /**
    * Filesystem segments from app/ root to the route's directory.
    * Includes route groups and dynamic segments (as template strings like "[id]").