vinext 1.2.1 → 1.3.0

package/dist/routing/browser-route-manifest.js

@@ -0,0 +1,195 @@
+import { buildOptimisticRouteTrie } from "./optimistic-route-trie.js";
+//#region src/routing/browser-route-manifest.ts
+function createRouteIdFromPatternParts(patternParts) {
+	return `route:/${patternParts.join("/")}`;
+}
+/**
+* Route matching precedence of one pattern part, lower wins: the URL ending
+* here, then a static, dynamic, catch-all and optional catch-all part.
+*/
+function patternPartRank(part) {
+	if (part === void 0) return 0;
+	if (!part.startsWith(":")) return 1;
+	if (part.endsWith("+")) return 3;
+	if (part.endsWith("*")) return 4;
+	return 2;
+}
+/**
+* Whether the router sends a URL pathname that both patterns match to the
+* route handler: it wins at the first part whose kind differs. Two patterns
+* that never differ would be the same route shape, which cannot hold both a
+* handler and a page.
+*/
+function routeHandlerOutranks(handler, rendered) {
+	for (let index = 0;; index++) {
+		const handlerRank = patternPartRank(handler[index]);
+		const renderedRank = patternPartRank(rendered[index]);
+		if (handlerRank !== renderedRank) return handlerRank < renderedRank;
+		if (handlerRank === 0 || handlerRank >= 3) return false;
+	}
+}
+/**
+* Whether the optimistic trie of the rendered routes predicts a rendered
+* route that the route handler outranks for some URL pathname the handler
+* pattern matches. The trie match descends one path and only backtracks to a
+* catch-all on its way up, so this follows that path for every URL: a param
+* segment either names one of the node's static children or none of them,
+* and a catch-all takes any number of such segments.
+*/
+function triePredictsOutrankedRoute(trie, handler) {
+	const lastPart = handler.at(-1);
+	const isCatchAll = lastPart?.startsWith(":") === true && /[+*]$/.test(lastPart);
+	const fixedLength = isCatchAll ? handler.length - 1 : handler.length;
+	const minLength = lastPart?.endsWith("+") === true ? handler.length : fixedLength;
+	const predict = (route) => route === null ? {
+		outranked: false,
+		unmatched: true
+	} : {
+		outranked: routeHandlerOutranks(handler, route.patternParts),
+		unmatched: false
+	};
+	const afterOtherSegment = (node, depth) => {
+		const dynamic = node.dynamicChild ? predictFrom(node.dynamicChild.node, depth) : {
+			outranked: false,
+			unmatched: true
+		};
+		if (!dynamic.unmatched) return dynamic;
+		const fallback = predict(node.catchAllChild?.route ?? node.optionalCatchAllChild?.route ?? null);
+		return {
+			outranked: dynamic.outranked || fallback.outranked,
+			unmatched: fallback.unmatched
+		};
+	};
+	const predictFrom = (node, depth) => {
+		const predictions = {
+			outranked: false,
+			unmatched: false
+		};
+		const add = (more) => {
+			predictions.outranked ||= more.outranked;
+			predictions.unmatched ||= more.unmatched;
+		};
+		if (isCatchAll ? depth >= minLength : depth === fixedLength) add(predict(node.route ?? node.optionalCatchAllChild?.route ?? null));
+		if (depth < fixedLength && !handler[depth].startsWith(":")) {
+			const child = node.staticChildren.get(handler[depth]);
+			add(child ? predictFrom(child, depth + 1) : afterOtherSegment(node, depth + 1));
+		} else if (depth < fixedLength || isCatchAll) {
+			for (const child of node.staticChildren.values()) add(predictFrom(child, depth + 1));
+			add(afterOtherSegment(node, depth + 1));
+		}
+		return predictions;
+	};
+	return predictFrom(trie, 0).outranked;
+}
+/**
+* The browser only needs a route handler where the optimistic route trie of
+* the rendered routes would predict a route the handler outranks: the matcher
+* must find the handler there instead of rendering that route's shell. Any
+* other handler URL matches no rendered route on the client, or one the
+* router prefers, and its non-Flight response already turns the navigation
+* into a document load, so shipping its path would only publish the app's
+* API surface (issue #3624).
+*/
+function selectBrowserRoutes(routes) {
+	const allRoutes = [...routes];
+	const renderedTrie = buildOptimisticRouteTrie(allRoutes.filter((route) => route.routeHandlerId === null));
+	return allRoutes.filter((route) => route.routeHandlerId === null || triePredictsOutrankedRoute(renderedTrie, route.patternParts));
+}
+/**
+* The graph records the browser receives: the shipped routes, the rendered
+* routes' slot bindings, and the layouts and root boundaries those and the
+* interceptions reach. A shipped route handler only stops an optimistic
+* match, and its non-Flight response never renders a tree, so it ships as a
+* bare pattern; its layouts, slots and root boundary would only name its
+* directories.
+*/
+function selectBrowserGraph(graph) {
+	const routes = selectBrowserRoutes(graph.routes.values()).map((route) => route.routeHandlerId === null ? route : {
+		...route,
+		layoutIds: [],
+		rootBoundaryId: null,
+		slotIds: []
+	});
+	const renderedRouteIds = new Set(routes.filter((route) => route.routeHandlerId === null).map((route) => route.id));
+	const slotBindings = [...graph.slotBindings.values()].filter((binding) => renderedRouteIds.has(binding.routeId));
+	const layoutIds = /* @__PURE__ */ new Set([
+		...routes.flatMap((route) => route.layoutIds),
+		...slotBindings.flatMap((binding) => binding.ownerLayoutId ?? []),
+		...[...graph.interceptions.values()].flatMap((interception) => interception.ownerLayoutId ?? [])
+	]);
+	const layouts = [...graph.layouts.values()].filter((layout) => layoutIds.has(layout.id));
+	const rootBoundaryIds = new Set([...routes, ...layouts].flatMap((record) => record.rootBoundaryId ?? []));
+	return {
+		routes,
+		layouts,
+		slotBindings,
+		rootBoundaries: [...graph.rootBoundaries.values()].filter((rootBoundary) => rootBoundaryIds.has(rootBoundary.id))
+	};
+}
+function toBrowserRouteManifestWire(routeManifest) {
+	const graph = routeManifest.segmentGraph;
+	const browserGraph = selectBrowserGraph(graph);
+	return {
+		graphVersion: routeManifest.graphVersion,
+		routes: browserGraph.routes.map((route) => ({
+			...route.id === createRouteIdFromPatternParts(route.patternParts) ? {} : { id: route.id },
+			patternParts: route.patternParts,
+			isDynamic: route.isDynamic,
+			paramNames: route.paramNames,
+			rootBoundaryId: route.rootBoundaryId,
+			pageId: route.pageId,
+			layoutIds: route.layoutIds,
+			slotIds: route.slotIds
+		})),
+		layouts: browserGraph.layouts.map((layout) => ({
+			id: layout.id,
+			patternParts: layout.patternParts,
+			rootBoundaryId: layout.rootBoundaryId
+		})),
+		slotBindings: browserGraph.slotBindings.map((binding) => ({
+			id: binding.id,
+			routeId: binding.routeId,
+			slotId: binding.slotId,
+			ownerLayoutId: binding.ownerLayoutId,
+			state: binding.state,
+			routeSegments: binding.routeSegments,
+			slotPatternParts: binding.slotPatternParts,
+			slotParamNames: binding.slotParamNames
+		})),
+		interceptions: Array.from(graph.interceptions.values(), (interception) => ({
+			id: interception.id,
+			sourcePatternParts: interception.sourcePatternParts,
+			targetPatternParts: interception.targetPatternParts,
+			slotId: interception.slotId,
+			ownerLayoutId: interception.ownerLayoutId,
+			targetRouteId: interception.targetRouteId
+		})),
+		interceptionsBySlotId: Array.from(graph.interceptionsBySlotId, ([slotId, interceptions]) => [slotId, interceptions.map((interception) => interception.id)]),
+		rootBoundaries: browserGraph.rootBoundaries.map((rootBoundary) => ({
+			id: rootBoundary.id,
+			treePath: rootBoundary.treePath
+		}))
+	};
+}
+function mapById(values) {
+	return new Map(values.map((value) => [value.id, value]));
+}
+function decodeBrowserRouteManifest(wire) {
+	const interceptions = mapById(wire.interceptions);
+	return {
+		graphVersion: wire.graphVersion,
+		segmentGraph: {
+			routes: mapById(wire.routes.map((route) => ({
+				...route,
+				id: route.id ?? createRouteIdFromPatternParts(route.patternParts)
+			}))),
+			layouts: mapById(wire.layouts),
+			slotBindings: mapById(wire.slotBindings),
+			interceptions,
+			interceptionsBySlotId: new Map(wire.interceptionsBySlotId.map(([slotId, interceptionIds]) => [slotId, interceptionIds.flatMap((id) => interceptions.get(id) ?? [])])),
+			rootBoundaries: mapById(wire.rootBoundaries)
+		}
+	};
+}
+//#endregion
+export { decodeBrowserRouteManifest, toBrowserRouteManifestWire };

package/dist/routing/hashed-route-patterns.d.ts

@@ -0,0 +1,4 @@
+//#region src/routing/hashed-route-patterns.d.ts
+export declare function hashRoutePatternParts(patternParts: readonly string[]): string[];
+export declare function hashRoutePathname(pathname: string): string;
+//#endregion

package/dist/routing/hashed-route-patterns.js

@@ -0,0 +1,22 @@
+import { splitPathnameForRouteMatch } from "./utils.js";
+import { fnv1a64 } from "../utils/hash.js";
+//#region src/routing/hashed-route-patterns.ts
+/**
+* Hybrid App/Pages clients need App route handler patterns only to decide
+* route ownership, so they receive them with every static segment hashed and
+* never see the handlers' paths in plain text (issue #3624). Dynamic parts
+* stay as they are, so a hashed pattern matches a hashed URL with the usual
+* route trie. A collision can only add a false handler match, which sends the
+* navigation to the document.
+*/
+function hashRouteSegment(segment) {
+	return fnv1a64(segment).slice(0, 8);
+}
+function hashRoutePatternParts(patternParts) {
+	return patternParts.map((part) => part.startsWith(":") ? part : hashRouteSegment(part));
+}
+function hashRoutePathname(pathname) {
+	return "/" + splitPathnameForRouteMatch(pathname).map(hashRouteSegment).join("/");
+}
+//#endregion
+export { hashRoutePathname, hashRoutePatternParts };

package/dist/routing/optimistic-route-trie.d.ts

@@ -0,0 +1,27 @@
+//#region src/routing/optimistic-route-trie.d.ts
+type OptimisticTrieRoute = {
+  readonly patternParts: readonly string[];
+};
+export type OptimisticRouteTrieNode<Route extends OptimisticTrieRoute> = {
+  catchAllChild: {
+    paramName: string;
+    route: Route;
+  } | null;
+  dynamicChild: {
+    node: OptimisticRouteTrieNode<Route>;
+    paramName: string;
+  } | null;
+  optionalCatchAllChild: {
+    paramName: string;
+    route: Route;
+  } | null;
+  route: Route | null;
+  staticChildren: Map<string, OptimisticRouteTrieNode<Route>>;
+};
+export type OptimisticRouteTrieMatch<Route extends OptimisticTrieRoute> = {
+  params: Record<string, string | string[]>;
+  route: Route;
+};
+export declare function buildOptimisticRouteTrie<Route extends OptimisticTrieRoute>(routes: Iterable<Route>, onDynamicSegmentConflict?: (existingParamName: string, part: string) => void): OptimisticRouteTrieNode<Route>;
+export declare function matchOptimisticRouteTrie<Route extends OptimisticTrieRoute>(trie: OptimisticRouteTrieNode<Route>, urlParts: readonly string[]): OptimisticRouteTrieMatch<Route> | null;
+//#endregion

package/dist/routing/optimistic-route-trie.js

@@ -0,0 +1,102 @@
+import { buildParams } from "./utils.js";
+//#region src/routing/optimistic-route-trie.ts
+function createNode() {
+	return {
+		catchAllChild: null,
+		dynamicChild: null,
+		optionalCatchAllChild: null,
+		route: null,
+		staticChildren: /* @__PURE__ */ new Map()
+	};
+}
+function buildOptimisticRouteTrie(routes, onDynamicSegmentConflict) {
+	const root = createNode();
+	for (const route of routes) {
+		let node = root;
+		const parts = route.patternParts;
+		if (parts.length === 0) {
+			node.route ??= route;
+			continue;
+		}
+		for (const [index, part] of parts.entries()) {
+			const isTerminal = index === parts.length - 1;
+			if (part.startsWith(":") && part.endsWith("+")) {
+				if (isTerminal && node.catchAllChild === null) node.catchAllChild = {
+					paramName: part.slice(1, -1),
+					route
+				};
+				break;
+			}
+			if (part.startsWith(":") && part.endsWith("*")) {
+				if (isTerminal && node.optionalCatchAllChild === null) node.optionalCatchAllChild = {
+					paramName: part.slice(1, -1),
+					route
+				};
+				break;
+			}
+			if (part.startsWith(":")) {
+				const paramName = part.slice(1);
+				if (node.dynamicChild === null) node.dynamicChild = {
+					node: createNode(),
+					paramName
+				};
+				else if (node.dynamicChild.paramName !== paramName) onDynamicSegmentConflict?.(node.dynamicChild.paramName, part);
+				node = node.dynamicChild.node;
+				if (isTerminal) node.route ??= route;
+				continue;
+			}
+			let staticChild = node.staticChildren.get(part);
+			if (staticChild === void 0) {
+				staticChild = createNode();
+				node.staticChildren.set(part, staticChild);
+			}
+			node = staticChild;
+			if (isTerminal) node.route ??= route;
+		}
+	}
+	return root;
+}
+function matchNode(node, urlParts, index, entries) {
+	if (index === urlParts.length) {
+		if (node.route !== null) return {
+			route: node.route,
+			params: buildParams(entries)
+		};
+		if (node.optionalCatchAllChild !== null) return {
+			route: node.optionalCatchAllChild.route,
+			params: buildParams(entries)
+		};
+		return null;
+	}
+	const segment = urlParts[index];
+	const staticChild = node.staticChildren.get(segment);
+	if (staticChild !== void 0) return matchNode(staticChild, urlParts, index + 1, entries);
+	if (node.dynamicChild !== null) {
+		entries.push([node.dynamicChild.paramName, segment]);
+		const match = matchNode(node.dynamicChild.node, urlParts, index + 1, entries);
+		if (match !== null) return match;
+		entries.pop();
+	}
+	if (node.catchAllChild !== null) {
+		const params = buildParams(entries);
+		params[node.catchAllChild.paramName] = urlParts.slice(index);
+		return {
+			route: node.catchAllChild.route,
+			params
+		};
+	}
+	if (node.optionalCatchAllChild !== null) {
+		const params = buildParams(entries);
+		params[node.optionalCatchAllChild.paramName] = urlParts.slice(index);
+		return {
+			route: node.optionalCatchAllChild.route,
+			params
+		};
+	}
+	return null;
+}
+function matchOptimisticRouteTrie(trie, urlParts) {
+	return matchNode(trie, urlParts, 0, []);
+}
+//#endregion
+export { buildOptimisticRouteTrie, matchOptimisticRouteTrie };

package/dist/routing/route-validation.d.ts

@@ -1,9 +1,14 @@
 //#region src/routing/route-validation.d.ts
 /**
- * Dynamic route validation adapted from Next.js' sorted-routes implementation.
+ * Dynamic route validation and sorting adapted from Next.js' sorted-routes implementation.
  * Source:
  * https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/router/utils/sorted-routes.ts
  */
+/**
+ * Sort Next.js-format page paths (e.g. "/posts/[id]") into route-priority
+ * order, matching Next.js' `getSortedRoutes`.
+ */
+export declare function getSortedRoutes(pages: readonly string[]): string[];
 export declare function patternToNextFormat(pattern: string): string;
 export declare function validateRoutePatterns(patterns: readonly string[]): void;
 //#endregion

package/dist/routing/route-validation.js

@@ -1,7 +1,7 @@
 import { removeTrailingSlash } from "../utils/base-path.js";
 //#region src/routing/route-validation.ts
 /**
-* Dynamic route validation adapted from Next.js' sorted-routes implementation.
+* Dynamic route validation and sorting adapted from Next.js' sorted-routes implementation.
 * Source:
 * https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/router/utils/sorted-routes.ts
 */
@@ -69,17 +69,33 @@ var UrlNode = class UrlNode {
 		}
 		child.insertSegments(urlPaths.slice(1), slugNames, isCatchAll);
 	}
-	assertOptionalCatchAllSpecificity(prefix = "/") {
-		if (!this.placeholder && this.optionalRestSlugName !== null) {
+	/**
+	* Flatten the tree into route-priority order: static children
+	* alphabetically, then the dynamic, catch-all and optional catch-all
+	* children. Throws when a route shares a level with an optional catch-all.
+	*/
+	smoosh(prefix = "/") {
+		const routes = [...this.children.keys()].filter((segment) => segment !== "[]" && segment !== "[...]" && segment !== "[[...]]").sort().flatMap((segment) => this.children.get(segment).smoosh(`${prefix}${segment}/`));
+		if (this.slugName !== null) routes.push(...this.children.get("[]").smoosh(`${prefix}[${this.slugName}]/`));
+		if (!this.placeholder) {
 			const route = prefix === "/" ? "/" : prefix.slice(0, -1);
-			throw new Error(`You cannot define a route with the same specificity as a optional catch-all route ("${route}" and "${route}[[...${this.optionalRestSlugName}]]").`);
-		}
-		for (const [segment, child] of this.children) {
-			const nextPrefixSegment = segment === "[]" ? `[${this.slugName}]` : segment === "[...]" ? `[...${this.restSlugName}]` : segment === "[[...]]" ? `[[...${this.optionalRestSlugName}]]` : segment;
-			child.assertOptionalCatchAllSpecificity(`${prefix}${nextPrefixSegment}/`);
+			if (this.optionalRestSlugName !== null) throw new Error(`You cannot define a route with the same specificity as a optional catch-all route ("${route}" and "${route}[[...${this.optionalRestSlugName}]]").`);
+			routes.unshift(route);
 		}
+		if (this.restSlugName !== null) routes.push(...this.children.get("[...]").smoosh(`${prefix}[...${this.restSlugName}]/`));
+		if (this.optionalRestSlugName !== null) routes.push(...this.children.get("[[...]]").smoosh(`${prefix}[[...${this.optionalRestSlugName}]]/`));
+		return routes;
 	}
 };
+/**
+* Sort Next.js-format page paths (e.g. "/posts/[id]") into route-priority
+* order, matching Next.js' `getSortedRoutes`.
+*/
+function getSortedRoutes(pages) {
+	const root = new UrlNode();
+	for (const page of pages) root.insert(page);
+	return root.smoosh();
+}
 function patternToNextFormat(pattern) {
 	if (pattern === "/") return "/";
 	return pattern.split("/").map((segment) => {
@@ -102,7 +118,7 @@ function validateRoutePatterns(patterns) {
 		seenPatterns.add(normalizedPattern);
 		root.insert(patternToNextFormat(normalizedPattern));
 	}
-	root.assertOptionalCatchAllSpecificity();
+	root.smoosh();
 }
 //#endregion
-export { patternToNextFormat, validateRoutePatterns };
+export { getSortedRoutes, patternToNextFormat, validateRoutePatterns };

package/dist/server/app-action-forwarding.d.ts

@@ -1,3 +1,4 @@
+import { ExecutionContextLike } from "../shims/request-context.js";
 import { AppMiddlewareContext } from "./app-middleware.js";
 //#region src/server/app-action-forwarding.d.ts
 type ActionOwnerManifest = Readonly<Record<string, readonly string[]>>;
@@ -13,5 +14,12 @@ type ForwardServerActionOptions = {
   request: Request;
 };
 export declare function areServerActionsOwnedByRoute(actionOwners: ActionOwnerManifest | null, actionIds: readonly string[], currentRoutePattern: string | null): boolean;
+/**
+ * The execution context a forwarded action re-enters the app handler with.
+ * Middleware runs again there, so it keeps the server-owned middleware origin.
+ */
+export declare function createForwardedActionContext(executionContext: ExecutionContextLike | null | undefined): {
+  actionForwarded: true;
+} & Partial<ExecutionContextLike>;
 export declare function forwardServerActionIfNeeded(options: ForwardServerActionOptions): Promise<Response | null>;
 //#endregion

package/dist/server/app-action-forwarding.js

@@ -98,6 +98,20 @@ function areServerActionsOwnedByRoute(actionOwners, actionIds, currentRoutePatte
 		return ownerPatterns?.includes("*") === true || currentRoutePattern !== null && ownerPatterns?.includes(currentRoutePattern) === true;
 	});
 }
+/**
+* The execution context a forwarded action re-enters the app handler with.
+* Middleware runs again there, so it keeps the server-owned middleware origin.
+*/
+function createForwardedActionContext(executionContext) {
+	if (!executionContext) return { actionForwarded: true };
+	return {
+		actionForwarded: true,
+		cache: executionContext.cache,
+		middlewareOrigin: executionContext.middlewareOrigin,
+		passThroughOnException: executionContext.passThroughOnException?.bind(executionContext),
+		waitUntil: executionContext.waitUntil.bind(executionContext)
+	};
+}
 async function forwardServerActionIfNeeded(options) {
 	if (!options.actionOwners) return null;
 	const csrfResponse = validateCsrfOrigin(options.request, options.allowedOrigins);
@@ -137,4 +151,4 @@ async function forwardServerActionIfNeeded(options) {
 	return emptyActionForwardResponse(options.middlewareContext);
 }
 //#endregion
-export { areServerActionsOwnedByRoute, forwardServerActionIfNeeded };
+export { areServerActionsOwnedByRoute, createForwardedActionContext, forwardServerActionIfNeeded };