vinext 1.3.0 → 1.4.0

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

@@ -9,6 +9,7 @@ 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)(?:\?.*)?$/;
+const NODE_MODULES_SOURCE_MODULE_ID_RE = /[\\/]node_modules[\\/].*\.(?:tsx?|jsx?|mjs)(?:\?.*)?$/;
 const RESOLVED_VIRTUAL_MODULE_ID_RE = new RegExp(`^${String.fromCharCode(0)}`);
 const USE_CACHE_DIRECTIVE = /^use cache(?:: ([^\s].*))?$/;
 const USE_CACHE_DIRECTIVE_CANDIDATE = /^use cache.*$/;
@@ -40,6 +41,30 @@ function getArgumentCount(meta) {
 	if (node?.type !== "FunctionDeclaration" && node?.type !== "FunctionExpression" && node?.type !== "ArrowFunctionExpression") return;
 	return node.params.at(-1)?.type === "RestElement" ? void 0 : node.params.length;
 }
+/**
+* `export { fn }` carries no value node, so find the exported binding's
+* `const` initializer, which records the function's parameters. Other
+* bindings, function declarations included, can be reassigned before the
+* module finishes evaluating, so their arity stays unknown.
+*/
+function getSpecifierExportValueNodes(ast) {
+	const locals = /* @__PURE__ */ new Map();
+	for (const statement of ast.body) {
+		const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+		if (declaration?.type !== "VariableDeclaration" || declaration.kind !== "const") continue;
+		for (const declarator of declaration.declarations) if (declarator.id.type === "Identifier" && declarator.init) locals.set(declarator.id.name, declarator.init);
+	}
+	const values = /* @__PURE__ */ new Map();
+	for (const statement of ast.body) {
+		if (statement.type !== "ExportNamedDeclaration" || statement.declaration || statement.source) continue;
+		for (const specifier of statement.specifiers) {
+			if (specifier.local.type !== "Identifier" || specifier.exported.type !== "Identifier") continue;
+			const value = locals.get(specifier.local.name);
+			if (value) values.set(specifier.exported.name, value);
+		}
+	}
+	return values;
+}
 function acceptsSecondArgument(meta) {
 	const node = meta.valueNode;
 	if (node?.type !== "FunctionDeclaration" && node?.type !== "FunctionExpression" && node?.type !== "ArrowFunctionExpression") return true;
@@ -150,7 +175,103 @@ async function createUseCacheCallablePlugin(options) {
 			secureExportName
 		};
 	}
-	return {
+	async function transformDirectives(code, id) {
+		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, secret, code, id);
+		if (!(this.environment.name === "rsc")) {
+			if (useServerBoundary) {
+				manager.serverReferences.deleteClaim(PLUGIN_NAME, id);
+				return;
+			}
+			const result = transformBrowserModule(transforms, code, ast, id, moduleDirective, {
+				environmentName: this.environment.name,
+				reference,
+				secureExportName,
+				createReference: (referenceId, name) => `$$ReactClient.createServerReference(${JSON.stringify(referenceId)},$$ReactClient.callServer,undefined,${this.environment.mode === "dev" ? "$$ReactClient.findSourceMapURL" : "undefined"},${JSON.stringify(name)})`
+			});
+			if (!result) {
+				manager.serverReferences.deleteClaim(PLUGIN_NAME, id);
+				return;
+			}
+			manager.serverReferences.replaceClaim(PLUGIN_NAME, id, {
+				...reference,
+				exportNames: result.referenceNames
+			});
+			const runtimeEnvironment = this.environment.name === "client" ? "browser" : "ssr";
+			result.output.prepend(`import * as $$ReactClient from "@vitejs/plugin-rsc/react/${runtimeEnvironment}";\n`);
+			return magicStringTransformResult(result.output, {
+				hires: "boundary",
+				source: id
+			});
+		}
+		const secureExports = /* @__PURE__ */ new Set();
+		const wrap = (value, name, directiveMatch, meta) => {
+			const variant = directiveMatch[1] ?? "";
+			const secureName = secureExportName(name);
+			secureExports.add(secureName);
+			const wrapperOptions = {
+				...getCacheWrapperOptions(meta),
+				serverReferenceId: `${reference.referenceKey}#${secureName}`
+			};
+			return `$$cacheRuntime.registerCachedFunction(${value}, ${JSON.stringify(`${id}:${name}`)}, ${JSON.stringify(variant)}, ${JSON.stringify(wrapperOptions)})`;
+		};
+		let needsReactServer = false;
+		const runtime = (value, name, directiveMatch, meta) => {
+			const cached = wrap(value, name, directiveMatch, meta);
+			const secureName = secureExportName(name);
+			needsReactServer = true;
+			return `(${secureName} = $$VinextReactServer.registerServerReference(${cached}, ${JSON.stringify(reference.referenceKey)}, ${JSON.stringify(secureName)}))`;
+		};
+		const specifierValueNodes = moduleDirective ? getSpecifierExportValueNodes(ast) : void 0;
+		const result = moduleDirective ? transforms.transformWrapExport(code, ast, {
+			filter: (name, meta) => {
+				if (hasFunctionDirective(meta, "use server") || !shouldTransformModuleExport(name, id, meta)) return false;
+				validateModuleExport(transforms, meta);
+				return true;
+			},
+			runtime: (value, name, meta) => runtime(value, name, matchUseCacheDirective(moduleDirective), {
+				...meta,
+				valueNode: meta.valueNode ?? specifierValueNodes?.get(name)
+			})
+		}) : transforms.transformHoistInlineDirective(code, ast, {
+			directive: USE_CACHE_DIRECTIVE_CANDIDATE,
+			rejectNonAsyncFunction: true,
+			hoistRuntime: true,
+			noExport: true,
+			runtime: (value, name, meta) => runtime(value, name, matchUseCacheDirective(meta.directiveMatch[0]), meta),
+			encode: (value, name) => {
+				if (name === void 0) throw new Error("vinext: inline \"use cache\" functions require @vitejs/plugin-rsc 0.5.37 or newer.");
+				const referenceId = `${reference.referenceKey}#${secureExportName(name)}`;
+				return `$$cacheRuntime.encryptCacheCaptures(${JSON.stringify(referenceId)}, ${value})`;
+			},
+			decode: (value) => value
+		});
+		if (!result.output.hasChanged()) {
+			manager.serverReferences.deleteClaim(PLUGIN_NAME, id);
+			return;
+		}
+		manager.serverReferences.replaceClaim(PLUGIN_NAME, id, {
+			...reference,
+			exportNames: [...secureExports]
+		});
+		const importPosition = ast.body.find((node) => !("directive" in node))?.start ?? code.length;
+		result.output.prependLeft(importPosition, [
+			`import * as $$cacheRuntime from ${JSON.stringify(options.cacheRuntime)};`,
+			needsReactServer && `import * as $$VinextReactServer from "@vitejs/plugin-rsc/react/rsc/server";`,
+			secureExports.size > 0 && `let ${[...secureExports].join(",")};`
+		].filter(Boolean).join("\n") + "\n");
+		if (secureExports.size > 0) result.output.append(`\nexport { ${[...secureExports].join(",")} };\n`);
+		return magicStringTransformResult(result.output, {
+			hires: "boundary",
+			source: id
+		});
+	}
+	return [{
 		name: PLUGIN_NAME,
 		api: { async transformWorkerModule(code, id, createReference) {
 			if (!code.includes("use cache")) return;
@@ -192,100 +313,21 @@ async function createUseCacheCallablePlugin(options) {
 				include: SOURCE_MODULE_ID_RE,
 				exclude: [NODE_MODULES_PATH_RE, RESOLVED_VIRTUAL_MODULE_ID_RE]
 			} },
-			async handler(code, id) {
-				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, secret, code, id);
-				if (!(this.environment.name === "rsc")) {
-					if (useServerBoundary) {
-						manager.serverReferences.deleteClaim(PLUGIN_NAME, id);
-						return;
-					}
-					const result = transformBrowserModule(transforms, code, ast, id, moduleDirective, {
-						environmentName: this.environment.name,
-						reference,
-						secureExportName,
-						createReference: (referenceId, name) => `$$ReactClient.createServerReference(${JSON.stringify(referenceId)},$$ReactClient.callServer,undefined,${this.environment.mode === "dev" ? "$$ReactClient.findSourceMapURL" : "undefined"},${JSON.stringify(name)})`
-					});
-					if (!result) {
-						manager.serverReferences.deleteClaim(PLUGIN_NAME, id);
-						return;
-					}
-					manager.serverReferences.replaceClaim(PLUGIN_NAME, id, {
-						...reference,
-						exportNames: result.referenceNames
-					});
-					const runtimeEnvironment = this.environment.name === "client" ? "browser" : "ssr";
-					result.output.prepend(`import * as $$ReactClient from "@vitejs/plugin-rsc/react/${runtimeEnvironment}";\n`);
-					return magicStringTransformResult(result.output, {
-						hires: "boundary",
-						source: id
-					});
-				}
-				const secureExports = /* @__PURE__ */ new Set();
-				const wrap = (value, name, directiveMatch, meta) => {
-					const variant = directiveMatch[1] ?? "";
-					const secureName = secureExportName(name);
-					secureExports.add(secureName);
-					const wrapperOptions = {
-						...getCacheWrapperOptions(meta),
-						serverReferenceId: `${reference.referenceKey}#${secureName}`
-					};
-					return `$$cacheRuntime.registerCachedFunction(${value}, ${JSON.stringify(`${id}:${name}`)}, ${JSON.stringify(variant)}, ${JSON.stringify(wrapperOptions)})`;
-				};
-				let needsReactServer = false;
-				const runtime = (value, name, directiveMatch, meta) => {
-					const cached = wrap(value, name, directiveMatch, meta);
-					const secureName = secureExportName(name);
-					needsReactServer = true;
-					return `(${secureName} = $$VinextReactServer.registerServerReference(${cached}, ${JSON.stringify(reference.referenceKey)}, ${JSON.stringify(secureName)}))`;
-				};
-				const result = moduleDirective ? transforms.transformWrapExport(code, ast, {
-					filter: (name, meta) => {
-						if (hasFunctionDirective(meta, "use server") || !shouldTransformModuleExport(name, id, meta)) return false;
-						validateModuleExport(transforms, meta);
-						return true;
-					},
-					runtime: (value, name, meta) => runtime(value, name, matchUseCacheDirective(moduleDirective), meta)
-				}) : transforms.transformHoistInlineDirective(code, ast, {
-					directive: USE_CACHE_DIRECTIVE_CANDIDATE,
-					rejectNonAsyncFunction: true,
-					hoistRuntime: true,
-					noExport: true,
-					runtime: (value, name, meta) => runtime(value, name, matchUseCacheDirective(meta.directiveMatch[0]), meta),
-					encode: (value, name) => {
-						if (name === void 0) throw new Error("vinext: inline \"use cache\" functions require @vitejs/plugin-rsc 0.5.37 or newer.");
-						const referenceId = `${reference.referenceKey}#${secureExportName(name)}`;
-						return `$$cacheRuntime.encryptCacheCaptures(${JSON.stringify(referenceId)}, ${value})`;
-					},
-					decode: (value) => value
-				});
-				if (!result.output.hasChanged()) {
-					manager.serverReferences.deleteClaim(PLUGIN_NAME, id);
-					return;
-				}
-				manager.serverReferences.replaceClaim(PLUGIN_NAME, id, {
-					...reference,
-					exportNames: [...secureExports]
-				});
-				const importPosition = ast.body.find((node) => !("directive" in node))?.start ?? code.length;
-				result.output.prependLeft(importPosition, [
-					`import * as $$cacheRuntime from ${JSON.stringify(options.cacheRuntime)};`,
-					needsReactServer && `import * as $$VinextReactServer from "@vitejs/plugin-rsc/react/rsc/server";`,
-					secureExports.size > 0 && `let ${[...secureExports].join(",")};`
-				].filter(Boolean).join("\n") + "\n");
-				if (secureExports.size > 0) result.output.append(`\nexport { ${[...secureExports].join(",")} };\n`);
-				return magicStringTransformResult(result.output, {
-					hires: "boundary",
-					source: id
-				});
-			}
+			handler: transformDirectives
 		}
-	};
+	}, {
+		name: `${PLUGIN_NAME}:node-modules`,
+		transform: {
+			filter: {
+				id: {
+					include: NODE_MODULES_SOURCE_MODULE_ID_RE,
+					exclude: RESOLVED_VIRTUAL_MODULE_ID_RE
+				},
+				code: "use cache"
+			},
+			handler: transformDirectives
+		}
+	}];
 }
 //#endregion
 export { PLUGIN_NAME as USE_CACHE_PLUGIN_NAME, createUseCacheCallablePlugin };

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]").
@@ -371,6 +411,12 @@ export declare function buildAppRouteGraph(appDir: string, matcher: ValidFileMat
   routes: AppRouteGraphRoute[];
   routeManifest: RouteManifest;
 }>;
+/**
+ * The tree position of a slot's active page relative to the slot root, in the
+ * coordinates of configLayoutTreePositions. Route groups count, unlike in
+ * `routeSegments`, since each is its own loader-tree segment.
+ */
+export declare function findSlotPageTreePosition(slot: Pick<ParallelSlot, "ownerDir" | "pagePath">): number | null;
 export declare function computeRootParamNames(routeSegments: readonly string[], layoutTreePositions: readonly number[]): string[];
 export declare function patternsStructurallyEquivalent(a: readonly string[], b: readonly string[]): boolean;
 /**