vinext 0.1.2 → 0.1.3

package/dist/routing/utils.d.ts

@@ -1,13 +1,42 @@
 //#region src/routing/utils.d.ts
 /**
- * Sort comparator for routes — lower precedence score sorts first (higher priority).
- * Lexicographic tiebreaker on pattern for determinism.
+ * Sort routes by precedence — lower score sorts first (higher priority), with a
+ * lexicographic tiebreaker on the pattern for determinism. Sorts in place and
+ * returns the same array (mirrors `Array.prototype.sort`).
  *
- * Usage: routes.sort(compareRoutes)
+ * `routePrecedence` is a pure function of the pattern, so each pattern's score
+ * is computed exactly once up front (decorate-sort) instead of ~2·log n times
+ * by a comparator that re-parses on every comparison. The `localeCompare`
+ * tiebreaker already guarantees a total order, so the result is byte-identical
+ * to comparing precedence inline.
+ *
+ * Usage: sortRoutes(routes)
  */
-declare function compareRoutes<T extends {
+declare function sortRoutes<T extends {
   pattern: string;
-}>(a: T, b: T): number;
+}>(routes: T[]): T[];
+/**
+ * Single source of truth for hybrid App/Pages route ownership.
+ *
+ * Mirrors Next.js's DefaultRouteMatcherManager ordering: Pages providers
+ * are registered before App providers, then merged dynamic matchers sort
+ * together. Returns the router that should own a request/navigation to
+ * a URL that matched BOTH routers.
+ *
+ * Centralised so the server's request handling and the client's link /
+ * prefetch / programmatic-navigation paths all reach the same owner for
+ * the same (pages pattern, app pattern) pair. This intentionally implements
+ * Next.js's segment-tree ordering directly instead of vinext's broader
+ * `sortRoutes()` score heuristic. It only arbitrates two routes that already
+ * matched the same URL; each router's own trie ordering remains unchanged.
+ *
+ * Usage:
+ *   compareHybridRoutePatterns("/:slug", true, "/:slug", true)  // → "pages"
+ *   compareHybridRoutePatterns("/_sites/:slug*", true, "/:slug*", true)  // → "pages"
+ *   compareHybridRoutePatterns("/:path+", true, "/dashboard", false)  // → "app"
+ *   compareHybridRoutePatterns("/", false, "/", false)  // → "app"
+ */
+declare function compareHybridRoutePatterns(pagesPattern: string, pagesIsDynamic: boolean, appPattern: string, appIsDynamic: boolean): "app" | "pages";
 /**
  * Decode a filesystem or URL path segment while preserving encoded path delimiters.
  * Mirrors Next.js segment-wise decoding so "%5F" becomes "_" but "%2F" stays "%2F".
@@ -85,4 +114,4 @@ declare function isOptionalCatchAllSegment(segment: string): boolean;
  */
 declare function countConsumedPathnameSegments(visibleTreePathSegments: readonly string[], pathnameSegmentCount: number): number;
 //#endregion
-export { buildParams, compareRoutes, countConsumedPathnameSegments, decodeMatchedParams, decodeRouteSegment, isCatchAllSegment, isInvisibleSegment, isOptionalCatchAllSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, splitPathSegments, splitPathnameForRouteMatch };
+export { buildParams, compareHybridRoutePatterns, countConsumedPathnameSegments, decodeMatchedParams, decodeRouteSegment, isCatchAllSegment, isInvisibleSegment, isOptionalCatchAllSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, sortRoutes, splitPathSegments, splitPathnameForRouteMatch };

package/dist/routing/utils.js

@@ -44,14 +44,66 @@ function routePrecedence(pattern) {
 	return score;
 }
 /**
-* Sort comparator for routes — lower precedence score sorts first (higher priority).
-* Lexicographic tiebreaker on pattern for determinism.
+* Sort routes by precedence — lower score sorts first (higher priority), with a
+* lexicographic tiebreaker on the pattern for determinism. Sorts in place and
+* returns the same array (mirrors `Array.prototype.sort`).
 *
-* Usage: routes.sort(compareRoutes)
+* `routePrecedence` is a pure function of the pattern, so each pattern's score
+* is computed exactly once up front (decorate-sort) instead of ~2·log n times
+* by a comparator that re-parses on every comparison. The `localeCompare`
+* tiebreaker already guarantees a total order, so the result is byte-identical
+* to comparing precedence inline.
+*
+* Usage: sortRoutes(routes)
+*/
+function sortRoutes(routes) {
+	const scores = /* @__PURE__ */ new Map();
+	for (const route of routes) if (!scores.has(route.pattern)) scores.set(route.pattern, routePrecedence(route.pattern));
+	return routes.sort((a, b) => {
+		const diff = (scores.get(a.pattern) ?? 0) - (scores.get(b.pattern) ?? 0);
+		return diff !== 0 ? diff : a.pattern.localeCompare(b.pattern);
+	});
+}
+/**
+* Single source of truth for hybrid App/Pages route ownership.
+*
+* Mirrors Next.js's DefaultRouteMatcherManager ordering: Pages providers
+* are registered before App providers, then merged dynamic matchers sort
+* together. Returns the router that should own a request/navigation to
+* a URL that matched BOTH routers.
+*
+* Centralised so the server's request handling and the client's link /
+* prefetch / programmatic-navigation paths all reach the same owner for
+* the same (pages pattern, app pattern) pair. This intentionally implements
+* Next.js's segment-tree ordering directly instead of vinext's broader
+* `sortRoutes()` score heuristic. It only arbitrates two routes that already
+* matched the same URL; each router's own trie ordering remains unchanged.
+*
+* Usage:
+*   compareHybridRoutePatterns("/:slug", true, "/:slug", true)  // → "pages"
+*   compareHybridRoutePatterns("/_sites/:slug*", true, "/:slug*", true)  // → "pages"
+*   compareHybridRoutePatterns("/:path+", true, "/dashboard", false)  // → "app"
+*   compareHybridRoutePatterns("/", false, "/", false)  // → "app"
 */
-function compareRoutes(a, b) {
-	const diff = routePrecedence(a.pattern) - routePrecedence(b.pattern);
-	return diff !== 0 ? diff : a.pattern.localeCompare(b.pattern);
+function compareHybridRoutePatterns(pagesPattern, pagesIsDynamic, appPattern, appIsDynamic) {
+	if (pagesPattern === appPattern) throw new Error(`Conflicting app and page routes found for "${pagesPattern}"`);
+	if (!pagesIsDynamic) return appIsDynamic ? "pages" : "app";
+	if (!appIsDynamic) return "app";
+	const pagesSegments = pagesPattern.split("/").filter(Boolean);
+	const appSegments = appPattern.split("/").filter(Boolean);
+	const segmentRank = (segment) => {
+		if (!segment.startsWith(":")) return 0;
+		if (segment.endsWith("*")) return 3;
+		if (segment.endsWith("+")) return 2;
+		return 1;
+	};
+	for (let index = 0; index < Math.min(pagesSegments.length, appSegments.length); index++) {
+		const pagesRank = segmentRank(pagesSegments[index]);
+		const appRank = segmentRank(appSegments[index]);
+		if (pagesRank !== appRank) return pagesRank < appRank ? "pages" : "app";
+	}
+	if (pagesSegments.length !== appSegments.length) return pagesSegments.length < appSegments.length ? "pages" : "app";
+	return "pages";
 }
 const PATH_DELIMITER_REGEX = /([/#?\\]|%(2f|23|3f|5c))/gi;
 function encodePathDelimiters(segment) {
@@ -187,4 +239,4 @@ function countConsumedPathnameSegments(visibleTreePathSegments, pathnameSegmentC
 	return consumed;
 }
 //#endregion
-export { buildParams, compareRoutes, countConsumedPathnameSegments, decodeMatchedParams, decodeRouteSegment, isCatchAllSegment, isInvisibleSegment, isOptionalCatchAllSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, splitPathSegments, splitPathnameForRouteMatch };
+export { buildParams, compareHybridRoutePatterns, countConsumedPathnameSegments, decodeMatchedParams, decodeRouteSegment, isCatchAllSegment, isInvisibleSegment, isOptionalCatchAllSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, sortRoutes, splitPathSegments, splitPathnameForRouteMatch };

package/dist/server/api-handler.d.ts

@@ -1,3 +1,4 @@
+import { NextI18nConfig } from "../config/next-config.js";
 import { Route } from "../routing/pages-router.js";
 import { ModuleImporter } from "./instrumentation.js";
 import { IncomingMessage, ServerResponse } from "node:http";
@@ -7,6 +8,10 @@ import { IncomingMessage, ServerResponse } from "node:http";
  * Handle an API route request.
  * Returns true if the request was handled, false if no API route matched.
  */
-declare function handleApiRoute(runner: ModuleImporter, req: IncomingMessage, res: ServerResponse, url: string, apiRoutes: Route[]): Promise<boolean>;
+declare function handleApiRoute(runner: ModuleImporter, req: IncomingMessage, res: ServerResponse, url: string, apiRoutes: Route[], nextConfig?: {
+  basePath?: string;
+  i18n?: NextI18nConfig | null;
+  trailingSlash?: boolean;
+}): Promise<boolean>;
 //#endregion
 export { handleApiRoute };

package/dist/server/api-handler.js

@@ -1,8 +1,10 @@
+import { hasBasePath } from "../utils/base-path.js";
 import { matchRoute } from "../routing/pages-router.js";
 import "./server-globals.js";
+import { parseCookieHeader } from "../utils/parse-cookie.js";
 import { NextRequest } from "../shims/server.js";
 import { importModule, reportRequestError } from "./instrumentation.js";
-import { mergeRouteParamsIntoQuery, parseQueryString } from "../utils/query.js";
+import { mergeRouteParamsIntoQuery, parseQueryString, urlQueryToSearchParams } from "../utils/query.js";
 import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-media-type.js";
 import { isEdgeApiRuntime } from "./edge-api-runtime.js";
 import { DEFAULT_PAGES_API_BODY_SIZE_LIMIT, resolveBodyParserConfig } from "./pages-body-parser-config.js";
@@ -71,13 +73,7 @@ async function parseBody(req, sizeLimit = MAX_BODY_SIZE) {
 * Parse cookies from the Cookie header.
 */
 function parseCookies(req) {
-	const header = req.headers.cookie ?? "";
-	const cookies = {};
-	for (const part of header.split(";")) {
-		const [key, ...rest] = part.split("=");
-		if (key) cookies[key.trim()] = rest.join("=").trim();
-	}
-	return cookies;
+	return parseCookieHeader(req.headers.cookie);
 }
 function isEdgeApiRouteModule(module) {
 	if (typeof module.default !== "function") return false;
@@ -98,13 +94,19 @@ function readEdgeRequestBody(req) {
 		req.on("error", (error) => controller.error(error));
 	} });
 }
-function createEdgeApiRequest(req, url) {
+function createEdgeApiRequest(req, url, params, nextConfig) {
 	const headers = new Headers();
-	for (const [name, value] of Object.entries(req.headers)) if (Array.isArray(value)) for (const item of value) headers.append(name, item);
-	else if (value !== void 0) headers.set(name, value);
+	for (const [name, value] of Object.entries(req.headers)) {
+		if (name.startsWith(":")) continue;
+		if (Array.isArray(value)) for (const item of value) headers.append(name, item);
+		else if (value !== void 0) headers.set(name, value);
+	}
 	const proto = resolveRequestProtocol(req);
 	const host = resolveRequestHost(req, "localhost");
-	const requestUrl = new URL(url, `${proto}://${host}`);
+	const requestUrl = new URL(req.url ?? url, `${proto}://${host}`);
+	const basePath = nextConfig?.basePath;
+	if (basePath && !hasBasePath(requestUrl.pathname, basePath)) requestUrl.pathname = `${basePath}${requestUrl.pathname}`;
+	requestUrl.search = urlQueryToSearchParams(mergeRouteParamsIntoQuery(parseQueryString(url), params)).toString();
 	const body = readEdgeRequestBody(req);
 	const init = {
 		headers,
@@ -210,14 +212,18 @@ function enhanceApiObjects(req, res, query, body) {
 * Handle an API route request.
 * Returns true if the request was handled, false if no API route matched.
 */
-async function handleApiRoute(runner, req, res, url, apiRoutes) {
+async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 	const match = matchRoute(url, apiRoutes);
 	if (!match) return false;
 	const { route, params } = match;
 	try {
 		const apiModule = await importModule(runner, route.filePath);
 		if (isEdgeApiRouteModule(apiModule)) {
-			const nextRequest = new NextRequest(createEdgeApiRequest(req, url));
+			const nextRequest = new NextRequest(createEdgeApiRequest(req, url, params, nextConfig), nextConfig ? { nextConfig: {
+				basePath: nextConfig.basePath,
+				i18n: nextConfig.i18n ?? void 0,
+				trailingSlash: nextConfig.trailingSlash
+			} } : void 0);
 			const response = await apiModule.default(nextRequest);
 			if (!(response instanceof Response)) throw new Error("Edge API route did not return a Response");
 			res.statusCode = response.status;
@@ -253,7 +259,7 @@ async function handleApiRoute(runner, req, res, url, apiRoutes) {
 		reportRequestError(e instanceof Error ? e : new Error(String(e)), {
 			path: url,
 			method: req.method ?? "GET",
-			headers: Object.fromEntries(Object.entries(req.headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(", ") : String(v ?? "")]))
+			headers: Object.fromEntries(Object.entries(req.headers).filter(([k]) => !k.startsWith(":")).map(([k, v]) => [k, Array.isArray(v) ? v.join(", ") : String(v ?? "")]))
 		}, {
 			routerKind: "Pages Router",
 			routePath: match.route.pattern,

package/dist/server/app-browser-action-result.d.ts

@@ -1,3 +1,5 @@
+import { ServerActionResultFacts } from "./navigation-planner.js";
+
 //#region src/server/app-browser-action-result.d.ts
 type AppBrowserServerActionResult<TRoot> = {
   root?: TRoot;
@@ -24,12 +26,23 @@ declare function shouldClearClientNavigationCachesForServerActionResult<TRoot>(r
 declare function parseServerActionRevalidationHeader(headers: Pick<Headers, "get">): ServerActionRevalidationKind;
 declare function normalizeServerActionThrownValue(data: unknown, responseStatus: number): unknown;
 declare function readInvalidServerActionResponseError(response: Pick<Response, "headers" | "status" | "text">, hasRedirectLocation: boolean): Promise<Error | null>;
-declare function shouldCheckRscCompatibilityForServerActionResponse(response: Pick<Response, "headers">): boolean;
-declare function resolveServerActionRedirectCompatibilityHardNavigationTarget(options: {
+type ServerActionResultResponseFactsInput = {
   actionRedirectHref: string | null;
-  clientCompatibilityId: string | null | undefined;
-  response: Pick<Response, "headers">;
-}): string | null;
+  actionRedirectType: string | null;
+  clientCompatibilityId: string | null;
+  contentTypeHeader: string | null;
+  compatibilityIdHeader: string | null;
+  currentHref: string;
+  origin: string;
+  responseUrl: string | null;
+};
+/**
+ * Converts raw browser response data into the narrow facts expected by the
+ * navigation planner. This is the single place where redirect-type
+ * normalisation and RSC content-type detection happen for server-action
+ * compatibility checks.
+ */
+declare function createServerActionResultFacts(input: ServerActionResultResponseFactsInput): ServerActionResultFacts;
 declare function shouldScheduleRefreshForDiscardedServerAction(revalidation: ServerActionRevalidationKind): boolean;
 declare function createServerActionInitiationSnapshot<TRouterState>(options: {
   href: string;
@@ -48,4 +61,4 @@ type DiscardedServerActionRefreshSchedulerOptions = {
 };
 declare function createDiscardedServerActionRefreshScheduler(options: DiscardedServerActionRefreshSchedulerOptions): DiscardedServerActionRefreshScheduler;
 //#endregion
-export { AppBrowserServerActionResult, ServerActionRevalidationKind, createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, resolveServerActionRedirectCompatibilityHardNavigationTarget, shouldCheckRscCompatibilityForServerActionResponse, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction };
+export { AppBrowserServerActionResult, ServerActionResultResponseFactsInput, ServerActionRevalidationKind, createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction };

package/dist/server/app-browser-action-result.js

@@ -1,5 +1,5 @@
 import { ACTION_REVALIDATED_HEADER } from "./headers.js";
-import { VINEXT_RSC_CONTENT_TYPE, isRscCompatibilityIdCompatible } from "./app-rsc-cache-busting.js";
+import { VINEXT_RSC_CONTENT_TYPE } from "./app-rsc-cache-busting.js";
 //#region src/server/app-browser-action-result.ts
 const ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC = 1;
 const ACTION_DID_REVALIDATE_DYNAMIC_ONLY = 2;
@@ -47,14 +47,23 @@ async function readInvalidServerActionResponseError(response, hasRedirectLocatio
 	const message = response.status >= 400 && contentType.toLowerCase().startsWith("text/plain") ? await response.text() : "An unexpected response was received from the server.";
 	return new Error(message || "An unexpected response was received from the server.");
 }
-function shouldCheckRscCompatibilityForServerActionResponse(response) {
-	return (response.headers.get("content-type") ?? "").startsWith(VINEXT_RSC_CONTENT_TYPE);
-}
-function resolveServerActionRedirectCompatibilityHardNavigationTarget(options) {
-	if (!options.actionRedirectHref) return null;
-	if (!shouldCheckRscCompatibilityForServerActionResponse(options.response)) return null;
-	if (isRscCompatibilityIdCompatible(options.response.headers.get("X-Vinext-RSC-Compatibility-Id"), options.clientCompatibilityId)) return null;
-	return options.actionRedirectHref;
+/**
+* Converts raw browser response data into the narrow facts expected by the
+* navigation planner. This is the single place where redirect-type
+* normalisation and RSC content-type detection happen for server-action
+* compatibility checks.
+*/
+function createServerActionResultFacts(input) {
+	return {
+		actionRedirectHref: input.actionRedirectHref,
+		actionRedirectType: input.actionRedirectType === "push" ? "push" : "replace",
+		clientCompatibilityId: input.clientCompatibilityId,
+		compatibilityIdHeader: input.compatibilityIdHeader,
+		currentHref: input.currentHref,
+		isRscContentType: (input.contentTypeHeader ?? "").startsWith(VINEXT_RSC_CONTENT_TYPE),
+		origin: input.origin,
+		responseUrl: input.responseUrl
+	};
 }
 function shouldScheduleRefreshForDiscardedServerAction(revalidation) {
 	return revalidation !== "none";
@@ -99,4 +108,4 @@ function createDiscardedServerActionRefreshScheduler(options) {
 	};
 }
 //#endregion
-export { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, resolveServerActionRedirectCompatibilityHardNavigationTarget, shouldCheckRscCompatibilityForServerActionResponse, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction };
+export { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction };