@qzsy/vinext 0.1.7

package/dist/server/app-layout-param-observation.js

@@ -0,0 +1,168 @@
+import { isInsideUnifiedScope, runWithUnifiedStateMutation } from "../shims/unified-request-context.js";
+import { peekDynamicUsage, peekRenderRequestApiUsage } from "../shims/headers.js";
+import { _peekRequestScopedCacheLife, _peekUnstableCacheObservations } from "../shims/cache-request-state.js";
+import { getCollectedFetchTags, peekCacheableFetchObservations, peekDynamicFetchObservations } from "../shims/fetch-cache.js";
+import { isPromiseLike } from "../utils/promise.js";
+//#region src/server/app-layout-param-observation.ts
+const STATIC_LAYOUT_OBSERVATION_SKIP_RULES = [
+	["SKIP_LAYOUT_PARAMS_OBSERVATION_INCOMPLETE", (observation) => observation.completeness !== "complete"],
+	["SKIP_LAYOUT_PARAMS_PRESENT", (observation) => observation.paramScopeKeys.length > 0],
+	["SKIP_LAYOUT_PARAMS_OBSERVED", (observation) => observation.observed],
+	["SKIP_LAYOUT_DYNAMIC_USAGE_OBSERVED", (observation) => observation.dynamicUsageObserved],
+	["SKIP_LAYOUT_REQUEST_API_OBSERVED", (observation) => observation.requestApis.length > 0],
+	["SKIP_LAYOUT_REVALIDATE_PRESENT", (observation) => observation.finiteRevalidateSeconds !== null],
+	["SKIP_LAYOUT_CACHE_LIFE_OBSERVED", (observation) => observation.cacheLifeObserved],
+	["SKIP_LAYOUT_UNSTABLE_CACHE_OBSERVED", (observation) => observation.unstableCaches.length > 0],
+	["SKIP_LAYOUT_CACHE_TAGS_OBSERVED", (observation) => observation.cacheTags.length > 0],
+	["SKIP_LAYOUT_CACHEABLE_FETCHES_OBSERVED", (observation) => observation.cacheableFetchCount > 0],
+	["SKIP_LAYOUT_DYNAMIC_FETCHES_OBSERVED", (observation) => observation.dynamicFetchCount > 0]
+];
+function createStaticLayoutObservationTraceFields(observation) {
+	return {
+		cacheLifeObserved: observation.cacheLifeObserved,
+		cacheTags: observation.cacheTags,
+		cacheableFetchCount: observation.cacheableFetchCount,
+		dynamicFetchCount: observation.dynamicFetchCount,
+		dynamicUsageObserved: observation.dynamicUsageObserved,
+		finiteRevalidateSeconds: observation.finiteRevalidateSeconds,
+		observedParamKeys: observation.keys,
+		paramScopeKeys: observation.paramScopeKeys,
+		requestApis: observation.requestApis,
+		unstableCacheCount: observation.unstableCaches.length,
+		unstableCacheKeyHashes: observation.unstableCaches.map((cache) => cache.keyHash),
+		unstableCacheRevalidates: observation.unstableCaches.map((cache) => String(cache.revalidate)),
+		unstableCacheTagCounts: observation.unstableCaches.map((cache) => String(cache.tagCount)),
+		unstableCacheTagHashes: observation.unstableCaches.map((cache) => cache.tagHash ?? "none")
+	};
+}
+function getStaticLayoutObservationSkipRejection(observation) {
+	for (const [code, matches] of STATIC_LAYOUT_OBSERVATION_SKIP_RULES) if (matches(observation)) return {
+		code,
+		fields: createStaticLayoutObservationTraceFields(observation)
+	};
+	return null;
+}
+function isAppLayoutObservationUnsafeForStaticReuse(observation) {
+	return getStaticLayoutObservationSkipRejection(observation) !== null;
+}
+function createAppLayoutParamAccessTracker() {
+	const observations = /* @__PURE__ */ new Map();
+	const ensureObservation = (layoutId) => {
+		const existing = observations.get(layoutId);
+		if (existing) return existing;
+		const created = {
+			cacheLifeObserved: false,
+			cacheTags: /* @__PURE__ */ new Set(),
+			cacheableFetches: /* @__PURE__ */ new Set(),
+			dynamicFetches: /* @__PURE__ */ new Set(),
+			dynamicUsageObserved: false,
+			finiteRevalidateSeconds: null,
+			keys: /* @__PURE__ */ new Set(),
+			observed: false,
+			paramScopeKeys: /* @__PURE__ */ new Set(),
+			probeComplete: false,
+			requestApis: /* @__PURE__ */ new Set(),
+			unstableCaches: /* @__PURE__ */ new Map()
+		};
+		observations.set(layoutId, created);
+		return created;
+	};
+	const markObserved = (layoutId, keys) => {
+		const observation = ensureObservation(layoutId);
+		observation.observed = true;
+		for (const key of keys) observation.keys.add(key);
+	};
+	const markProbeComplete = (layoutId) => {
+		ensureObservation(layoutId).probeComplete = true;
+	};
+	const runWithIsolatedProbeDependencies = (probe) => {
+		if (!isInsideUnifiedScope()) return probe();
+		return runWithUnifiedStateMutation((ctx) => {
+			ctx.cacheableFetchUrls = /* @__PURE__ */ new Set();
+			ctx.currentRequestTags = [];
+			ctx.currentFetchSoftTags = [];
+			ctx.dynamicFetchUrls = /* @__PURE__ */ new Set();
+			ctx.dynamicUsageDetected = false;
+			ctx.renderRequestApiUsage = /* @__PURE__ */ new Set();
+			ctx.requestScopedCacheLife = null;
+			ctx.unstableCacheObservations = /* @__PURE__ */ new Map();
+		}, probe);
+	};
+	const recordProbeDependencies = (layoutId) => {
+		const observation = ensureObservation(layoutId);
+		if (peekDynamicUsage()) observation.dynamicUsageObserved = true;
+		if (_peekRequestScopedCacheLife() !== null) observation.cacheLifeObserved = true;
+		for (const tag of getCollectedFetchTags()) observation.cacheTags.add(tag);
+		for (const url of peekCacheableFetchObservations()) observation.cacheableFetches.add(url);
+		for (const url of peekDynamicFetchObservations()) observation.dynamicFetches.add(url);
+		for (const requestApi of peekRenderRequestApiUsage()) observation.requestApis.add(requestApi);
+		for (const unstableCache of _peekUnstableCacheObservations()) observation.unstableCaches.set(unstableCache.keyHash, unstableCache);
+	};
+	return {
+		createThenableParamsObserver(layoutId) {
+			return { observeParamAccess(keys) {
+				markObserved(layoutId, keys);
+			} };
+		},
+		getLayoutObservation(layoutId) {
+			const observation = observations.get(layoutId);
+			if (!observation) return {
+				cacheLifeObserved: false,
+				cacheTags: [],
+				cacheableFetchCount: 0,
+				completeness: "unknown",
+				dynamicFetchCount: 0,
+				dynamicUsageObserved: false,
+				finiteRevalidateSeconds: null,
+				keys: [],
+				observed: false,
+				paramScopeKeys: [],
+				requestApis: [],
+				unstableCaches: []
+			};
+			return {
+				cacheLifeObserved: observation.cacheLifeObserved,
+				cacheTags: [...observation.cacheTags].sort(),
+				cacheableFetchCount: observation.cacheableFetches.size,
+				completeness: observation.probeComplete ? "complete" : "unknown",
+				dynamicFetchCount: observation.dynamicFetches.size,
+				dynamicUsageObserved: observation.dynamicUsageObserved,
+				finiteRevalidateSeconds: observation.finiteRevalidateSeconds,
+				keys: [...observation.keys].sort(),
+				observed: observation.observed,
+				paramScopeKeys: [...observation.paramScopeKeys].sort(),
+				requestApis: [...observation.requestApis].sort(),
+				unstableCaches: [...observation.unstableCaches.values()].sort((a, b) => a.keyHash.localeCompare(b.keyHash))
+			};
+		},
+		recordLayoutFiniteRevalidate(layoutId, revalidateSeconds) {
+			if (!Number.isFinite(revalidateSeconds) || revalidateSeconds <= 0) return;
+			const observation = ensureObservation(layoutId);
+			observation.finiteRevalidateSeconds = observation.finiteRevalidateSeconds === null ? revalidateSeconds : Math.min(observation.finiteRevalidateSeconds, revalidateSeconds);
+		},
+		recordLayoutParamScope(layoutId, paramScopeKeys) {
+			const observation = ensureObservation(layoutId);
+			for (const key of paramScopeKeys) observation.paramScopeKeys.add(key);
+		},
+		runLayoutProbe(layoutId, probe) {
+			return runWithIsolatedProbeDependencies(() => {
+				const result = probe();
+				if (!isPromiseLike(result)) {
+					recordProbeDependencies(layoutId);
+					markProbeComplete(layoutId);
+					return result;
+				}
+				return Promise.resolve(result).then((resolved) => {
+					recordProbeDependencies(layoutId);
+					markProbeComplete(layoutId);
+					return resolved;
+				}, (error) => {
+					recordProbeDependencies(layoutId);
+					throw error;
+				});
+			});
+		}
+	};
+}
+//#endregion
+export { createAppLayoutParamAccessTracker, getStaticLayoutObservationSkipRejection, isAppLayoutObservationUnsafeForStaticReuse };

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

@@ -0,0 +1,46 @@
+import { NextI18nConfig } from "../config/next-config.js";
+import { MiddlewareModule } from "./middleware-runtime.js";
+import { FLIGHT_HEADERS } from "./headers.js";
+
+//#region src/server/app-middleware.d.ts
+type AppMiddlewareContext = {
+  headers: Headers | null;
+  requestHeaders: Headers | null;
+  status: number | null;
+};
+type ApplyAppMiddlewareOptions = {
+  basePath?: string;
+  cleanPathname: string;
+  context: AppMiddlewareContext;
+  i18nConfig?: NextI18nConfig | null;
+  /**
+   * Whether the inbound request was a `_next/data` fetch. Captured from the
+   * raw incoming headers by the caller, because `x-nextjs-data` is in
+   * INTERNAL_HEADERS and is stripped before this function runs.
+   */
+  isDataRequest?: boolean;
+  filePath?: string;
+  isProxy: boolean;
+  module: MiddlewareModule;
+  request: Request;
+  /**
+   * Forwarded to `executeMiddleware` so the NextRequest exposes a NextURL with
+   * the configured trailingSlash policy. This is what makes
+   * `NextResponse.redirect(request.nextUrl)` emit a Location that honours
+   * `trailingSlash`.
+   */
+  trailingSlash?: boolean;
+};
+type ApplyAppMiddlewareResult = {
+  kind: "continue";
+  cleanPathname: string;
+  search: string | null;
+} | {
+  kind: "response";
+  response: Response;
+};
+declare function isExternalMiddlewareRewrite(rewriteUrl: string, request: Request): boolean;
+declare function proxyExternalMiddlewareRewrite(request: Request, rewriteUrl: string, context: AppMiddlewareContext): Promise<Response>;
+declare function applyAppMiddleware(options: ApplyAppMiddlewareOptions): Promise<ApplyAppMiddlewareResult>;
+//#endregion
+export { AppMiddlewareContext, ApplyAppMiddlewareOptions, ApplyAppMiddlewareResult, FLIGHT_HEADERS, applyAppMiddleware, isExternalMiddlewareRewrite, proxyExternalMiddlewareRewrite };

package/dist/server/app-middleware.js

@@ -0,0 +1,168 @@
+import { FLIGHT_HEADERS, VINEXT_MW_CTX_HEADER } from "./headers.js";
+import { buildRequestHeadersFromMiddlewareResponse } from "./middleware-request-headers.js";
+import { isExternalUrl, proxyExternalRequest } from "../config/config-matchers.js";
+import { internalServerErrorResponse } from "./http-error-responses.js";
+import { cloneRequestWithHeaders, processMiddlewareHeaders } from "./request-pipeline.js";
+import { executeMiddleware } from "./middleware-runtime.js";
+import { applyMiddlewareRequestHeaders, setHeadersContext } from "../shims/headers.js";
+import { setNavigationContext } from "../shims/navigation-context-state.js";
+import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import "../shims/navigation.js";
+//#region src/server/app-middleware.ts
+const FLIGHT_HEADER_SET = new Set(FLIGHT_HEADERS);
+function isForwardedMiddlewareContext(value) {
+	return !!value && typeof value === "object";
+}
+function requestWithoutFlightHeaders(request) {
+	let hasFlightHeader = false;
+	const headers = new Headers();
+	for (const [key, value] of request.headers) if (FLIGHT_HEADER_SET.has(key.toLowerCase())) hasFlightHeader = true;
+	else headers.append(key, value);
+	if (!hasFlightHeader) return request;
+	return cloneRequestWithHeaders(request.body ? request.clone() : request, headers);
+}
+function appendForwardedHeader(headers, value) {
+	if (!Array.isArray(value) || value.length < 2) return;
+	const key = value[0];
+	const headerValue = value[1];
+	if (typeof key === "string" && typeof headerValue === "string") headers.append(key, headerValue);
+}
+function responseFromMiddlewareRedirect(result) {
+	if (result.response) return result.response;
+	const headers = new Headers(result.responseHeaders);
+	if (result.redirectUrl) headers.set("Location", result.redirectUrl);
+	return new Response(null, {
+		status: result.redirectStatus ?? 307,
+		headers
+	});
+}
+function isExternalMiddlewareRewrite(rewriteUrl, request) {
+	return new URL(rewriteUrl, request.url).origin !== new URL(request.url).origin;
+}
+function requestWithMiddlewareRequestHeaders(request, middlewareHeaders) {
+	const nextHeaders = middlewareHeaders ? buildRequestHeadersFromMiddlewareResponse(request.headers, middlewareHeaders, { preserveCredentialHeaders: true }) : null;
+	if (!nextHeaders) return request;
+	const init = {
+		method: request.method,
+		headers: nextHeaders,
+		body: request.body
+	};
+	if (request.body) Object.defineProperty(init, "duplex", {
+		value: "half",
+		enumerable: true
+	});
+	return new Request(request.url, init);
+}
+async function proxyExternalMiddlewareRewrite(request, rewriteUrl, context) {
+	const proxyRequest = requestWithMiddlewareRequestHeaders(request, context.requestHeaders ?? context.headers);
+	setHeadersContext(null);
+	setNavigationContext(null);
+	const proxyResponse = await proxyExternalRequest(proxyRequest, rewriteUrl);
+	const headers = new Headers(proxyResponse.headers);
+	processMiddlewareHeaders(headers);
+	if (!context.headers) return new Response(proxyResponse.body, {
+		status: proxyResponse.status,
+		statusText: proxyResponse.statusText,
+		headers
+	});
+	const middlewareHeaders = new Headers(context.headers);
+	processMiddlewareHeaders(middlewareHeaders);
+	mergeMiddlewareResponseHeaders(headers, middlewareHeaders);
+	return new Response(proxyResponse.body, {
+		status: proxyResponse.status,
+		statusText: proxyResponse.statusText,
+		headers
+	});
+}
+function applyForwardedMiddlewareContext(request, context) {
+	if (process.env.NODE_ENV === "production") return { applied: false };
+	const header = request.headers.get(VINEXT_MW_CTX_HEADER);
+	if (!header) return { applied: false };
+	try {
+		const data = JSON.parse(header);
+		if (!isForwardedMiddlewareContext(data)) return { applied: false };
+		if (Array.isArray(data.h) && data.h.length > 0) {
+			context.headers = new Headers();
+			for (const entry of data.h) appendForwardedHeader(context.headers, entry);
+		}
+		if (typeof data.s === "number") context.status = data.s;
+		if (typeof data.r === "string" && data.r.length > 0) return {
+			applied: true,
+			rewriteUrl: data.r
+		};
+		return { applied: true };
+	} catch (e) {
+		console.error("[vinext] Failed to parse forwarded middleware context:", e);
+		return { applied: false };
+	}
+}
+async function applyAppMiddleware(options) {
+	const forwarded = applyForwardedMiddlewareContext(options.request, options.context);
+	const middlewareRequest = requestWithoutFlightHeaders(options.request);
+	let cleanPathname = options.cleanPathname;
+	let search = null;
+	if (forwarded.rewriteUrl) try {
+		if (isExternalMiddlewareRewrite(forwarded.rewriteUrl, middlewareRequest)) return {
+			kind: "response",
+			response: await proxyExternalMiddlewareRewrite(middlewareRequest, forwarded.rewriteUrl, options.context)
+		};
+		const rewriteParsed = new URL(forwarded.rewriteUrl, middlewareRequest.url);
+		cleanPathname = rewriteParsed.pathname;
+		search = rewriteParsed.search;
+	} catch (e) {
+		console.error("[vinext] Failed to apply forwarded middleware rewrite:", e);
+		forwarded.applied = false;
+	}
+	if (!forwarded.applied) {
+		const result = await executeMiddleware({
+			basePath: options.basePath,
+			hadBasePath: true,
+			filePath: options.filePath,
+			i18nConfig: options.i18nConfig,
+			isDataRequest: options.isDataRequest,
+			isProxy: options.isProxy,
+			module: options.module,
+			normalizedPathname: cleanPathname,
+			request: middlewareRequest,
+			trailingSlash: options.trailingSlash
+		});
+		if (!result.continue) {
+			if (result.redirectUrl) return {
+				kind: "response",
+				response: responseFromMiddlewareRedirect(result)
+			};
+			if (result.response) return {
+				kind: "response",
+				response: result.response
+			};
+			return {
+				kind: "response",
+				response: internalServerErrorResponse()
+			};
+		}
+		if (result.responseHeaders) options.context.headers = new Headers(result.responseHeaders);
+		if (result.status !== void 0) options.context.status = result.status;
+		if (result.rewriteUrl) {
+			if (result.rewriteStatus !== void 0) options.context.status = result.rewriteStatus;
+			if (isExternalUrl(result.rewriteUrl)) return {
+				kind: "response",
+				response: await proxyExternalMiddlewareRewrite(middlewareRequest, result.rewriteUrl, options.context)
+			};
+			const rewriteParsed = new URL(result.rewriteUrl, middlewareRequest.url);
+			cleanPathname = rewriteParsed.pathname;
+			search = rewriteParsed.search;
+		}
+	}
+	if (options.context.headers) {
+		options.context.requestHeaders = new Headers(options.context.headers);
+		applyMiddlewareRequestHeaders(options.context.headers);
+		processMiddlewareHeaders(options.context.headers);
+	}
+	return {
+		kind: "continue",
+		cleanPathname,
+		search
+	};
+}
+//#endregion
+export { FLIGHT_HEADERS, applyAppMiddleware, isExternalMiddlewareRewrite, proxyExternalMiddlewareRewrite };

package/dist/server/app-mounted-slots-header.d.ts

@@ -0,0 +1,35 @@
+//#region src/server/app-mounted-slots-header.d.ts
+/**
+ * Normalize the `x-vinext-mounted-slots` header for request handling and cache keying.
+ *
+ * The browser sends mounted slot ids as a space-separated list in the order slots were
+ * rendered, which changes across navigations. This normalizes to a canonical form
+ * (sorted, deduplicated) so equivalent slot sets map to the same RSC cache entry.
+ *
+ * Security: the value flows into the ISR RSC cache key (`appIsrRscKey`). Without
+ * bounds, an attacker who controls this header can fabricate unbounded distinct
+ * values to fan out KV writes (per-write billing) or fragment the cache. See
+ * `SECURITY-AUDIT-2026-05.md` finding F-PROD-1. The legitimate wire format is a
+ * whitespace-separated list of `slot:<name>:<treePath>` tokens (see
+ * `createAppPayloadSlotId` in `app-elements-wire.ts`); anything else is rejected.
+ *
+ * Bounds applied:
+ *   - Total raw header value capped at MAX_RAW_HEADER_LENGTH bytes (returns null
+ *     if exceeded so the request is treated as if the header were absent).
+ *   - Each token capped at MAX_TOKEN_LENGTH bytes.
+ *   - Token count capped at MAX_SLOT_TOKENS (extras are dropped after sort + dedup).
+ *   - Each token must match the legitimate slot-id shape, as defined by the
+ *     AppElements wire codec (`AppElementsWire.isSlotId`). Wire-format details
+ *     are intentionally kept inside the codec so this module does not duplicate
+ *     them. Malformed tokens are dropped silently rather than rejecting the
+ *     whole request — this matches the prior forgiving behavior for browsers
+ *     that send legitimate but stale formats during rolling deploys.
+ *
+ * Consumed by:
+ *   - app-rsc-request-normalization (request lifecycle, reads incoming header)
+ *   - app-elements (outgoing x-vinext-mounted-slots construction)
+ *   - isr-cache (RSC cache key generation)
+ */
+declare function normalizeMountedSlotsHeader(raw: string | null | undefined): string | null;
+//#endregion
+export { normalizeMountedSlotsHeader };

package/dist/server/app-mounted-slots-header.js

@@ -0,0 +1,58 @@
+import { AppElementsWire } from "./app-elements-wire.js";
+//#region src/server/app-mounted-slots-header.ts
+/**
+* Normalize the `x-vinext-mounted-slots` header for request handling and cache keying.
+*
+* The browser sends mounted slot ids as a space-separated list in the order slots were
+* rendered, which changes across navigations. This normalizes to a canonical form
+* (sorted, deduplicated) so equivalent slot sets map to the same RSC cache entry.
+*
+* Security: the value flows into the ISR RSC cache key (`appIsrRscKey`). Without
+* bounds, an attacker who controls this header can fabricate unbounded distinct
+* values to fan out KV writes (per-write billing) or fragment the cache. See
+* `SECURITY-AUDIT-2026-05.md` finding F-PROD-1. The legitimate wire format is a
+* whitespace-separated list of `slot:<name>:<treePath>` tokens (see
+* `createAppPayloadSlotId` in `app-elements-wire.ts`); anything else is rejected.
+*
+* Bounds applied:
+*   - Total raw header value capped at MAX_RAW_HEADER_LENGTH bytes (returns null
+*     if exceeded so the request is treated as if the header were absent).
+*   - Each token capped at MAX_TOKEN_LENGTH bytes.
+*   - Token count capped at MAX_SLOT_TOKENS (extras are dropped after sort + dedup).
+*   - Each token must match the legitimate slot-id shape, as defined by the
+*     AppElements wire codec (`AppElementsWire.isSlotId`). Wire-format details
+*     are intentionally kept inside the codec so this module does not duplicate
+*     them. Malformed tokens are dropped silently rather than rejecting the
+*     whole request — this matches the prior forgiving behavior for browsers
+*     that send legitimate but stale formats during rolling deploys.
+*
+* Consumed by:
+*   - app-rsc-request-normalization (request lifecycle, reads incoming header)
+*   - app-elements (outgoing x-vinext-mounted-slots construction)
+*   - isr-cache (RSC cache key generation)
+*/
+/** Hard cap on the raw header value byte length. Real values are <1 KB. */
+const MAX_RAW_HEADER_LENGTH = 4096;
+/** Hard cap on a single slot token byte length. */
+const MAX_TOKEN_LENGTH = 256;
+/** Hard cap on the number of slot tokens kept after normalization. */
+const MAX_SLOT_TOKENS = 16;
+/**
+* Validate a single mounted-slot token. Shape validation is delegated to the
+* AppElements wire codec so the wire format definition lives in exactly one
+* place. This module only enforces the additional security cap on token byte
+* length to bound cache-key cardinality.
+*/
+function isValidSlotToken(token) {
+	if (token.length === 0 || token.length > MAX_TOKEN_LENGTH) return false;
+	return AppElementsWire.isSlotId(token);
+}
+function normalizeMountedSlotsHeader(raw) {
+	if (!raw) return null;
+	if (raw.length > MAX_RAW_HEADER_LENGTH) return null;
+	const validTokens = raw.split(/\s+/).filter((token) => token && isValidSlotToken(token));
+	if (validTokens.length === 0) return null;
+	return Array.from(new Set(validTokens)).sort().slice(0, MAX_SLOT_TOKENS).join(" ") || null;
+}
+//#endregion
+export { normalizeMountedSlotsHeader };

package/dist/server/app-optimistic-routing.d.ts

@@ -0,0 +1,53 @@
+import { RouteManifest, RouteManifestRoute } from "../routing/app-route-graph.js";
+import { AppElements } from "./app-elements-wire.js";
+//#region src/server/app-optimistic-routing.d.ts
+type OptimisticRouteMatch = {
+  params: Record<string, string | string[]>;
+  route: RouteManifestRoute;
+};
+type OptimisticRouteTemplate = {
+  elements: AppElements;
+  mountedSlotsHeader: string | null;
+  pageElementIds: readonly string[];
+  routeId: string;
+};
+type OptimisticNavigationPayload = {
+  elements: AppElements;
+  params: Record<string, string | string[]>;
+  template: OptimisticRouteTemplate;
+};
+declare function getOptimisticRouteTemplateKey(options: {
+  interceptionContext: string | null;
+  mountedSlotsHeader: string | null;
+  routeId: string;
+}): string;
+declare function getOptimisticPrefetchSourceKey(options: {
+  cacheKey: string;
+  interceptionContext: string | null;
+  mountedSlotsHeader: string | null;
+}): string;
+declare function matchOptimisticRouteManifestRoute(options: {
+  basePath: string;
+  href: string;
+  routeManifest: RouteManifest;
+}): OptimisticRouteMatch | null;
+declare function createOptimisticRouteTemplate(options: {
+  allowLoadingShell?: boolean;
+  basePath: string;
+  elements: AppElements;
+  href: string;
+  interceptionContext: string | null;
+  mountedSlotsHeader: string | null;
+  routeManifest: RouteManifest;
+}): OptimisticRouteTemplate | null;
+declare function createOptimisticRouteElements(template: OptimisticRouteTemplate): AppElements;
+declare function resolveOptimisticNavigationPayload(options: {
+  basePath: string;
+  href: string;
+  interceptionContext: string | null;
+  mountedSlotsHeader: string | null;
+  routeManifest: RouteManifest;
+  templates: ReadonlyMap<string, OptimisticRouteTemplate>;
+}): OptimisticNavigationPayload | null;
+//#endregion
+export { OptimisticRouteTemplate, createOptimisticRouteElements, createOptimisticRouteTemplate, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, matchOptimisticRouteManifestRoute, resolveOptimisticNavigationPayload };