vinext 1.2.0 → 1.3.0

package/dist/build/client-reference-groups.js

@@ -0,0 +1,534 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { parseModuleRecord } from "../plugins/ast-utils.js";
+import { actionOwnerRouteEntryIds } from "./action-owner-manifest.js";
+import { createHash } from "node:crypto";
+//#region src/build/client-reference-groups.ts
+/**
+* Client references whose estimated group cost (see
+* {@link measureClientReferenceGroupCosts}) is larger than this many
+* transformed source bytes keep their own lazy chunk instead of joining a route
+* group. Grouping makes every member load with the group, so a heavy component
+* that a route can reach but rarely renders must not be pulled into that
+* route's startup bundle.
+*/
+const CLIENT_REFERENCE_GROUP_MAX_COST_BYTES = 102400;
+const SEGMENT_FILE_ORDER = [
+	"layout",
+	"template",
+	"error",
+	"unauthorized",
+	"forbidden",
+	"not-found",
+	"loading",
+	"default",
+	"page"
+];
+/**
+* Order route files as they render: outer segments first and, within a
+* segment, each file before the ones it wraps. A group evaluates its members in
+* the order the walk reaches them, so this keeps an outer layout's top-level
+* side effects and CSS ahead of its page's, as Next.js evaluates client
+* references in render order.
+*/
+function inRenderOrder(files) {
+	const rank = (file) => {
+		const index = SEGMENT_FILE_ORDER.indexOf(path.basename(file).split(".")[0]);
+		return index === -1 ? SEGMENT_FILE_ORDER.length : index;
+	};
+	return files.map((file) => ({
+		file,
+		depth: path.dirname(file).split("/").length,
+		rank: rank(file)
+	})).sort((a, b) => a.depth - b.depth || a.rank - b.rank).map(({ file }) => file);
+}
+function interceptEntryIds(intercept) {
+	return [
+		intercept.pagePath,
+		...intercept.layoutPaths,
+		...intercept.loadingPaths ?? [],
+		intercept.notFoundPath
+	].filter((value) => typeof value === "string");
+}
+/**
+* Map each client reference reachable from App Router route files to a
+* signature naming the owners that reach it. A route owns its page, layouts,
+* templates, boundaries and parallel slots, which render with it. Intercepting
+* routes (which only render on soft navigation), global-error and
+* global-not-found render on their own, so each is owned by its file, named by
+* its path relative to `root`. References with the same signature are needed
+* together, mirroring Next.js' per-route client entries. The map is in the
+* order a depth-first walk in import order first reaches each reference from
+* the route files in render order, which follows ES module evaluation order.
+*
+* References reachable from no route file (for example vinext's internal
+* runtime references) are omitted and keep their own lazy chunk. So are
+* references that route code reaches through a dynamic import (`next/dynamic`,
+* `React.lazy`), directly or through the dynamically imported module's graph.
+*/
+function collectClientReferenceRouteSignatures(options) {
+	const canonicalize = options.canonicalizeModuleId ?? ((id) => id);
+	const moduleInfoCache = /* @__PURE__ */ new Map();
+	const getModuleInfo = (id) => {
+		let info = moduleInfoCache.get(id);
+		if (info === void 0) {
+			info = options.getModuleInfo(id);
+			moduleInfoCache.set(id, info);
+		}
+		return info;
+	};
+	const lazyReferences = /* @__PURE__ */ new Set();
+	const lazyVisited = /* @__PURE__ */ new Set();
+	const markLazy = (root) => {
+		const stack = [root];
+		while (stack.length > 0) {
+			const id = stack.pop();
+			if (lazyVisited.has(id)) continue;
+			lazyVisited.add(id);
+			if (options.clientReferenceIds.has(id)) {
+				lazyReferences.add(id);
+				continue;
+			}
+			const info = getModuleInfo(id);
+			if (info) stack.push(...info.importedIds, ...info.dynamicallyImportedIds);
+		}
+	};
+	const referencesByFile = /* @__PURE__ */ new Map();
+	const referencesReachedFrom = (file) => {
+		let references = referencesByFile.get(file);
+		if (references) return references;
+		references = /* @__PURE__ */ new Set();
+		const visited = /* @__PURE__ */ new Set();
+		const stack = [canonicalize(file)];
+		while (stack.length > 0) {
+			const id = stack.pop();
+			if (visited.has(id)) continue;
+			visited.add(id);
+			if (options.clientReferenceIds.has(id)) {
+				references.add(id);
+				continue;
+			}
+			const info = getModuleInfo(id);
+			if (!info) continue;
+			for (const importedId of info.dynamicallyImportedIds) markLazy(importedId);
+			for (let index = info.importedIds.length - 1; index >= 0; index--) stack.push(info.importedIds[index]);
+		}
+		referencesByFile.set(file, references);
+		return references;
+	};
+	const owners = /* @__PURE__ */ new Map();
+	const addOwner = (owner, files) => {
+		for (const file of files) for (const reference of referencesReachedFrom(file)) {
+			let referenceOwners = owners.get(reference);
+			if (!referenceOwners) {
+				referenceOwners = /* @__PURE__ */ new Set();
+				owners.set(reference, referenceOwners);
+			}
+			referenceOwners.add(owner);
+		}
+	};
+	const fileOwner = (file) => path.relative(options.root, file);
+	for (const route of options.routes) {
+		addOwner(route.pattern, inRenderOrder(actionOwnerRouteEntryIds({
+			...route,
+			parallelSlots: route.parallelSlots.map((slot) => ({
+				...slot,
+				interceptingRoutes: []
+			})),
+			siblingIntercepts: []
+		})));
+		const intercepts = [...route.parallelSlots.flatMap((slot) => slot.interceptingRoutes), ...route.siblingIntercepts];
+		for (const intercept of intercepts) addOwner(fileOwner(intercept.pagePath), inRenderOrder(interceptEntryIds(intercept)));
+	}
+	for (const file of options.sharedRoots ?? []) addOwner(fileOwner(file), [file]);
+	const signatures = /* @__PURE__ */ new Map();
+	for (const [reference, referenceOwners] of owners) {
+		if (lazyReferences.has(reference)) continue;
+		signatures.set(reference, [...referenceOwners].sort().join("\n"));
+	}
+	return signatures;
+}
+/**
+* Plan which client references SSR loads before rendering each route. A route
+* preloads every client reference its page, layouts, templates, boundaries and
+* parallel slots reach, statically or through dynamic imports (a
+* `next/dynamic` component renders on the server), plus the `always` set.
+* Intercepting routes only render on soft navigation, which SSR never
+* renders, so they add to no set. `entryIds` are the RSC graph's entries:
+* walking them up to route files finds what renders outside any route.
+*/
+function collectClientReferencePreloadPlan(options) {
+	const canonicalize = options.canonicalizeModuleId ?? ((id) => id);
+	const moduleInfoCache = /* @__PURE__ */ new Map();
+	const getModuleInfo = (id) => {
+		let info = moduleInfoCache.get(id);
+		if (info === void 0) {
+			info = options.getModuleInfo(id);
+			moduleInfoCache.set(id, info);
+		}
+		return info;
+	};
+	const reached = /* @__PURE__ */ new Set();
+	const referencesReachedFrom = (roots, stopAt) => {
+		const references = [];
+		const visited = /* @__PURE__ */ new Set();
+		const stack = roots.map(canonicalize).reverse();
+		while (stack.length > 0) {
+			const id = stack.pop();
+			if (visited.has(id)) continue;
+			visited.add(id);
+			if (stopAt?.has(id)) continue;
+			if (options.clientReferenceIds.has(id)) {
+				references.push(id);
+				reached.add(id);
+				continue;
+			}
+			const info = getModuleInfo(id);
+			if (!info) continue;
+			const imports = [...info.importedIds, ...info.dynamicallyImportedIds];
+			for (let index = imports.length - 1; index >= 0; index--) stack.push(imports[index]);
+		}
+		return references;
+	};
+	const files = [];
+	const fileIndices = /* @__PURE__ */ new Map();
+	const fileIndex = (file) => {
+		const id = canonicalize(file);
+		let index = fileIndices.get(id);
+		if (index === void 0) {
+			index = files.length;
+			fileIndices.set(id, index);
+			files.push(referencesReachedFrom([id]));
+		}
+		return index;
+	};
+	const routes = /* @__PURE__ */ new Map();
+	const interceptFiles = [];
+	for (const route of options.routes) {
+		const indices = inRenderOrder(actionOwnerRouteEntryIds({
+			...route,
+			parallelSlots: route.parallelSlots.map((slot) => ({
+				...slot,
+				interceptingRoutes: []
+			})),
+			siblingIntercepts: []
+		})).map(fileIndex);
+		routes.set(route.pattern, [.../* @__PURE__ */ new Set([...routes.get(route.pattern) ?? [], ...indices])]);
+		for (const intercept of [...route.parallelSlots.flatMap((slot) => slot.interceptingRoutes), ...route.siblingIntercepts]) interceptFiles.push(...interceptEntryIds(intercept));
+	}
+	const routeless = [...new Set((options.routelessFiles ?? []).map(fileIndex))];
+	referencesReachedFrom(interceptFiles);
+	const alwaysRoots = options.alwaysRoots ?? [];
+	const stopAt = /* @__PURE__ */ new Set([...fileIndices.keys(), ...[...interceptFiles, ...alwaysRoots].map(canonicalize)]);
+	const always = /* @__PURE__ */ new Set([...referencesReachedFrom(options.entryIds, stopAt), ...referencesReachedFrom(alwaysRoots)]);
+	for (const id of options.clientReferenceIds) if (!reached.has(id)) always.add(id);
+	return {
+		always: [...always],
+		files,
+		routes,
+		routeless
+	};
+}
+function importedName(kind, name) {
+	if (kind === "Name") return name;
+	return kind === "Default" ? "default" : "*";
+}
+/**
+* Read a module's static imports and re-exports for
+* {@link measureClientReferenceGroupCosts}. Returns undefined when the code does
+* not parse or a specifier does not resolve to one of `importedIds`.
+*/
+async function readClientModuleBindings(options) {
+	const { code } = options;
+	const record = parseModuleRecord(code, "js");
+	if (!record) return void 0;
+	const specifiers = /* @__PURE__ */ new Set([...record.staticImports.map((statement) => statement.moduleRequest.value), ...record.staticExports.flatMap((statement) => statement.entries.flatMap((entry) => entry.moduleRequest ? [entry.moduleRequest.value] : []))]);
+	const importedIds = new Set(options.importedIds);
+	const ids = /* @__PURE__ */ new Map();
+	for (const [specifier, id] of await Promise.all([...specifiers].map(async (specifier) => [specifier, await options.resolve(specifier)]))) {
+		if (id === null || !importedIds.has(id)) return void 0;
+		ids.set(specifier, id);
+	}
+	const isIndirect = (statement) => code.startsWith("import", statement.start);
+	const exportList = /export\s*[{*]/y;
+	const ranges = [
+		...record.staticImports,
+		...record.staticExports.filter((statement) => {
+			exportList.lastIndex = statement.start;
+			return exportList.test(code);
+		}),
+		...record.staticExports.filter(isIndirect).flatMap((statement) => statement.entries)
+	].sort((a, b) => a.start - b.start);
+	let body = "";
+	let offset = 0;
+	for (const range of ranges) {
+		if (range.start > offset) body += code.slice(offset, range.start);
+		offset = Math.max(offset, range.end);
+	}
+	body += code.slice(offset);
+	const reexports = [];
+	const localExports = /* @__PURE__ */ new Map();
+	const addLocalExport = (key, exportName) => localExports.set(key, [...localExports.get(key) ?? [], exportName]);
+	for (const statement of record.staticExports) for (const entry of statement.entries) {
+		const exportName = importedName(entry.exportName.kind, entry.exportName.name);
+		const importName = importedName(entry.importName.kind, entry.importName.name);
+		if (entry.moduleRequest && isIndirect(statement)) addLocalExport(`\0${entry.importName.start}`, exportName);
+		else if (entry.moduleRequest) reexports.push({
+			id: ids.get(entry.moduleRequest.value),
+			exportName,
+			importName
+		});
+		else if (entry.localName.name !== null) addLocalExport(entry.localName.name, exportName);
+	}
+	const imports = [];
+	for (const statement of record.staticImports) {
+		const id = ids.get(statement.moduleRequest.value);
+		imports.push({
+			id,
+			names: /* @__PURE__ */ new Set()
+		});
+		for (const entry of statement.entries) {
+			if (entry.isType) continue;
+			const name = importedName(entry.importName.kind, entry.importName.name);
+			const local = entry.localName.value;
+			const exportNames = [...localExports.get(local) ?? [], ...entry.importName.start !== null && localExports.get(`\0${entry.importName.start}`) || []];
+			if (exportNames.length > 0 && !new RegExp(`(?<![\\w$])${local.replaceAll("$", "\\$")}(?![\\w$])`).test(body)) for (const exportName of exportNames) reexports.push({
+				id,
+				exportName,
+				importName: name
+			});
+			else imports.push({
+				id,
+				names: name === "*" ? "*" : /* @__PURE__ */ new Set([name])
+			});
+		}
+	}
+	const covered = new Set(ids.values());
+	for (const id of options.importedIds) if (!covered.has(id)) imports.push({
+		id,
+		names: "*"
+	});
+	return {
+		bytes: Buffer.byteLength(body, "utf8"),
+		imports,
+		reexports
+	};
+}
+/**
+* Estimate, in transformed source bytes, how much code each client reference
+* would add to a route group's chunk: the modules only it uses, plus the cost
+* of every client reference it statically imports (grouping a reference pulls
+* those along). Modules shared with other client references are not charged
+* to any one of them, so shared libraries do not block grouping. With
+* {@link readClientModuleBindings}, a side-effect-free module only charges the
+* re-exports that are imported from it, so a reference that imports one icon
+* from a barrel is not charged for the whole library.
+*
+* `references` maps each client reference id to its module id in the client
+* graph. `isSideEffectFree` reports a module's package `sideEffects` flag as
+* the bundler resolved it. Traversal stops at modules for which `isExcluded`
+* returns true (CSS, always-loaded framework chunks, virtual modules that must
+* not be loaded re-entrantly). A reference whose import graph cannot be fully
+* loaded is reported as `null` so callers keep it out of groups.
+*/
+async function measureClientReferenceGroupCosts(options) {
+	const loaded = /* @__PURE__ */ new Map();
+	const load = (id) => {
+		let module = loaded.get(id);
+		if (!module) {
+			module = options.loadModule(id).catch(() => null);
+			loaded.set(id, module);
+		}
+		return module;
+	};
+	const referenceByModuleId = /* @__PURE__ */ new Map();
+	for (const [referenceId, moduleId] of options.references) referenceByModuleId.set(moduleId, referenceId);
+	const reexportIndexes = /* @__PURE__ */ new Map();
+	const indexReexports = (id, bindings) => {
+		let index = reexportIndexes.get(id);
+		if (index) return index;
+		index = {
+			byName: /* @__PURE__ */ new Map(),
+			stars: [],
+			sideEffectTargets: /* @__PURE__ */ new Set()
+		};
+		for (const edge of bindings.reexports) {
+			if (edge.exportName === "*") {
+				index.stars.push(edge);
+				continue;
+			}
+			const edges = index.byName.get(edge.exportName);
+			if (edges) edges.push(edge);
+			else index.byName.set(edge.exportName, [edge]);
+			if (!options.isSideEffectFree(edge.id)) index.sideEffectTargets.add(edge.id);
+		}
+		reexportIndexes.set(id, index);
+		return index;
+	};
+	const noNames = /* @__PURE__ */ new Set();
+	const importedNames = (edge) => edge.importName === "*" ? "*" : /* @__PURE__ */ new Set([edge.importName]);
+	const slots = /* @__PURE__ */ new Map();
+	const moduleBytes = /* @__PURE__ */ new Map();
+	let frontier = [];
+	const slot = (id, name) => {
+		const key = `${name}\0${id}`;
+		let found = slots.get(key);
+		if (!found) {
+			found = {
+				id,
+				name,
+				children: [],
+				references: [],
+				failed: false
+			};
+			slots.set(key, found);
+			frontier.push(found);
+		}
+		return found;
+	};
+	const link = (from, id, names) => {
+		if (options.isExcluded(id)) return;
+		const reference = referenceByModuleId.get(id);
+		if (reference !== void 0) from.references.push(reference);
+		else if (names === "*" || !options.isSideEffectFree(id)) from.children.push(slot(id, "*"));
+		else for (const name of names) from.children.push(slot(id, name));
+	};
+	const rootSlots = /* @__PURE__ */ new Map();
+	for (const [referenceId, rootModuleId] of options.references) rootSlots.set(referenceId, slot(rootModuleId, "*"));
+	while (frontier.length > 0) {
+		const current = frontier;
+		frontier = [];
+		const modules = await Promise.all(current.map((from) => load(from.id)));
+		for (let index = 0; index < modules.length; index++) {
+			const module = modules[index];
+			const from = current[index];
+			if (!module) {
+				from.failed = true;
+				continue;
+			}
+			const { bindings } = module;
+			moduleBytes.set(from.id, bindings?.bytes ?? (module.code ? Buffer.byteLength(module.code, "utf8") : 0));
+			if (!bindings) {
+				for (const importedId of module.importedIds) link(from, importedId, "*");
+				continue;
+			}
+			for (const edge of bindings.imports) link(from, edge.id, edge.names);
+			if (from.name === "*") {
+				for (const edge of bindings.reexports) link(from, edge.id, importedNames(edge));
+				continue;
+			}
+			const reexports = indexReexports(from.id, bindings);
+			for (const edge of reexports.byName.get(from.name) ?? []) link(from, edge.id, importedNames(edge));
+			const starNames = from.name === "default" ? noNames : /* @__PURE__ */ new Set([from.name]);
+			for (const edge of reexports.stars) link(from, edge.id, starNames);
+			for (const target of reexports.sideEffectTargets) link(from, target, noNames);
+		}
+	}
+	const parents = /* @__PURE__ */ new Map();
+	const leads = /* @__PURE__ */ new Set();
+	for (const from of slots.values()) {
+		for (const child of from.children) {
+			let childParents = parents.get(child);
+			if (!childParents) {
+				childParents = [];
+				parents.set(child, childParents);
+			}
+			childParents.push(from);
+		}
+		if (from.references.length > 0 || from.failed) leads.add(from);
+	}
+	for (const lead of leads) for (const parent of parents.get(lead) ?? []) leads.add(parent);
+	const importedReferences = /* @__PURE__ */ new Map();
+	const unloadable = /* @__PURE__ */ new Set();
+	for (const [referenceId, root] of rootSlots) {
+		const imported = /* @__PURE__ */ new Set();
+		importedReferences.set(referenceId, imported);
+		if (!leads.has(root)) continue;
+		const visited = /* @__PURE__ */ new Set([root]);
+		const stack = [root];
+		while (stack.length > 0) {
+			const current = stack.pop();
+			if (current.failed) unloadable.add(referenceId);
+			for (const reference of current.references) if (reference !== referenceId) imported.add(reference);
+			for (const child of current.children) if (leads.has(child) && !visited.has(child)) {
+				visited.add(child);
+				stack.push(child);
+			}
+		}
+	}
+	const slotOwners = /* @__PURE__ */ new Map();
+	const marks = [];
+	for (const [referenceId, root] of rootSlots) if (!unloadable.has(referenceId)) marks.push([root, referenceId]);
+	while (marks.length > 0) {
+		const [marked, owner] = marks.pop();
+		const current = slotOwners.get(marked);
+		const next = current === void 0 || current === owner ? owner : null;
+		if (next === current) continue;
+		slotOwners.set(marked, next);
+		for (const child of marked.children) marks.push([child, next]);
+	}
+	const moduleOwners = /* @__PURE__ */ new Map();
+	for (const [marked, owner] of slotOwners) {
+		const current = moduleOwners.get(marked.id);
+		moduleOwners.set(marked.id, current === void 0 || current === owner ? owner : null);
+	}
+	const exclusiveBytes = /* @__PURE__ */ new Map();
+	for (const [moduleId, owner] of moduleOwners) {
+		if (owner === null) continue;
+		exclusiveBytes.set(owner, (exclusiveBytes.get(owner) ?? 0) + (moduleBytes.get(moduleId) ?? 0));
+	}
+	const costs = /* @__PURE__ */ new Map();
+	for (const referenceId of options.references.keys()) {
+		let cost = 0;
+		const visited = /* @__PURE__ */ new Set();
+		const queue = [referenceId];
+		for (let index = 0; index < queue.length && cost !== null; index++) {
+			const current = queue[index];
+			if (visited.has(current)) continue;
+			visited.add(current);
+			cost = unloadable.has(current) ? null : cost + (exclusiveBytes.get(current) ?? 0);
+			for (const importedReference of importedReferences.get(current) ?? []) queue.push(importedReference);
+		}
+		costs.set(referenceId, cost);
+	}
+	return costs;
+}
+/**
+* Group client references that share a route signature. References without a
+* signature, references whose cost is unknown or above `maxCostBytes`, and
+* signatures with a single member stay ungrouped. Group keys derive from the
+* members' `referenceKeys`, so a group keeps its chunk name when routes change
+* but its members do not.
+*/
+function planClientReferenceGroups(options) {
+	const membersBySignature = /* @__PURE__ */ new Map();
+	for (const [referenceId, signature] of options.signatures) {
+		if (!options.referenceIds.has(referenceId)) continue;
+		const cost = options.costs.get(referenceId);
+		if (cost == null || cost > options.maxCostBytes) continue;
+		let members = membersBySignature.get(signature);
+		if (!members) {
+			members = [];
+			membersBySignature.set(signature, members);
+		}
+		members.push(referenceId);
+	}
+	const groups = [];
+	const usedKeys = /* @__PURE__ */ new Set();
+	for (const signature of [...membersBySignature.keys()].sort()) {
+		const members = membersBySignature.get(signature);
+		if (members.length < 2) continue;
+		const memberKeys = members.map((referenceId) => options.referenceKeys.get(referenceId));
+		const hash = createHash("sha256").update(memberKeys.sort().join("\0")).digest("hex");
+		let length = 10;
+		while (usedKeys.has(hash.slice(0, length))) length++;
+		const key = hash.slice(0, length);
+		usedKeys.add(key);
+		groups.push({
+			key,
+			referenceIds: members
+		});
+	}
+	return groups;
+}
+//#endregion
+export { CLIENT_REFERENCE_GROUP_MAX_COST_BYTES, collectClientReferencePreloadPlan, collectClientReferenceRouteSignatures, measureClientReferenceGroupCosts, planClientReferenceGroups, readClientModuleBindings };

package/dist/build/module-dependency-cache.d.ts

@@ -1,3 +1,34 @@
 //#region src/build/module-dependency-cache.d.ts
 export declare function createModuleDependencyCache<T>(collect: (moduleId: string) => Promise<T>): (moduleId: string) => Promise<T>;
+export type ModuleDependencyEntry<T> = {
+  dependencies: T[];
+  /** Files the module's imports resolved to, without Vite queries. */
+  resolvedFiles: string[];
+  /**
+   * False when an import did not resolve. Vite only caches modules that
+   * transformed, so it retries those imports on every request. So does the store.
+   */
+  cacheable: boolean;
+};
+type FileEvent = {
+  files: readonly string[];
+  event: "create" | "update" | "delete";
+};
+/**
+ * Dependency lists of source modules, kept across loads of a dev virtual
+ * module. An entry is dropped by the file events that make Vite transform the
+ * module again: an edit, creation or deletion of the module's own file, and
+ * deletion of a file one of its imports resolved to.
+ */
+export declare class ModuleDependencyStore<T> {
+  private readonly entries;
+  private readonly pendingReads;
+  read(moduleId: string, collect: (moduleId: string) => Promise<ModuleDependencyEntry<T>>): Promise<T[]>;
+  /**
+   * `files` holds every spelling of one file, such as its symlinked and real
+   * path. Returns whether an entry was dropped.
+   */
+  invalidate(files: readonly string[], event: FileEvent["event"]): boolean;
+  clear(): void;
+}
 //#endregion

package/dist/build/module-dependency-cache.js

@@ -1,3 +1,4 @@
+import { stripViteModuleQuery } from "../utils/path.js";
 //#region src/build/module-dependency-cache.ts
 function createModuleDependencyCache(collect) {
 	const cache = /* @__PURE__ */ new Map();
@@ -9,5 +10,54 @@ function createModuleDependencyCache(collect) {
 		return pending;
 	};
 }
+function isOutdatedBy(moduleId, entry, { files, event }) {
+	return files.includes(stripViteModuleQuery(moduleId)) || event === "delete" && entry.resolvedFiles.some((file) => files.includes(file));
+}
+/**
+* Dependency lists of source modules, kept across loads of a dev virtual
+* module. An entry is dropped by the file events that make Vite transform the
+* module again: an edit, creation or deletion of the module's own file, and
+* deletion of a file one of its imports resolved to.
+*/
+var ModuleDependencyStore = class {
+	entries = /* @__PURE__ */ new Map();
+	pendingReads = /* @__PURE__ */ new Set();
+	async read(moduleId, collect) {
+		const cached = this.entries.get(moduleId);
+		if (cached) return cached.dependencies;
+		const pending = { events: [] };
+		this.pendingReads.add(pending);
+		let entry;
+		try {
+			entry = await collect(moduleId);
+		} finally {
+			this.pendingReads.delete(pending);
+		}
+		if (entry.cacheable && pending.events && !pending.events.some((event) => isOutdatedBy(moduleId, entry, event))) this.entries.set(moduleId, entry);
+		return entry.dependencies;
+	}
+	/**
+	* `files` holds every spelling of one file, such as its symlinked and real
+	* path. Returns whether an entry was dropped.
+	*/
+	invalidate(files, event) {
+		const fileEvent = {
+			files,
+			event
+		};
+		for (const pending of this.pendingReads) pending.events?.push(fileEvent);
+		let dropped = false;
+		for (const [moduleId, entry] of this.entries) {
+			if (!isOutdatedBy(moduleId, entry, fileEvent)) continue;
+			this.entries.delete(moduleId);
+			dropped = true;
+		}
+		return dropped;
+	}
+	clear() {
+		for (const pending of this.pendingReads) pending.events = null;
+		this.entries.clear();
+	}
+};
 //#endregion
-export { createModuleDependencyCache };
+export { ModuleDependencyStore, createModuleDependencyCache };

package/dist/build/next-client-runtime-manifests.d.ts

@@ -1,3 +1,4 @@
+import { ValidFileMatcher } from "../routing/file-matcher.js";
 import { ResolvedNextConfig } from "../config/next-config.js";
 //#region src/build/next-client-runtime-manifests.d.ts
 type EmitNextClientRuntimeManifestsOptions = {
@@ -5,8 +6,16 @@ type EmitNextClientRuntimeManifestsOptions = {
   assetsSubdir: string;
   buildId: string;
   rewrites: ResolvedNextConfig["rewrites"];
+  /** Next.js-format paths of every `pages/` page and API route, e.g. "/posts/[id]". */
+  pages: readonly string[];
 };
-export declare function buildNextClientBuildManifestContent(rewrites: ResolvedNextConfig["rewrites"]): string;
+/**
+ * Next.js page key for a `pages/` file, e.g. "/posts/[id]". Keeps the raw file
+ * name (no decoding), so `pages/caf%C3%A9.js` stays "/caf%C3%A9".
+ * Ported from Next.js: packages/next/src/build/route-discovery.ts (`getPageFromPath`).
+ */
+export declare function getPagesManifestPage(pagesDir: string, filePath: string, matcher: Pick<ValidFileMatcher, "stripExtension">): string;
+export declare function buildNextClientBuildManifestContent(rewrites: ResolvedNextConfig["rewrites"], pages: readonly string[]): string;
 export declare function buildNextClientSsgManifestContent(): string;
 export declare function emitNextClientRuntimeManifests(options: EmitNextClientRuntimeManifestsOptions): void;
 //#endregion

package/dist/build/next-client-runtime-manifests.js

@@ -1,11 +1,26 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { getSortedRoutes } from "../routing/route-validation.js";
 import { toClientRewrites } from "../client/client-rewrites.js";
 import fs from "node:fs";
 //#region src/build/next-client-runtime-manifests.ts
-function buildNextClientBuildManifestContent(rewrites) {
+/**
+* Next.js page key for a `pages/` file, e.g. "/posts/[id]". Keeps the raw file
+* name (no decoding), so `pages/caf%C3%A9.js` stays "/caf%C3%A9".
+* Ported from Next.js: packages/next/src/build/route-discovery.ts (`getPageFromPath`).
+*/
+function getPagesManifestPage(pagesDir, filePath, matcher) {
+	const page = `/${matcher.stripExtension(path.relative(pagesDir, filePath))}`;
+	const withoutIndex = page.endsWith("/index") ? page.slice(0, -6) : page;
+	return withoutIndex === "" ? "/" : withoutIndex;
+}
+function buildNextClientBuildManifestContent(rewrites, pages) {
 	const manifest = {
 		__rewrites: toClientRewrites(rewrites),
-		sortedPages: []
+		sortedPages: getSortedRoutes([
+			...pages,
+			"/_app",
+			"/_error"
+		])
 	};
 	return `self.__BUILD_MANIFEST = ${JSON.stringify(manifest)};self.__BUILD_MANIFEST_CB && self.__BUILD_MANIFEST_CB()`;
 }
@@ -15,8 +30,8 @@ function buildNextClientSsgManifestContent() {
 function emitNextClientRuntimeManifests(options) {
 	const manifestDir = path.join(options.clientDir, options.assetsSubdir, options.buildId);
 	fs.mkdirSync(manifestDir, { recursive: true });
-	fs.writeFileSync(path.join(manifestDir, "_buildManifest.js"), buildNextClientBuildManifestContent(options.rewrites), "utf-8");
+	fs.writeFileSync(path.join(manifestDir, "_buildManifest.js"), buildNextClientBuildManifestContent(options.rewrites, options.pages), "utf-8");
 	fs.writeFileSync(path.join(manifestDir, "_ssgManifest.js"), buildNextClientSsgManifestContent(), "utf-8");
 }
 //#endregion
-export { buildNextClientBuildManifestContent, buildNextClientSsgManifestContent, emitNextClientRuntimeManifests };
+export { buildNextClientBuildManifestContent, buildNextClientSsgManifestContent, emitNextClientRuntimeManifests, getPagesManifestPage };