vinext 1.0.0-beta.8 → 1.0.0

package/dist/server/middleware-runtime.js

@@ -1,20 +1,36 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import "../utils/protocol-headers.js";
+import { shouldKeepMiddlewareHeader } from "../utils/middleware-request-headers.js";
+import { normalizeHost } from "../config/request-context.js";
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { addBasePathToPathname, hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
-import "./server-globals.js";
-import { normalizeHost } from "../config/request-context.js";
 import { getRequestExecutionContext, runWithExecutionContext } from "../shims/request-context.js";
-import "../utils/protocol-headers.js";
+import "./server-globals.js";
 import { MIDDLEWARE_REWRITE_HEADER } from "./headers.js";
-import { shouldKeepMiddlewareHeader } from "../utils/middleware-request-headers.js";
 import { NextFetchEvent, NextRequest } from "../shims/server.js";
 import { normalizePath } from "./normalize-path.js";
-import { matchesMiddleware } from "./middleware-matcher.js";
+import { matchesMiddleware, matchesMiddlewarePathname } from "./middleware-matcher.js";
 import { badRequestResponse, internalServerErrorResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped } from "./open-redirect.js";
 import { processMiddlewareHeaders } from "./request-pipeline.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
+import { reportRequestError } from "./instrumentation.js";
+import { isValidNavigationSignalError } from "../utils/navigation-signal.js";
+import { frameworkTracer } from "./tracer.js";
 //#region src/server/middleware-runtime.ts
+function reportProxyError(options, error) {
+	const url = new URL(options.request.url);
+	return reportRequestError(error, {
+		path: url.pathname + url.search,
+		method: options.request.method,
+		headers: Object.fromEntries(options.request.headers.entries())
+	}, {
+		routerKind: "Pages Router",
+		routePath: "/proxy",
+		routeType: "proxy",
+		revalidateReason: void 0
+	});
+}
 function isMiddlewareHandler(value) {
 	return typeof value === "function";
 }
@@ -187,9 +203,13 @@ async function executeMiddleware(options) {
 			kind: "defaulted"
 		};
 	}
+	const encodedPathMatches = encodedMatchPathname !== null && matchesMiddlewarePathname(encodedMatchPathname, matcher, options.i18nConfig, localeContext);
+	const decodedPathMatches = !encodedPathMatches && decodedMatchPathname !== null && decodedMatchPathname !== encodedMatchPathname && matchesMiddlewarePathname(decodedMatchPathname, matcher, options.i18nConfig, localeContext);
+	if (encodedPathMatches || decodedPathMatches) options.onPathMatch?.();
 	const encodedMatches = encodedMatchPathname !== null && matchesMiddleware(encodedMatchPathname, matcher, options.request, options.i18nConfig, localeContext);
 	const decodedMatches = !encodedMatches && decodedMatchPathname !== null && decodedMatchPathname !== encodedMatchPathname && matchesMiddleware(decodedMatchPathname, matcher, options.request, options.i18nConfig, localeContext);
 	if (!encodedMatches && !decodedMatches) return { continue: true };
+	options.onMatch?.();
 	const nextRequest = createNextRequest(options.request, options.i18nConfig, options.basePath, options.trailingSlash, hadBasePath, options.requestBodyAlreadyIsolated);
 	if (options.isDataRequest) Object.defineProperty(nextRequest, "__isData", {
 		enumerable: false,
@@ -198,14 +218,25 @@ async function executeMiddleware(options) {
 	const fetchEvent = new NextFetchEvent({ page: removeTrailingSlash(matchPathname) });
 	let response;
 	try {
-		response = await middlewareFn(nextRequest, fetchEvent);
+		response = await frameworkTracer.runWithDetachedContext(() => frameworkTracer.withPropagatedContext(options.request.headers, () => frameworkTracer.trace({
+			attributes: {
+				"http.method": options.request.method,
+				"http.target": nextRequest.nextUrl.pathname
+			},
+			name: `middleware ${options.request.method}`,
+			type: "Middleware.execute"
+		}, () => middlewareFn(nextRequest, fetchEvent))));
 	} catch (e) {
+		const isDevelopmentNavigationSignal = process.env.NODE_ENV !== "production" && isValidNavigationSignalError(e);
+		if (isDevelopmentNavigationSignal && e instanceof Error) e.message = `Next.js navigation API is not allowed to be used in ${options.isProxy ? "Proxy" : "Middleware"}.`;
 		console.error("[vinext] Middleware error:", e);
+		if (!isDevelopmentNavigationSignal) await reportProxyError(options, e);
 		const waitUntilPromises = drainFetchEvent(fetchEvent);
 		releaseMiddlewareRequestBody(nextRequest, waitUntilPromises);
+		const message = options.includeErrorDetails ? "Middleware Error: " + (e instanceof Error ? e.message : String(e)) : "Internal Server Error";
 		return {
 			continue: false,
-			response: internalServerErrorResponse(options.includeErrorDetails ? "Middleware Error: " + (e instanceof Error ? e.message : String(e)) : "Internal Server Error"),
+			response: internalServerErrorResponse(message),
 			waitUntilPromises
 		};
 	}
@@ -236,8 +267,10 @@ async function executeMiddleware(options) {
 				if (loc.origin === new URL(options.request.url).origin) {
 					const p = loc.pathname;
 					let normalized = null;
-					if (p !== "" && p !== "/") if (options.trailingSlash) normalized = p.endsWith("/") ? null : p + "/";
-					else normalized = p.endsWith("/") ? p.slice(0, -1) : null;
+					if (p !== "" && p !== "/") {
+						if (options.trailingSlash) normalized = p.endsWith("/") ? null : p + "/";
+						else normalized = p.endsWith("/") ? p.slice(0, -1) : null;
+					}
 					if (normalized !== null) {
 						loc.pathname = normalized;
 						normalizedLocation = relativizeLocation(loc.toString(), options.request.url);
@@ -302,7 +335,18 @@ async function executeMiddleware(options) {
 	};
 }
 async function runGeneratedMiddleware(options) {
-	const run = () => executeMiddleware(options);
+	let pathnameEligible = false;
+	const run = async () => {
+		const result = await executeMiddleware({
+			...options,
+			onPathMatch() {
+				pathnameEligible = true;
+				options.onPathMatch?.();
+			}
+		});
+		if (pathnameEligible) result.pathnameEligible = true;
+		return result;
+	};
 	return options.ctx ? runWithExecutionContext(options.ctx, run) : run();
 }
 //#endregion

package/dist/server/middleware.d.ts

@@ -1,7 +1,7 @@
 import { ValidFileMatcher } from "../routing/file-matcher.js";
 import { NextI18nConfig } from "../config/next-config.js";
-import { MiddlewareResult } from "./middleware-runtime.js";
 import { matchPattern, matchesMiddleware } from "./middleware-matcher.js";
+import { MiddlewareResult } from "./middleware-runtime.js";
 import { ModuleRunner } from "vite/module-runner";
 //#region src/server/middleware.d.ts
 /**
@@ -13,7 +13,7 @@ import { ModuleRunner } from "vite/module-runner";
  * named export or a default export:
  * https://github.com/vercel/next.js/blob/canary/packages/next/src/build/templates/middleware.ts
  */
-declare function isProxyFile(filePath: string): boolean;
+export declare function isProxyFile(filePath: string): boolean;
 /**
  * Find the proxy or middleware file at the selected app/pages convention level.
  * Checks for proxy.ts (Next.js 16) first, then falls back to middleware.ts.
@@ -31,7 +31,7 @@ declare function isProxyFile(filePath: string): boolean;
  * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/build/index.ts
  *   (search for "MIDDLEWARE_FILENAME" + "file convention is deprecated")
  */
-declare function findMiddlewareFile(root: string, fileMatcher: ValidFileMatcher, conventionDir?: string): string | null;
+export declare function findMiddlewareFile(root: string, fileMatcher: ValidFileMatcher, conventionDir?: string): string | null;
 /**
  * Load and execute middleware for a given request.
  *
@@ -44,6 +44,6 @@ declare function findMiddlewareFile(root: string, fileMatcher: ValidFileMatcher,
  * @param request - The incoming Request object
  * @returns Middleware result describing what action to take
  */
-declare function runMiddleware(runner: ModuleRunner, middlewarePath: string, request: Request, i18nConfig?: NextI18nConfig | null, basePath?: string, trailingSlash?: boolean, isDataRequest?: boolean, normalizedPathname?: string): Promise<MiddlewareResult>;
+export declare function runMiddleware(runner: ModuleRunner, middlewarePath: string, request: Request, i18nConfig?: NextI18nConfig | null, basePath?: string, trailingSlash?: boolean, isDataRequest?: boolean, normalizedPathname?: string): Promise<MiddlewareResult>;
 //#endregion
-export { findMiddlewareFile, isProxyFile, matchPattern, matchesMiddleware, runMiddleware };
+export { matchPattern, matchesMiddleware };

package/dist/server/multi-stage.d.ts

@@ -0,0 +1,141 @@
+import { CacheabilityRepresentation } from "./cacheability-manifest.js";
+//#region src/server/multi-stage.d.ts
+/** Whether a response-stage cache must reject a field it did not key itself by. */
+export declare function hasUnsupportedResponseStageVary(headers: Headers, keyedRequestHeaders?: Iterable<string>): boolean;
+/**
+ * Transport-neutral cache intent passed from the request stage to an
+ * adapter-owned response-stage transport.
+ */
+export type VinextResponseStageDispatchOptions = {
+  /**
+   * Whether the adapter may use its shared response transport. Bypassed work
+   * still uses the same response stage, but must not pass through a host cache.
+   * Without a `cacheIdentity`, a shared transport must partition its baseline
+   * lookup by the request method, complete request URL (including scheme,
+   * authority, exact path, and query), plus the complete serialized stage
+   * props; each can affect handler selection or response bytes.
+   * Framework-managed selectors are already represented by that URL and the
+   * serialized props. A verbatim-capable transport must partition stored
+   * variants by every named `Vary` request header and never store `Vary: *`.
+   * Other transports must reject application-defined variance themselves or
+   * opt into completed-response admission and honor core's `no-store` policy.
+   */
+  cache: "shared" | "bypass";
+  /**
+   * Query-free identity of a shared App page GET/HEAD dispatch, supplied only
+   * to adapters that declare `responseStageCacheIdentity: "query-free"` and
+   * require completed-response admission. A transport given one partitions
+   * its baseline lookup and stored entry by this request's method and complete
+   * URL plus these complete serialized props, instead of the dispatched request
+   * and props, and replays this identity for background regeneration.
+   * Everything else in the contract above still applies.
+   *
+   * The identity drops the user query from the URL and `resolvedUrl`, keeping
+   * framework representation selectors: the `.rsc` suffix, the render mode,
+   * and, for RSC requests only, the one validated `_rsc` value. That is safe only because completed-response
+   * admission refuses a cacheable App page response unless its render proved
+   * it never read `searchParams`. The dispatched request still carries the real
+   * query for the render itself. Core omits the identity when a `next.config`
+   * public cache policy applies (cached per full URL, as Next.js CDN caching
+   * is), and for bypassed, interception, and mounted-slot dispatches.
+   */
+  cacheIdentity?: {
+    props: unknown;
+    request: Request;
+  };
+};
+export type VinextCacheabilityProbeMode = "probe" | "identity";
+/** A durably replayable invocation of a transformed public `"use cache"` function. */
+export type VinextCacheFunctionInvocation = {
+  encryptedArgs: string;
+  referenceId: string;
+  rootParams: Record<string, string | string[]>;
+  softTags: string[];
+};
+/** Trusted route/admission metadata transported independently of user headers. */
+export type VinextResponseStageCacheability = {
+  /** Safe positive next.config policy needed for CDN-level Next.js parity. */
+  policyHeaders: Array<[string, string]> | null;
+  /** Present only after the request stage authenticates an internal probe. */
+  probeMode: VinextCacheabilityProbeMode | null;
+  /** Resolved route pathname used for manifest authorization after outer rewrites. */
+  resolvedRoutePathname: string;
+  /** Trusted representation retained when request-stage normalization changes the URL shape. */
+  representation?: CacheabilityRepresentation;
+};
+/**
+ * Adapter-owned transport from the request stage to the response stage.
+ *
+ * The props and options are serializable stage metadata. An adapter may carry
+ * them over in-process dispatch, platform RPC, a service binding, or HTTP. If
+ * it caches shared dispatches, its baseline identity must include the request
+ * method, complete request URL (including scheme, authority, exact path, and
+ * query), plus the complete serialized props, or the equivalent fields of
+ * `options.cacheIdentity` when core supplies one. An adapter that advertises
+ * `responseVary: "verbatim"` must also partition stored variants by every
+ * request header named in the returned `Vary` fields and reject `Vary: *` from
+ * storage. Adapters without that capability must reject application-defined
+ * variance themselves, or opt into completed-response admission and honor
+ * core's resulting `no-store` policy.
+ *
+ * The transport is also the trust boundary for this metadata. It must
+ * authenticate both directions and integrity-protect the serialized props,
+ * dispatch options, and response so public callers cannot forge trusted route
+ * or cache-admission state. Platform bindings can provide that boundary
+ * directly; HTTP transports need equivalent authenticated, confidential
+ * transport for both request-stage and response-stage endpoints.
+ */
+export type VinextResponseStageTransport<Props = unknown> = (request: Request, props: Props, options: VinextResponseStageDispatchOptions) => Promise<Response>;
+/** Adapter-selected server output for an adapter-owned staged runtime. */
+export type VinextMultiStageOutput = {
+  /** Adapter-owned module that becomes the deployment entry when selected. */
+  entry: string;
+  /** Complete adapter-owned host entries for independently deployable stages. */
+  entries?: {
+    request: string;
+    response: string;
+  };
+  type: "multi-stage";
+  /** Decide whether the current build host supports this adapter's transport. */
+  matchesBuild?: (build: {
+    plugins: readonly {
+      name?: string;
+    }[];
+  }) => boolean;
+  /** Decorate a host entry without exposing transport-specific exports to core. */
+  transformHostEntry?: (module: {
+    code: string;
+    id: string;
+  }) => string | null;
+  /**
+   * Let the adapter finalize host-owned deployment output after it is written.
+   * Core supplies paths only; the adapter owns every platform-specific detail.
+   */
+  finalizeBuildOutput?: (output: {
+    outDir: string;
+    root: string;
+    isPrimaryServerOutput: boolean;
+  }) => Promise<void> | void;
+};
+/** Platform-neutral request-stage handler exposed to deployment adapters. */
+export type VinextRequestStageHandler<Env = unknown, Context = unknown> = (request: Request, env: Env, context: Context, dispatchResponseStage: VinextResponseStageTransport) => Promise<Response>;
+/** Adapter-owned reverse transport from a response stage back through request routing. */
+export type VinextRequestStageTransport = (request: Request) => Promise<Response>;
+/** Adapter-supplied host capability for serving deployment assets. */
+export type VinextAssetFetcher = {
+  fetch(request: Request): Promise<Response> | Response;
+};
+/** Optional host capabilities consumed by a platform-neutral request stage. */
+export type VinextRequestStageContext = {
+  assets?: VinextAssetFetcher;
+};
+/** Platform-neutral response-stage handler exposed to deployment adapters. */
+export type VinextResponseStageHandler<Env = unknown, Context = unknown> = (request: Request, env: Env, context: Context, props: unknown, dispatchRequestStage: VinextRequestStageTransport, options: VinextResponseStageDispatchOptions) => Promise<Response>;
+export type VinextRequestStageModule<Env = unknown, Context = unknown> = {
+  handleRequestStage: VinextRequestStageHandler<Env, Context>;
+};
+export type VinextResponseStageModule<Env = unknown, Context = unknown> = {
+  handleResponseStage: VinextResponseStageHandler<Env, Context>;
+  invokeCacheFunction?: (invocation: VinextCacheFunctionInvocation, env: Env, context: Context, dispatchRequestStage: VinextRequestStageTransport) => Promise<void>;
+};
+//#endregion

package/dist/server/multi-stage.js

@@ -0,0 +1,8 @@
+//#region src/server/multi-stage.ts
+/** Whether a response-stage cache must reject a field it did not key itself by. */
+function hasUnsupportedResponseStageVary(headers, keyedRequestHeaders = []) {
+	const keyedFields = new Set([...keyedRequestHeaders].map((name) => name.trim().toLowerCase()).filter(Boolean));
+	return (headers.get("Vary") ?? "").split(",").map((name) => name.trim().toLowerCase()).filter(Boolean).some((name) => name === "*" || !keyedFields.has(name));
+}
+//#endregion
+export { hasUnsupportedResponseStageVary };

package/dist/server/navigation-planner.d.ts

@@ -5,7 +5,7 @@ import "./app-elements.js";
 import { NavigationTrace, NavigationTraceFields } from "./navigation-trace.js";
 import { OperationLane, OperationToken } from "./operation-token.js";
 //#region src/server/navigation-planner.d.ts
-type RouteSnapshot = {
+export type RouteSnapshot = {
   interception: InterceptionSnapshot | null;
   interceptionContext: string | null;
   routeId: string;
@@ -16,27 +16,27 @@ type RouteSnapshot = {
   matchedUrl: string;
   slotBindings: readonly ParallelSlotBindingSnapshot[];
 };
-type InterceptionSnapshot = {
+export type InterceptionSnapshot = {
   sourceMatchedUrl: string;
   sourceRouteId: string;
   slotId: string;
   targetMatchedUrl: string;
   targetRouteId: string;
 };
-type MountedParallelSlotSnapshot = {
+export type MountedParallelSlotSnapshot = {
   slotId: string;
   ownerLayoutId: string | null;
 };
-type ParallelSlotBindingSnapshot = AppElementsSlotBinding;
-type NavigationPlannerState = {
+export type ParallelSlotBindingSnapshot = AppElementsSlotBinding;
+export type NavigationPlannerState = {
   nextOperationToken: OperationToken;
   traceFields?: NavigationTraceFields;
   visibleCommitVersion: number;
   visibleSnapshot: RouteSnapshot;
 };
-type RefreshScope = "visible";
-type TraverseDirection = "back" | "forward" | "unknown";
-type NavigationEvent = {
+export type RefreshScope = "visible";
+export type TraverseDirection = "back" | "forward" | "unknown";
+export type NavigationEvent = {
   kind: "navigate";
   href: string;
   mode: "push" | "replace";
@@ -77,8 +77,8 @@ type CommitProposal = {
 };
 type NoCommitReason = "prefetchOnly";
 type HardNavigationReason = "cacheProofRejected" | "cacheReuseTokenRejected" | "interceptionProofRejected" | "rootBoundaryChanged";
-type RootBoundaryTransition = "currentRootBoundary" | "rootBoundaryChanged" | "rootBoundaryUnknown";
-type NavigationDecision = {
+export type RootBoundaryTransition = "currentRootBoundary" | "rootBoundaryChanged" | "rootBoundaryUnknown";
+export type NavigationDecision = {
   kind: "requestWork";
   token: OperationToken;
   work: RequestedWork;
@@ -100,14 +100,14 @@ type NavigationDecision = {
   reason: HardNavigationReason;
   trace: NavigationTrace;
 };
-type FlightResult = {
+export type FlightResult = {
   cacheEntryReuseProof?: CacheEntryReuseProof;
   href: string;
   restoredHistorySnapshot?: boolean;
   targetSnapshot: RouteSnapshot;
 };
 type RscFetchResultSource = "cached" | "live";
-type RscFetchResultFacts = {
+export type RscFetchResultFacts = {
   source: RscFetchResultSource;
   currentHref: string;
   origin: string;
@@ -130,7 +130,7 @@ type RscRedirectFollow = {
   redirectDepth: number;
 };
 type RscFetchResultHardNavReason = "invalidRscPayload" | "rscCompatibilityMismatch" | "externalRedirectTarget" | "redirectDepthExhausted" | "streamedRedirectLoop";
-type RscFetchResultDecision = {
+export type RscFetchResultDecision = {
   kind: "proceedToCommit";
   discardBody: false;
   trace: NavigationTrace;
@@ -147,7 +147,7 @@ type RscFetchResultDecision = {
   reason: RscFetchResultHardNavReason;
   trace: NavigationTrace;
 };
-type EarlyNavigationIntentFacts = {
+export type EarlyNavigationIntentFacts = {
   basePath: string;
   currentUrlSpace: "appRelativeSnapshot" | "browser";
   currentHref: string;
@@ -155,7 +155,7 @@ type EarlyNavigationIntentFacts = {
   scroll: boolean;
   targetHref: string;
 };
-type EarlyNavigationIntentDecision = {
+export type EarlyNavigationIntentDecision = {
   kind: "sameDocumentScroll";
   hash: string;
   mode: "push" | "replace";
@@ -167,7 +167,7 @@ type EarlyNavigationIntentDecision = {
   trace: NavigationTrace;
 };
 type NavigationReuseNavigationKind = "navigate" | "refresh" | "traverse";
-type VisitedResponseCacheCandidateFacts = {
+export type VisitedResponseCacheCandidateFacts = {
   candidate: "missing";
   navigationKind: NavigationReuseNavigationKind;
 } | {
@@ -195,7 +195,7 @@ type OptimisticRouteShellCandidateAvailability = {
   status: "unavailable";
   reason: "routeManifestMissing";
 };
-type NavigationReuseFacts = {
+export type NavigationReuseFacts = {
   bypassNavigationCache: boolean;
   navigationKind: NavigationReuseNavigationKind;
   optimisticRouteShell: OptimisticRouteShellCandidateAvailability;
@@ -204,7 +204,7 @@ type NavigationReuseFacts = {
   visitedResponse: NavigationReuseCandidateAvailability;
 };
 type FreshFetchReason = "cacheBypassed" | "cacheMiss" | "refresh" | "routeManifestMissing";
-type NavigationReuseDecision = {
+export type NavigationReuseDecision = {
   kind: "reuseVisitedResponse";
   trace: NavigationTrace;
 } | {
@@ -229,7 +229,7 @@ type NavigationPrefetchProbeDecision = {
   kind: "skip";
   reason: "cacheBypassed" | "refresh" | "visitedResponseAvailable";
 };
-type NavigationPlannerInput = {
+export type NavigationPlannerInput = {
   routeManifest: RouteManifest | null;
   state: NavigationPlannerState;
   event: NavigationEvent;
@@ -256,13 +256,13 @@ declare function resolveCurrentRootBoundaryElementPersistence(currentSnapshot: R
  *
  * Wire absence and UNMATCHED_SLOT markers are not semantic proof.
  */
-declare function resolveDefaultOrUnmatchedSlotPersistenceForLayouts(options: {
+export declare function resolveDefaultOrUnmatchedSlotPersistenceForLayouts(options: {
   currentSlotBindings: readonly ParallelSlotBindingSnapshot[];
   preservedLayoutIds: readonly string[];
   targetSlotBindings: readonly ParallelSlotBindingSnapshot[];
 }): readonly string[];
 declare function planNavigation(input: NavigationPlannerInput): NavigationDecision;
-type ServerActionResultFacts = {
+export type ServerActionResultFacts = {
   actionRedirectHref: string | null;
   actionRedirectType: "push" | "replace";
   clientCompatibilityId: string | null;
@@ -272,7 +272,7 @@ type ServerActionResultFacts = {
   origin: string;
   responseUrl: string | null;
 };
-type ServerActionResultDecision = {
+export type ServerActionResultDecision = {
   kind: "proceed";
   trace: NavigationTrace;
 } | {
@@ -283,10 +283,10 @@ type ServerActionResultDecision = {
   reason: "serverActionRedirectCompatibilityMismatch" | "serverActionRscCompatibilityMismatch";
   trace: NavigationTrace;
 };
-type RscNavigationErrorFacts = {
+export type RscNavigationErrorFacts = {
   currentHref: string;
 };
-type RscNavigationErrorDecision = {
+export type RscNavigationErrorDecision = {
   kind: "hardNavigate";
   url: string;
   reason: "rscNavigationError";
@@ -294,7 +294,7 @@ type RscNavigationErrorDecision = {
 };
 declare function classifyServerActionResult(facts: ServerActionResultFacts): ServerActionResultDecision;
 declare function classifyRscNavigationError(facts: RscNavigationErrorFacts): RscNavigationErrorDecision;
-declare const navigationPlanner: {
+export declare const navigationPlanner: {
   classifyEarlyNavigationIntent: typeof classifyEarlyNavigationIntent;
   classifyNavigationPrefetchProbe: typeof classifyNavigationPrefetchProbe;
   classifyNavigationReuse: typeof classifyNavigationReuse;
@@ -309,4 +309,4 @@ declare const navigationPlanner: {
   resolveSameLayoutAncestorPersistence: typeof resolveSameLayoutAncestorPersistence;
 };
 //#endregion
-export { EarlyNavigationIntentDecision, EarlyNavigationIntentFacts, FlightResult, InterceptionSnapshot, MountedParallelSlotSnapshot, NavigationDecision, NavigationEvent, NavigationPlannerInput, NavigationPlannerState, NavigationReuseDecision, NavigationReuseFacts, type OperationLane, type OperationToken, ParallelSlotBindingSnapshot, RefreshScope, RootBoundaryTransition, RouteSnapshot, RscFetchResultDecision, RscFetchResultFacts, RscNavigationErrorDecision, RscNavigationErrorFacts, ServerActionResultDecision, ServerActionResultFacts, TraverseDirection, VisitedResponseCacheCandidateFacts, navigationPlanner, resolveDefaultOrUnmatchedSlotPersistenceForLayouts };
+export type { OperationLane, OperationToken };

package/dist/server/navigation-trace.d.ts

@@ -1,7 +1,7 @@
 //#region src/server/navigation-trace.d.ts
-declare const NAVIGATION_TRACE_SCHEMA_VERSION = 0;
+export declare const NAVIGATION_TRACE_SCHEMA_VERSION = 0;
 type NavigationTraceSchemaVersion = 0;
-declare const NavigationTraceReasonCodes: {
+export declare const NavigationTraceReasonCodes: {
   cacheProofRejected: "NC_CACHE_REJECT";
   cacheReuseTokenRejected: "NC_CACHE_TOKEN_REJECT";
   commitCurrent: "NC_COMMIT";
@@ -36,26 +36,26 @@ declare const NavigationTraceReasonCodes: {
   streamedRedirectLoop: "NC_RSC_STREAMED_REDIRECT_LOOP";
   visitedResponseReuse: "NC_VISITED_REUSE";
 };
-declare const NavigationTraceTransactionCodes: {
+export declare const NavigationTraceTransactionCodes: {
   hardNavigate: "NT_HARD_NAVIGATE";
   noCommit: "NT_NO_COMMIT";
   visibleCommit: "NT_VISIBLE_COMMIT";
 };
-type NavigationTraceReasonCode = (typeof NavigationTraceReasonCodes)[keyof typeof NavigationTraceReasonCodes];
-type NavigationTraceTransactionCode = (typeof NavigationTraceTransactionCodes)[keyof typeof NavigationTraceTransactionCodes];
+export type NavigationTraceReasonCode = (typeof NavigationTraceReasonCodes)[keyof typeof NavigationTraceReasonCodes];
+export type NavigationTraceTransactionCode = (typeof NavigationTraceTransactionCodes)[keyof typeof NavigationTraceTransactionCodes];
 type NavigationTraceCode = NavigationTraceReasonCode | NavigationTraceTransactionCode;
 type NavigationTraceFieldName = "activeNavigationId" | "cacheProofCode" | "cacheProofMode" | "cacheProofReuseClass" | "cacheProofScope" | "cacheReuseTokenReason" | "currentRootLayoutTreePath" | "currentVisibleCommitVersion" | "nextRootLayoutTreePath" | "eventKind" | "fetchResultSource" | "freshFetchReason" | "operationLane" | "pendingOperationId" | "redirectDepth" | "redirectSignal" | "startedVisibleCommitVersion" | "startedNavigationId" | "targetHref" | "traverseDirection";
 type NavigationTraceFieldValue = string | number | boolean | null;
-type NavigationTraceFields = Readonly<Partial<Record<NavigationTraceFieldName, NavigationTraceFieldValue>>>;
+export type NavigationTraceFields = Readonly<Partial<Record<NavigationTraceFieldName, NavigationTraceFieldValue>>>;
 type NavigationTraceEntry = Readonly<{
   code: NavigationTraceCode;
   fields: NavigationTraceFields;
 }>;
-type NavigationTrace = Readonly<{
+export type NavigationTrace = Readonly<{
   schemaVersion: NavigationTraceSchemaVersion;
   entries: readonly NavigationTraceEntry[];
 }>;
-declare function createNavigationLifecycleTraceFields(options: {
+export declare function createNavigationLifecycleTraceFields(options: {
   activeNavigationId?: number;
   currentRootLayoutTreePath: string | null;
   currentVisibleCommitVersion: number;
@@ -63,7 +63,6 @@ declare function createNavigationLifecycleTraceFields(options: {
   startedNavigationId?: number;
   startedVisibleCommitVersion: number;
 }): NavigationTraceFields;
-declare function createNavigationTrace(code: NavigationTraceCode, fields?: NavigationTraceFields): NavigationTrace;
-declare function prependNavigationTraceEntry(trace: NavigationTrace, code: NavigationTraceCode, fields?: NavigationTraceFields): NavigationTrace;
-//#endregion
-export { NAVIGATION_TRACE_SCHEMA_VERSION, NavigationTrace, NavigationTraceFields, NavigationTraceReasonCode, NavigationTraceReasonCodes, NavigationTraceTransactionCode, NavigationTraceTransactionCodes, createNavigationLifecycleTraceFields, createNavigationTrace, prependNavigationTraceEntry };
+export declare function createNavigationTrace(code: NavigationTraceCode, fields?: NavigationTraceFields): NavigationTrace;
+export declare function prependNavigationTraceEntry(trace: NavigationTrace, code: NavigationTraceCode, fields?: NavigationTraceFields): NavigationTrace;
+//#endregion

package/dist/server/next-error-digest.d.ts

@@ -8,7 +8,7 @@ type NextHttpErrorDigest = {
  * Pulls a stringified `digest` off an unknown thrown value, or returns null
  * when the value is not a digest-bearing error.
  */
-declare function getNextErrorDigest(error: unknown): string | null;
+export declare function getNextErrorDigest(error: unknown): string | null;
 /**
  * Parses redirect digests from vinext's encoded three-part form and Next.js's
  * raw, semicolon-terminated form. Returns null when the digest is not a
@@ -17,12 +17,11 @@ declare function getNextErrorDigest(error: unknown): string | null;
  * 307 when omitted; an omitted `type` is left as null so the caller can apply
  * the correct context-sensitive default.
  */
-declare function parseNextRedirectDigest(digest: string): NextRedirectDigest | null;
+export declare function parseNextRedirectDigest(digest: string): NextRedirectDigest | null;
 /**
  * Parses a `NEXT_NOT_FOUND` or `NEXT_HTTP_ERROR_FALLBACK;<status>` digest.
  * Returns `{ status: 404 }` for `NEXT_NOT_FOUND` and the parsed status code
  * for the fallback form. Returns null otherwise.
  */
-declare function parseNextHttpErrorDigest(digest: string): NextHttpErrorDigest | null;
-//#endregion
-export { getNextErrorDigest, parseNextHttpErrorDigest, parseNextRedirectDigest };
+export declare function parseNextHttpErrorDigest(digest: string): NextHttpErrorDigest | null;
+//#endregion

package/dist/server/normalize-path.d.ts

@@ -1,5 +1,5 @@
 //#region src/server/normalize-path.d.ts
-declare function escapePathDelimiters(segment: string, escapeEncoded?: boolean): string;
+export declare function escapePathDelimiters(segment: string, escapeEncoded?: boolean): string;
 /**
  * Decode a URL pathname segment-by-segment, preserving encoded path delimiters.
  * Non-ASCII characters (e.g. %C3%A9 -> e) are decoded, but structural characters
@@ -11,8 +11,8 @@ declare function escapePathDelimiters(segment: string, escapeEncoded?: boolean):
  * Ported from Next.js: packages/next/src/server/lib/router-utils/decode-path-params.ts
  * https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-utils/decode-path-params.ts
  */
-declare function decodePathParams(pathname: string): string;
-declare function isInterceptionMatchedUrlPath(value: string): boolean;
+export declare function decodePathParams(pathname: string): string;
+export declare function isInterceptionMatchedUrlPath(value: string): boolean;
 /**
  * Path normalization utility for request handling.
  *
@@ -33,6 +33,5 @@ declare function isInterceptionMatchedUrlPath(value: string): boolean;
  *  - Decode percent-encoded characters (callers should decode before calling this)
  *  - Lowercase the path (route matching is case-sensitive)
  */
-declare function normalizePath(pathname: string): string;
-//#endregion
-export { decodePathParams, escapePathDelimiters, isInterceptionMatchedUrlPath, normalizePath };
+export declare function normalizePath(pathname: string): string;
+//#endregion

package/dist/server/normalize-path.js

@@ -33,7 +33,7 @@ function decodePathParams(pathname) {
 	}).join("/");
 }
 function isInterceptionMatchedUrlPath(value) {
-	return value.startsWith("/") && !value.startsWith("//") && !value.includes("?") && !value.includes("#") && !value.includes("\0");
+	return value.startsWith("/") && !value.startsWith("//") && !value.includes("?") && !value.includes("#") && !value.includes("\\") && !value.includes("\0");
 }
 /**
 * Path normalization utility for request handling.

package/dist/server/open-redirect.d.ts

@@ -7,6 +7,5 @@
  * after decoding backslashes and encoded delimiters, would cause a browser
  * to resolve a `Location` containing the pathname as protocol-relative.
  */
-declare function isOpenRedirectShaped(rawPathname: string): boolean;
-//#endregion
-export { isOpenRedirectShaped };
+export declare function isOpenRedirectShaped(rawPathname: string): boolean;
+//#endregion