vinext 1.0.0-beta.9 → 1.0.1

package/dist/server/middleware-matcher-pattern.d.ts

@@ -1,6 +1,6 @@
 import { HasCondition } from "../config/next-config.js";
 //#region src/server/middleware-matcher-pattern.d.ts
-type CompiledMiddlewareMatcherPattern = {
+export type CompiledMiddlewareMatcherPattern = {
   regexp: RegExp;
   error?: never;
 } | {
@@ -8,14 +8,13 @@ type CompiledMiddlewareMatcherPattern = {
   error: string;
   kind: "invalid" | "unsafe";
 };
-type MiddlewareMatcherObject = {
+export type MiddlewareMatcherObject = {
   source: string;
   locale?: false;
   has?: HasCondition[];
   missing?: HasCondition[];
 };
-declare function isValidMiddlewareMatcherObjectConfig(value: unknown): value is MiddlewareMatcherObject;
-declare function compileMiddlewareMatcherPattern(source: string): CompiledMiddlewareMatcherPattern;
-declare function validateMiddlewareMatcherPatterns(value: unknown): void;
-//#endregion
-export { CompiledMiddlewareMatcherPattern, MiddlewareMatcherObject, compileMiddlewareMatcherPattern, isValidMiddlewareMatcherObjectConfig, validateMiddlewareMatcherPatterns };
+export declare function isValidMiddlewareMatcherObjectConfig(value: unknown): value is MiddlewareMatcherObject;
+export declare function compileMiddlewareMatcherPattern(source: string): CompiledMiddlewareMatcherPattern;
+export declare function validateMiddlewareMatcherPatterns(value: unknown): void;
+//#endregion

package/dist/server/middleware-matcher.d.ts

@@ -1,14 +1,14 @@
 import { NextI18nConfig } from "../config/next-config.js";
 import { MiddlewareMatcherObject } from "./middleware-matcher-pattern.js";
 //#region src/server/middleware-matcher.d.ts
-type MatcherConfig = string | Array<string | MiddlewareMatcherObject>;
-type MiddlewareLocaleMatchContext = {
+export type MatcherConfig = string | Array<string | MiddlewareMatcherObject>;
+export type MiddlewareLocaleMatchContext = {
   kind: "defaulted";
   defaultLocale: string;
 } | {
   kind: "internal" | "literal";
 };
-declare function matchesMiddleware(pathname: string, matcher: MatcherConfig | undefined, request?: Request, i18nConfig?: NextI18nConfig | null, localeContext?: MiddlewareLocaleMatchContext): boolean;
+export declare function matchesMiddleware(pathname: string, matcher: MatcherConfig | undefined, request?: Request, i18nConfig?: NextI18nConfig | null, localeContext?: MiddlewareLocaleMatchContext): boolean;
 /**
  * Whether a pathname can reach middleware, ignoring request-specific
  * `has`/`missing` conditions. This is deliberately separate from
@@ -16,7 +16,6 @@ declare function matchesMiddleware(pathname: string, matcher: MatcherConfig | un
  * full request, while cacheability certification needs a stable answer for
  * every request that can share the pathname's cache entry.
  */
-declare function matchesMiddlewarePathname(pathname: string, matcher: MatcherConfig | undefined, i18nConfig?: NextI18nConfig | null, localeContext?: MiddlewareLocaleMatchContext): boolean;
-declare function matchPattern(pathname: string, pattern: string): boolean;
-//#endregion
-export { MatcherConfig, MiddlewareLocaleMatchContext, matchPattern, matchesMiddleware, matchesMiddlewarePathname };
+export declare function matchesMiddlewarePathname(pathname: string, matcher: MatcherConfig | undefined, i18nConfig?: NextI18nConfig | null, localeContext?: MiddlewareLocaleMatchContext): boolean;
+export declare function matchPattern(pathname: string, pattern: string): boolean;
+//#endregion

package/dist/server/middleware-path-to-regexp.d.ts

@@ -1,14 +1,13 @@
 //#region src/server/middleware-path-to-regexp.d.ts
-type MiddlewarePathToken = string | MiddlewarePathKey;
-type MiddlewarePathKey = {
+export type MiddlewarePathToken = string | MiddlewarePathKey;
+export type MiddlewarePathKey = {
   name: string | number;
   prefix: string;
   suffix: string;
   pattern: string;
   modifier: string;
 };
-declare function parseMiddlewarePath(value: string): MiddlewarePathToken[];
-declare function normalizeMiddlewarePathTokens(tokens: MiddlewarePathToken[]): MiddlewarePathToken[];
-declare function middlewarePathTokensToRegExp(tokens: MiddlewarePathToken[]): RegExp;
-//#endregion
-export { MiddlewarePathKey, MiddlewarePathToken, middlewarePathTokensToRegExp, normalizeMiddlewarePathTokens, parseMiddlewarePath };
+export declare function parseMiddlewarePath(value: string): MiddlewarePathToken[];
+export declare function normalizeMiddlewarePathTokens(tokens: MiddlewarePathToken[]): MiddlewarePathToken[];
+export declare function middlewarePathTokensToRegExp(tokens: MiddlewarePathToken[]): RegExp;
+//#endregion

package/dist/server/middleware-path-to-regexp.js

@@ -211,15 +211,17 @@ function middlewarePathTokensToRegExp(tokens) {
 		}
 		const prefix = escapeRegex(token.prefix);
 		const suffix = escapeRegex(token.suffix);
-		if (token.pattern) if (prefix || suffix) if (token.modifier === "+" || token.modifier === "*") {
-			const optional = token.modifier === "*" ? "?" : "";
-			route += `(?:${prefix}((?:${token.pattern})(?:${suffix}${prefix}(?:${token.pattern}))*)${suffix})${optional}`;
-		} else route += `(?:${prefix}(${token.pattern})${suffix})${token.modifier}`;
-		else {
-			if (token.modifier === "+" || token.modifier === "*") throw new TypeError(`Can not repeat "${token.name}" without a prefix and suffix`);
-			route += `(${token.pattern})${token.modifier}`;
-		}
-		else route += `(?:${prefix}${suffix})${token.modifier}`;
+		if (token.pattern) {
+			if (prefix || suffix) {
+				if (token.modifier === "+" || token.modifier === "*") {
+					const optional = token.modifier === "*" ? "?" : "";
+					route += `(?:${prefix}((?:${token.pattern})(?:${suffix}${prefix}(?:${token.pattern}))*)${suffix})${optional}`;
+				} else route += `(?:${prefix}(${token.pattern})${suffix})${token.modifier}`;
+			} else {
+				if (token.modifier === "+" || token.modifier === "*") throw new TypeError(`Can not repeat "${token.name}" without a prefix and suffix`);
+				route += `(${token.pattern})${token.modifier}`;
+			}
+		} else route += `(?:${prefix}${suffix})${token.modifier}`;
 	}
 	route += `${delimiterRegex}?$`;
 	return new RegExp(route, "i");

package/dist/server/middleware-response-headers.d.ts

@@ -1,5 +1,5 @@
 //#region src/server/middleware-response-headers.d.ts
-declare function mergeVaryHeader(target: Headers, value: string): void;
+export declare function mergeVaryHeader(target: Headers, value: string): void;
 /**
  * Merge middleware response headers into a target Headers object.
  *
@@ -7,6 +7,5 @@ declare function mergeVaryHeader(target: Headers, value: string): void;
  * contribute values. All other headers use set() so middleware owns singular
  * response headers like Cache-Control.
  */
-declare function mergeMiddlewareResponseHeaders(target: Headers, middlewareHeaders: Headers | null): void;
-//#endregion
-export { mergeMiddlewareResponseHeaders, mergeVaryHeader };
+export declare function mergeMiddlewareResponseHeaders(target: Headers, middlewareHeaders: Headers | null): void;
+//#endregion

package/dist/server/middleware-runtime.d.ts

@@ -2,8 +2,8 @@ import { NextI18nConfig } from "../config/next-config.js";
 import { ExecutionContextLike } from "../shims/request-context.js";
 import { NextFetchEvent, NextRequest } from "../shims/server.js";
 //#region src/server/middleware-runtime.d.ts
-type MiddlewareModule = Record<string, unknown>;
-type MiddlewareResult = {
+export type MiddlewareModule = Record<string, unknown>;
+export type MiddlewareResult = {
   continue: boolean;
   /** True when this pathname can match middleware for some request context. */
   pathnameEligible?: boolean;
@@ -67,12 +67,11 @@ type ExecuteMiddlewareOptions = {
 type RunGeneratedMiddlewareOptions = ExecuteMiddlewareOptions & {
   ctx?: ExecutionContextLike;
 };
-declare function createMiddlewareMissingExportError(filePath: string | undefined, isProxy: boolean): Error;
-declare function resolveMiddlewareModuleHandler(mod: MiddlewareModule, options: {
+export declare function createMiddlewareMissingExportError(filePath: string | undefined, isProxy: boolean): Error;
+export declare function resolveMiddlewareModuleHandler(mod: MiddlewareModule, options: {
   filePath?: string;
   isProxy: boolean;
 }): MiddlewareHandler;
-declare function executeMiddleware(options: ExecuteMiddlewareOptions): Promise<MiddlewareResult>;
-declare function runGeneratedMiddleware(options: RunGeneratedMiddlewareOptions): Promise<MiddlewareResult>;
-//#endregion
-export { MiddlewareModule, MiddlewareResult, createMiddlewareMissingExportError, executeMiddleware, resolveMiddlewareModuleHandler, runGeneratedMiddleware };
+export declare function executeMiddleware(options: ExecuteMiddlewareOptions): Promise<MiddlewareResult>;
+export declare function runGeneratedMiddleware(options: RunGeneratedMiddlewareOptions): Promise<MiddlewareResult>;
+//#endregion

package/dist/server/middleware-runtime.js

@@ -1,12 +1,12 @@
 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 { getRequestExecutionContext, runWithExecutionContext } from "../shims/request-context.js";
 import "./server-globals.js";
-import { normalizeHost } from "../config/request-context.js";
-import "../utils/protocol-headers.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, matchesMiddlewarePathname } from "./middleware-matcher.js";
@@ -14,7 +14,23 @@ import { badRequestResponse, internalServerErrorResponse } from "./http-error-re
 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";
 }
@@ -202,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
 		};
 	}
@@ -240,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);

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 };