vinext 1.2.1 → 1.3.0

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

@@ -1,46 +1,364 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.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 fs from "node:fs";
+import { isCSSRequest } from "vite";
 //#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-`;
+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-/;
+/**
+* Whether the cost estimate loads a module. Rolldown keeps externals and
+* unresolved `require()`s in `importedIds` under their specifier (a bare name
+* or URL), and never settles a load of one, so only files and `\0` virtual
+* modules are measured.
+*/
+function isMeasured(id) {
+	return id.startsWith("\0") || path.isAbsolute(id);
+}
+/**
+* Whether `id` shares the package `sideEffects` flag of `owner`: it is in the
+* same package, and the package's `sideEffects` field is not a list of files.
+* `uniformSideEffects` caches that last check per package.json path.
+*/
+function isInPackage(id, owner, uniformSideEffects) {
+	const packageJsonPath = owner.packageJsonPath;
+	if (!packageJsonPath) return false;
+	const relative = path.relative(path.dirname(packageJsonPath), id);
+	if (relative.startsWith("..") || relative.split("/").includes("node_modules")) return false;
+	let uniform = uniformSideEffects.get(packageJsonPath);
+	if (uniform === void 0) {
+		try {
+			const { sideEffects } = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+			uniform = sideEffects === void 0 || typeof sideEffects === "boolean";
+		} catch {
+			uniform = false;
+		}
+		uniformSideEffects.set(packageJsonPath, uniform);
+	}
+	return uniform;
+}
 function withResolvedIdProxy(resolvedId) {
 	return resolvedId.startsWith("\0") ? RESOLVED_ID_PROXY_PREFIX + encodeURIComponent(resolvedId) : resolvedId;
 }
-function generateClientReferenceObject(meta) {
-	const exports = meta.renderedExports.slice().sort().map((name) => `      get ${JSON.stringify(name)}() { return m[${JSON.stringify(name)}]; },`).join("\n");
+function sortedRenderedExports(meta) {
+	return meta.renderedExports.slice().sort();
+}
+function groupExportName(slotIndex, exportIndex) {
+	return `r${slotIndex}_${exportIndex}`;
+}
+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 generateDirectClientReferenceLoaders(metas) {
+function generateClientReferenceLoaders(metas, slots = /* @__PURE__ */ new Map()) {
 	return `export default {\n${metas.slice().sort((a, b) => a.referenceKey.localeCompare(b.referenceKey)).map((meta) => {
-		const importId = withResolvedIdProxy(meta.importId);
+		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(importId)});`,
-			`    return ${generateClientReferenceObject(meta)};`,
+			`    const m = await import(${JSON.stringify(source)});`,
+			`    return ${generateClientReferenceObject(meta, slot)};`,
 			`  },`
 		].join("\n");
 	}).join("\n")}\n};\n`;
 }
-function createRscClientReferenceLoadersPlugin() {
+/**
+* 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.
+*/
+function generateClientReferenceGroupModule(metas) {
+	return `${metas.map((meta, slotIndex) => {
+		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`;
+}
+/**
+* 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`.
+*/
+function generateRouteClientReferencesExport(plan, metaEntries) {
+	if (!plan) return "export const routeClientReferences = null;\n";
+	const metaById = new Map(metaEntries);
+	const references = [];
+	const indices = /* @__PURE__ */ new Map();
+	const toIndices = (referenceIds) => referenceIds.flatMap((referenceId) => {
+		const meta = metaById.get(referenceId);
+		if (!meta) return [];
+		let index = indices.get(referenceId);
+		if (index === void 0) {
+			index = references.length;
+			indices.set(referenceId, index);
+			references.push(meta.referenceKey);
+		}
+		return [index];
+	});
+	const manifest = {
+		references,
+		always: toIndices([...plan.preloads.always, ...metaEntries.map(([referenceId]) => referenceId).filter((referenceId) => !plan.referenceIds.has(referenceId))]),
+		files: plan.preloads.files.map(toIndices),
+		routes: Object.fromEntries(plan.preloads.routes),
+		routeless: plan.preloads.routeless
+	};
+	return `export const routeClientReferences = ${JSON.stringify(manifest)};\n`;
+}
+/**
+* Replaces @vitejs/plugin-rsc's client-reference facades with per-reference
+* loaders. With `routes`, the SSR build also exports the client references
+* each App Router route preloads. With `grouping`, production client builds
+* additionally load references that the same App Router routes reach through
+* one shared route group module (see build/client-reference-groups.ts), so a
+* page fetches one chunk per route group instead of one per `"use client"`
+* module.
+*/
+function createRscClientReferenceLoadersPlugin(options = {}) {
+	const { routes: routeOptions } = options;
+	const grouping = routeOptions && options.grouping;
 	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();
 	return {
 		name: "vinext:rsc-client-reference-loaders",
 		enforce: "post",
 		configResolved(config) {
+			root = config.root;
 			rscApi = config.plugins.find((plugin) => plugin.name === "rsc:minimal")?.api;
 		},
-		transform(_code, id) {
-			if (id !== CLIENT_REFERENCES_ID) return null;
+		outputOptions: {
+			order: "post",
+			handler(output) {
+				if (this.environment?.name !== "client") return;
+				groupingEnabled = !!grouping && !hasUserClientChunkGroups(output, grouping.ownClientChunkGroups);
+			}
+		},
+		buildStart() {
+			if (this.environment.name === "rsc") {
+				routeSignatures = /* @__PURE__ */ new Map();
+				preloadPlan = null;
+			}
+			if (this.environment.name === "client") groupModules.clear();
+		},
+		buildEnd(error) {
+			if (error || !routeOptions) return;
+			if (this.environment.name !== "rsc" || this.environment.mode !== "build") return;
 			const manager = rscApi?.manager;
-			if (!manager || manager.isScanBuild) return null;
-			const metaEntries = Object.entries(manager.clientReferenceMetaMap).filter(([, meta]) => meta.serverChunk);
-			const metas = metaEntries.map(([, meta]) => meta);
-			if (metas.length === 0) return null;
-			for (const [id, meta] of metaEntries) meta.groupChunkId = id;
-			return {
-				code: generateDirectClientReferenceLoaders(metas),
-				map: null
+			const routes = routeOptions.getRoutes();
+			if (!manager || manager.isScanBuild || !routes) return;
+			const clientReferenceIds = new Set(Object.keys(manager.clientReferenceMetaMap));
+			const getModuleInfo = (id) => this.getModuleInfo(id);
+			preloadPlan = {
+				referenceIds: clientReferenceIds,
+				preloads: collectClientReferencePreloadPlan({
+					alwaysRoots: routeOptions.getAlwaysRenderedFiles(),
+					canonicalizeModuleId: routeOptions.canonicalizeModuleId,
+					clientReferenceIds,
+					entryIds: [...this.getModuleIds()].filter((id) => this.getModuleInfo(id)?.isEntry),
+					getModuleInfo,
+					routelessFiles: routeOptions.getRoutelessFiles(),
+					routes
+				})
 			};
+			if (!grouping) return;
+			routeSignatures = collectClientReferenceRouteSignatures({
+				canonicalizeModuleId: routeOptions.canonicalizeModuleId,
+				clientReferenceIds,
+				getModuleInfo,
+				root,
+				routes,
+				sharedRoots: routeOptions.getSharedRoots()
+			});
+		},
+		resolveId: {
+			filter: { id: CLIENT_REFERENCE_GROUP_RE },
+			handler(source) {
+				return groupModules.has(`\0${source}`) ? `\0${source}` : null;
+			}
+		},
+		load: {
+			filter: { id: RESOLVED_CLIENT_REFERENCE_GROUP_RE },
+			handler(id) {
+				return groupModules.get(id) ?? null;
+			}
+		},
+		transform: {
+			filter: { id: CLIENT_REFERENCES_ID_RE },
+			async handler(code) {
+				const manager = rscApi?.manager;
+				if (!manager || manager.isScanBuild) return null;
+				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) : "";
+				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 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({
+					referenceIds,
+					referenceKeys,
+					signatures: routeSignatures,
+					costs: new Map([...referenceIds].map((referenceId) => [referenceId, 0])),
+					maxCostBytes: 0
+				}).length > 0) {
+					const references = /* @__PURE__ */ new Map();
+					const resolutions = /* @__PURE__ */ new Map();
+					const packages = /* @__PURE__ */ new Map();
+					const externalIds = /* @__PURE__ */ new Set();
+					const uniformSideEffects = /* @__PURE__ */ new Map();
+					const resolveCache = /* @__PURE__ */ new Map();
+					const addResolution = (resolved) => {
+						resolutions.set(resolved.id, resolved);
+						packages.set(resolved.id, resolved);
+					};
+					await Promise.all(metaEntries.map(async ([referenceId, meta]) => {
+						if (meta.importId.startsWith("\0")) {
+							references.set(referenceId, meta.importId);
+							return;
+						}
+						const resolved = await this.resolve(meta.importId);
+						if (!resolved || resolved.external) return;
+						references.set(referenceId, resolved.id);
+						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);
+						if (excluded === void 0) {
+							excluded = !isMeasured(moduleId) || moduleId === CLIENT_REFERENCES_ID || moduleId.startsWith(RESOLVED_CLIENT_REFERENCE_GROUP_PREFIX) || isCSSRequest(moduleId) || grouping.isAlwaysLoadedClientModule(moduleId);
+							excludedById.set(moduleId, excluded);
+						}
+						return excluded;
+					};
+					const costs = await measureClientReferenceGroupCosts({
+						references,
+						loadModule: async (moduleId) => {
+							if (external && !resolutions.has(moduleId) && !moduleId.startsWith("\0")) {
+								const resolved = await this.resolve(moduleId);
+								if (!resolved || resolved.external) return {
+									code: "",
+									importedIds: []
+								};
+							}
+							const info = await this.load(resolutions.get(moduleId) ?? { id: moduleId });
+							moduleInfos.set(moduleId, info);
+							const { code, importedIds } = info;
+							if (code === null) return {
+								code,
+								importedIds
+							};
+							const importedIdSet = new Set(importedIds);
+							const owner = packages.get(moduleId);
+							return {
+								code,
+								importedIds,
+								bindings: await readClientModuleBindings({
+									code,
+									importedIds,
+									resolve: async (specifier) => {
+										if (owner && path.isAbsolute(moduleId) && (specifier.startsWith("./") || specifier.startsWith("../"))) {
+											const candidate = path.resolve(path.dirname(moduleId), specifier);
+											if (importedIdSet.has(candidate) && isInPackage(candidate, owner, uniformSideEffects)) {
+												packages.set(candidate, owner);
+												return candidate;
+											}
+										}
+										const key = `${path.dirname(moduleId)}\0${specifier}`;
+										let resolving = resolveCache.get(key);
+										if (!resolving) {
+											resolving = this.resolve(specifier, moduleId).then((resolved) => {
+												if (!resolved) return null;
+												if (resolved.external) externalIds.add(resolved.id);
+												else addResolution(resolved);
+												return resolved.id;
+											});
+											resolveCache.set(key, resolving);
+										}
+										return resolving;
+									}
+								})
+							};
+						},
+						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,
+						signatures: routeSignatures,
+						costs,
+						maxCostBytes: CLIENT_REFERENCE_GROUP_MAX_COST_BYTES
+					});
+					const metaById = new Map(metaEntries);
+					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) => {
+							meta.groupChunkId = resolvedGroupId;
+							slots.set(meta, {
+								groupId: resolvedGroupId.slice(1),
+								index
+							});
+						});
+					}
+				}
+				return {
+					code: generateClientReferenceLoaders(metas, slots) + routeClientReferencesExport,
+					map: null
+				};
+			}
+		}
+	};
+}
+/**
+* Exports a null preload plan from the client-references virtual module when
+* the app registers @vitejs/plugin-rsc itself (`rsc: false`), where vinext
+* doesn't add the loaders plugin above. The App Router SSR entry imports the
+* plan, and null makes it preload every client reference.
+*/
+function createRouteClientReferencesFallbackPlugin() {
+	return {
+		name: "vinext:route-client-references-fallback",
+		enforce: "post",
+		transform: {
+			filter: { id: CLIENT_REFERENCES_ID_RE },
+			handler(code) {
+				if (this.environment.config.consumer !== "server") return null;
+				return {
+					code: `${code}\n${generateRouteClientReferencesExport(null, [])}`,
+					map: null
+				};
+			}
 		}
 	};
 }
 //#endregion
-export { createRscClientReferenceLoadersPlugin };
+export { createRouteClientReferencesFallbackPlugin, createRscClientReferenceLoadersPlugin };

package/dist/plugins/use-cache-callable.d.ts

@@ -5,6 +5,11 @@ type Options = {
   projectRoot: string;
   cacheRuntime: string;
   allowMissingRsc?: boolean;
+  /**
+   * The Server Actions encryption key vinext loaded for an auto-registered
+   * @vitejs/plugin-rsc, so reference names derive from the same key.
+   */
+  getEncryptionKey?: () => string | undefined;
 };
 type BrowserTransformOptions = {
   environmentName: string;

package/dist/plugins/use-cache-callable.js

@@ -2,9 +2,10 @@ import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { parseProgramAsync } from "./ast-utils.js";
 import { magicStringTransformResult } from "./transform-result.js";
 import { NODE_MODULES_PATH_RE } from "../utils/path.js";
+import { getServerActionsKeyCacheFsDeny, loadOrGenerateServerActionsEncryptionKey } from "../build/server-actions-encryption-key.js";
 import { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
-import { createHmac, randomBytes } from "node:crypto";
+import { createHmac } from "node:crypto";
 //#region src/plugins/use-cache-callable.ts
 const PLUGIN_NAME = "vinext:server-function-directives";
 const SOURCE_MODULE_ID_RE = /\.(?:tsx?|jsx?|mjs)(?:\?.*)?$/;
@@ -114,21 +115,33 @@ function transformBrowserModule(transforms, code, ast, id, moduleDirective, opti
 		referenceNames: result.exportNames.map(referenceName)
 	};
 }
+/**
+* Ported from Next.js: crates/next-custom-transforms/src/transforms/server_actions.rs
+* salts server-reference IDs with the encryption key (`serverReferenceHashSalt`
+* in packages/next/src/build/webpack-config.ts), so rebuilds of identical
+* source emit identical client chunks. See
+* loadOrGenerateServerActionsEncryptionKey for where the key comes from. The
+* secret is derived under a label rather than used directly so the reference
+* names reveal nothing about the key.
+*/
+function createReferenceSecret(encryptionKey) {
+	return createHmac("sha256", encryptionKey).update("vinext use cache reference").digest();
+}
 async function createUseCacheCallablePlugin(options) {
 	const rscModulePath = resolvePluginRscModule(options.projectRoot, "@vitejs/plugin-rsc");
 	const transformsPath = resolvePluginRscModule(options.projectRoot, "@vitejs/plugin-rsc/transforms");
 	const rscModule = await import(pathToFileURL(rscModulePath).href);
 	const transforms = await import(pathToFileURL(transformsPath).href);
-	const referenceSecret = randomBytes(32);
+	let referenceSecret;
 	let manager;
-	async function analyzeModule(manager, code, id) {
+	async function analyzeModule(manager, secret, code, id) {
 		const ast = await parseProgramAsync(code);
 		const moduleDirective = findModuleUseCacheDirective(ast);
 		const useServerBoundary = transforms.hasDirective(ast.body, "use server");
 		if (moduleDirective && useServerBoundary) throw new Error(`A module cannot contain both ${JSON.stringify(moduleDirective)} and "use server" directives.`);
 		const reference = manager.serverReferences.resolve(id, "rsc");
 		const relativeImportId = manager.toRelativeId(reference.importId);
-		const secureExportName = (name) => `$$vinext_cache_${createHmac("sha256", referenceSecret).update(relativeImportId).update("\0").update(name).digest("hex")}`;
+		const secureExportName = (name) => `$$vinext_cache_${createHmac("sha256", secret).update(relativeImportId).update("\0").update(name).digest("hex")}`;
 		return {
 			ast,
 			moduleDirective,
@@ -141,11 +154,12 @@ async function createUseCacheCallablePlugin(options) {
 		name: PLUGIN_NAME,
 		api: { async transformWorkerModule(code, id, createReference) {
 			if (!code.includes("use cache")) return;
-			if (!manager) {
+			const secret = referenceSecret;
+			if (!manager || !secret) {
 				if (findModuleUseCacheDirective(await parseProgramAsync(code))) throw new Error("vinext: cannot compile a \"use cache\" module in a Web Worker without @vitejs/plugin-rsc.");
 				return;
 			}
-			const { ast, moduleDirective, useServerBoundary, reference, secureExportName } = await analyzeModule(manager, code, id);
+			const { ast, moduleDirective, useServerBoundary, reference, secureExportName } = await analyzeModule(manager, secret, code, id);
 			if (useServerBoundary) return;
 			return transformBrowserModule(transforms, code, ast, id, moduleDirective, {
 				environmentName: "worker",
@@ -154,10 +168,17 @@ async function createUseCacheCallablePlugin(options) {
 				createReference
 			})?.output;
 		} },
+		config(config) {
+			return { server: { fs: { deny: getServerActionsKeyCacheFsDeny(config.server?.fs?.deny) } } };
+		},
 		configResolved(config) {
 			const pluginApi = rscModule.getPluginApi(config);
 			const hasRscPlugin = config.plugins.some((plugin) => plugin.name === "rsc");
 			if (!pluginApi && options.allowMissingRsc && !hasRscPlugin) return;
+			referenceSecret ??= createReferenceSecret(options.getEncryptionKey?.() ?? loadOrGenerateServerActionsEncryptionKey({
+				root: config.root,
+				isBuild: config.command === "build"
+			}));
 			if (!pluginApi?.manager.serverReferences) throw new Error("vinext: callable use cache requires @vitejs/plugin-rsc 0.5.34 or newer.");
 			if (options.allowMissingRsc) {
 				const useCacheIndex = config.plugins.findIndex((plugin) => plugin.name === PLUGIN_NAME);
@@ -172,12 +193,13 @@ async function createUseCacheCallablePlugin(options) {
 				exclude: [NODE_MODULES_PATH_RE, RESOLVED_VIRTUAL_MODULE_ID_RE]
 			} },
 			async handler(code, id) {
-				if (!manager) return;
+				const secret = referenceSecret;
+				if (!manager || !secret) return;
 				if (!code.includes("use cache")) {
 					manager.serverReferences.deleteClaim(PLUGIN_NAME, id);
 					return;
 				}
-				const { ast, moduleDirective, useServerBoundary, reference, secureExportName } = await analyzeModule(manager, code, id);
+				const { ast, moduleDirective, useServerBoundary, reference, secureExportName } = await analyzeModule(manager, secret, code, id);
 				if (!(this.environment.name === "rsc")) {
 					if (useServerBoundary) {
 						manager.serverReferences.deleteClaim(PLUGIN_NAME, id);

package/dist/plugins/worker-image-imports.d.ts

@@ -1,5 +1,6 @@
 import { Plugin } from "vite";
 //#region src/plugins/worker-image-imports.d.ts
+export declare const WORKER_IMAGE_METADATA_PREFIX = "\0vinext-worker-image-meta:";
 /**
  * Preserve Next.js's StaticImageData shape for dynamic image imports inside
  * Vite worker graphs. Worker builds use their own plugin container, so the

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

@@ -128,4 +128,4 @@ function createWorkerImageImportsPlugin(options = {}) {
 	};
 }
 //#endregion
-export { createWorkerImageImportsPlugin };
+export { WORKER_IMAGE_METADATA_PREFIX, createWorkerImageImportsPlugin };

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

@@ -275,7 +275,7 @@ type RouteManifestRouteHandler = {
   routeId: string;
   pattern: string;
 };
-type RouteManifestLayout = {
+export type RouteManifestLayout = {
   id: string;
   treePath: string;
   patternParts: readonly string[];

package/dist/routing/browser-route-manifest.d.ts

@@ -0,0 +1,43 @@
+import { GraphVersion, RouteManifest, RouteManifestInterception, RouteManifestLayout, RouteManifestRootBoundary, RouteManifestRoute, RouteManifestSlotBinding } from "./app-route-graph.js";
+//#region src/routing/browser-route-manifest.d.ts
+export type BrowserRouteManifestRoute = Pick<RouteManifestRoute, "id" | "patternParts" | "isDynamic" | "paramNames" | "rootBoundaryId" | "pageId" | "layoutIds" | "slotIds">;
+type BrowserRouteManifestLayout = Pick<RouteManifestLayout, "id" | "patternParts" | "rootBoundaryId">;
+type BrowserRouteManifestSlotBinding = Pick<RouteManifestSlotBinding, "id" | "routeId" | "slotId" | "ownerLayoutId" | "state" | "routeSegments" | "slotPatternParts" | "slotParamNames">;
+export type BrowserRouteManifestInterception = Pick<RouteManifestInterception, "id" | "sourcePatternParts" | "targetPatternParts" | "slotId" | "ownerLayoutId" | "targetRouteId">;
+type BrowserRouteManifestRootBoundary = Pick<RouteManifestRootBoundary, "id" | "treePath">;
+/**
+ * The part of the RouteManifest the browser navigation runtime reads: the
+ * maps and fields the navigation planner, optimistic routing and interception
+ * context resolution use.
+ */
+export type BrowserRouteManifest = {
+  graphVersion: GraphVersion;
+  segmentGraph: {
+    routes: ReadonlyMap<string, BrowserRouteManifestRoute>;
+    layouts: ReadonlyMap<string, BrowserRouteManifestLayout>;
+    slotBindings: ReadonlyMap<string, BrowserRouteManifestSlotBinding>;
+    interceptions: ReadonlyMap<string, BrowserRouteManifestInterception>;
+    interceptionsBySlotId: ReadonlyMap<string, readonly BrowserRouteManifestInterception[]>;
+    rootBoundaries: ReadonlyMap<string, BrowserRouteManifestRootBoundary>;
+  };
+};
+/**
+ * JSON form of `BrowserRouteManifest`. Every map is keyed by its values' `id`,
+ * so maps travel as arrays of values in map order. A route omits `id` when it
+ * is `route:` plus its pattern, and `interceptionsBySlotId` lists interception
+ * ids instead of repeating the interceptions.
+ */
+export type BrowserRouteManifestWire = {
+  graphVersion: string;
+  routes: (Omit<BrowserRouteManifestRoute, "id"> & {
+    id?: string;
+  })[];
+  layouts: BrowserRouteManifestLayout[];
+  slotBindings: BrowserRouteManifestSlotBinding[];
+  interceptions: BrowserRouteManifestInterception[];
+  interceptionsBySlotId: [slotId: string, interceptionIds: string[]][];
+  rootBoundaries: BrowserRouteManifestRootBoundary[];
+};
+export declare function toBrowserRouteManifestWire(routeManifest: RouteManifest): BrowserRouteManifestWire;
+export declare function decodeBrowserRouteManifest(wire: BrowserRouteManifestWire): BrowserRouteManifest;
+//#endregion