vinext 1.3.0 → 1.3.1

package/dist/server/pages-page-response.d.ts

@@ -151,4 +151,5 @@ export declare function buildPagesNextDataScript(options: Pick<RenderPagesPageRe
   vinext?: VinextNextData["__vinext"];
 }): string;
 export declare function renderPagesPageResponse(options: RenderPagesPageResponseOptions): Promise<Response>;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-preview.d.ts

@@ -22,4 +22,5 @@ export declare function clearPagesPreviewData(response: PreviewResponse, options
   path?: string;
 }): void;
 export declare function appendPagesPreviewClearCookies(headers: Headers): void;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-readiness.d.ts

@@ -32,4 +32,5 @@ export declare function buildPagesReadinessNextData(options: {
   } | null | undefined;
   hasRewrites: boolean;
 }): PagesReadinessNextData;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-request-pipeline.d.ts

@@ -157,4 +157,5 @@ export type PagesPipelineResult = {
  * runPagesRequest receives a "clean" request with basePath-stripped URL.
  */
 export declare function runPagesRequest(request: Request, deps: PagesPipelineDeps): Promise<PagesPipelineResult>;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-request-pipeline.js

@@ -1,11 +1,11 @@
 import { PRERENDER_REVALIDATE_HEADER } from "../utils/protocol-headers.js";
 import { requestContextFromRequest } from "../config/request-context.js";
 import { isExternalUrl } from "../utils/external-url.js";
-import { addBasePathToPathname, hasBasePath } from "../utils/base-path.js";
+import { addBasePathToPathname } from "../utils/base-path.js";
 import { VINEXT_PRERENDER_REWRITTEN_HEADER } from "./headers.js";
 import { methodNotAllowedResponse, notFoundStaticAssetResponse, sanitizeMethodNotAllowedHeaders } from "./http-error-responses.js";
 import { cloneRequestWithUrl, normalizeTrailingSlash } from "./request-pipeline.js";
-import { applyMiddlewareRequestHeaders, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest, sanitizeDestination } from "../config/config-matchers.js";
+import { applyMiddlewareRequestHeaders, encodeRedirectLocation, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest } from "../config/config-matchers.js";
 import { assetPrefixPathname, isAssetPrefixBuildAsset, isNextStaticPath } from "../utils/asset-prefix.js";
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
@@ -127,12 +127,11 @@ async function runPagesRequest(request, deps) {
 	if (configRedirects.length) {
 		const redirect = matchRedirect(requestConfigMatchPathname, configRedirects, reqCtx, basePathState, conditionalRedirectCacheability);
 		if (redirect) {
-			const dest = sanitizeDestination(basePath && hadBasePath && !isExternalUrl(redirect.destination) && !hasBasePath(redirect.destination, basePath) ? basePath + redirect.destination : redirect.destination);
-			const location = preserveRedirectDestinationQuery(dest, deps.rawSearch ?? search, redirect.destinationQuery);
+			const location = encodeRedirectLocation(preserveRedirectDestinationQuery(redirect.destination, deps.rawSearch ?? search, redirect.destinationQuery));
 			return {
 				type: "response",
 				response: new Response(null, {
-					status: redirect.permanent ? 308 : 307,
+					status: redirect.statusCode,
 					headers: { Location: location }
 				})
 			};

package/dist/server/pages-request-stage-entry.d.ts

@@ -26,4 +26,5 @@ export declare function isPagesClientBuildFileRequest(request: Request, env: Pag
 export declare function handleRequestStage(request: Request, env: PagesWorkerEnv | undefined, ctx: PagesWorkerExecutionContext | undefined, dispatchResponseStage: DispatchWorkerResponseStage): Promise<Response>;
 /** Preserve the direct single-entry Worker path without retaining it in request-only builds. */
 export declare function handleRequestStageLocally(request: Request, env: PagesWorkerEnv | undefined, ctx: PagesWorkerExecutionContext | undefined, dispatchResponseStage: PagesLocalResponseStage): Promise<Response>;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-response-stage-entry.d.ts

@@ -8,4 +8,5 @@ type PagesWorkerExecutionContext = ExecutionContextLike & {
 };
 export declare function renderPagesResponse(request: Request, env: PagesWorkerEnv | undefined, platformCtx: PagesWorkerExecutionContext | undefined, props: WorkerResponseStageProps, stagedHeaders?: Headers, dispatchRequestStage?: VinextRequestStageTransport, dispatchOptions?: VinextResponseStageDispatchOptions): Promise<Response>;
 export declare function handleResponseStage(request: Request, env: PagesWorkerEnv | undefined, ctx: PagesWorkerExecutionContext | undefined, props: WorkerResponseStageProps, dispatchRequestStage: VinextRequestStageTransport, options: VinextResponseStageDispatchOptions): Promise<Response>;
-//#endregion
+//#endregion
+export {};

package/dist/server/pages-route-data-kind.d.ts

@@ -15,4 +15,5 @@ type AppComponent = {
 } | null;
 /** Classify loaded Pages modules after HOCs and re-exports have been evaluated. */
 export declare function getRuntimePagesDataKind(pageModule: PagesModule, appComponent: AppComponent): RuntimePagesDataKind;
-//#endregion
+//#endregion
+export {};

package/dist/server/prerender-cache-life-header.d.ts

@@ -7,4 +7,5 @@ type PrerenderCacheLife = {
 };
 export declare function applyPrerenderCacheLifeHeader(headers: Headers, requestCacheLife: PrerenderCacheLife | null | undefined): void;
 export declare function applyPrerenderCacheTagsHeader(headers: Headers, cacheTags: readonly string[]): void;
-//#endregion
+//#endregion
+export {};

package/dist/server/prerender-route-params.d.ts

@@ -26,4 +26,5 @@ export declare function readTrustedPrerenderStateFromHeaders(headers: Headers, e
 export declare function readTrustedPrerenderRouteParams(request: Request): PrerenderRouteParamsPayload | null;
 export declare function matchPrerenderRouteParamsPayload(payload: PrerenderRouteParamsPayload | null, routePattern: string, params: PrerenderRouteParams): PrerenderRouteParamsRouteMatch | null;
 export declare function encodePrerenderRouteParams(pattern: string, params: PrerenderRouteParams, fallbackParamNames?: readonly string[]): PrerenderRouteParamsPayload | null;
-//#endregion
+//#endregion
+export {};

package/dist/server/prod-server.js

@@ -31,7 +31,6 @@ import { readPrerenderSecret, readServerCompress } from "../build/server-manifes
 import { readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import { resolveClientBuildFile } from "./client-build-files.js";
 import { registerPrerenderCloudflareLoader } from "../build/prerender-cloudflare-loader.js";
-import { seedMemoryCacheFromPrerender } from "./seed-cache.js";
 import { negotiateEncoding, parseAcceptedEncodings, selectContentEncoding } from "./accept-encoding.js";
 import { COMPRESS_THRESHOLD, hasNoTransform, isCompressibleContentType, parseContentLengthHeader, resolveResponseCompression } from "./response-compression.js";
 import { ifRangeAllowsRange, parseByteRange } from "./http-range.js";
@@ -329,6 +328,7 @@ function installClientBuildManifestGlobals(clientDir, assetBase, assetPrefix, cr
 	});
 	setPagesClientAssets({
 		appBootstrapPreinitModules: metadata.appBootstrapPreinitModules,
+		appRouteManifestModule: metadata.appRouteManifestModule,
 		lazyChunks: metadata.lazyChunks,
 		dynamicPreloads: metadata.dynamicPreloads,
 		crossOrigin
@@ -904,6 +904,7 @@ function waitForNodeResponseCompletion(res) {
 */
 async function startProdServer(options = {}) {
 	installSocketErrorBackstop({ runningServer: options.purpose !== "prerender" });
+	if (options.purpose !== "prerender" && !process.env.NODE_ENV) Reflect.set(process.env, "NODE_ENV", "production");
 	const { port = process.env.PORT ? parseInt(process.env.PORT) : 3e3, host = "0.0.0.0", outDir = path.resolve("dist"), rscEntryPath: explicitRscEntryPath, serverDir: explicitServerDir, serverEntryPath: explicitServerEntryPath, noCompression = false, purpose, silent = false } = options;
 	if (purpose === "prerender") registerPrerenderCloudflareLoader();
 	const compress = !noCompression;
@@ -1007,15 +1008,19 @@ function resolveAppRouterHandler(entry) {
 	console.error("[vinext] App Router entry must export either a default handler function or a Worker-style default export with fetch()");
 	process.exit(1);
 }
+async function seedMemoryCacheFromPrerenderFallback(serverDir) {
+	const { seedMemoryCacheFromPrerender } = await import("./seed-cache.js");
+	return seedMemoryCacheFromPrerender(serverDir);
+}
 function isAppRouterPrerenderSeederExport(value) {
 	return typeof value === "function";
 }
 function resolveAppRouterPrerenderSeeder(entryModule) {
-	if (typeof entryModule !== "object" || entryModule === null) return seedMemoryCacheFromPrerender;
+	if (typeof entryModule !== "object" || entryModule === null) return seedMemoryCacheFromPrerenderFallback;
 	const seedExport = Object.getOwnPropertyDescriptor(entryModule, "seedMemoryCacheFromPrerender")?.value;
 	if (!isAppRouterPrerenderSeederExport(seedExport)) {
 		if (process.env.NEXT_PRIVATE_DEBUG_CACHE) console.debug("[vinext] ISR: using fallback prerender cache seeder");
-		return seedMemoryCacheFromPrerender;
+		return seedMemoryCacheFromPrerenderFallback;
 	}
 	if (process.env.NEXT_PRIVATE_DEBUG_CACHE) console.debug("[vinext] ISR: using App Router entry prerender cache seeder");
 	return async (serverDir) => {
@@ -1091,6 +1096,7 @@ function installPagesClientAssets(options) {
 	setPagesClientAssets({
 		clientEntry: metadata.clientEntryFile,
 		appBootstrapPreinitModules: metadata.appBootstrapPreinitModules,
+		appRouteManifestModule: metadata.appRouteManifestModule,
 		ssrManifest: Object.keys(ssrManifest).length > 0 ? ssrManifest : void 0,
 		sharedChunks: metadata.sharedChunks,
 		cssGraph: metadata.cssGraph,

package/dist/server/request-log.d.ts

@@ -31,4 +31,5 @@ export declare function logRequest({ method, url, status, totalMs, compileMs, re
  * Returns `performance.now()` - a high-resolution monotonic timestamp.
  */
 export declare function now(): number;
-//#endregion
+//#endregion
+export {};

package/dist/server/request-tracing.d.ts

@@ -19,4 +19,5 @@ export declare function clearFrameworkRequestError(response: Response): Response
 export declare function attachFrameworkRequestError(response: Response, error: unknown): Response;
 export declare function consumeFrameworkRequestRoute(response: Response): Response;
 export declare function traceFrameworkRequest<T>(input: RequestTraceInput<T>): Promise<T>;
-//#endregion
+//#endregion
+export {};

package/dist/server/request-tracing.js

@@ -1,8 +1,8 @@
 import { getOrCreateAls } from "../shims/internal/als-registry.js";
 import { isFullyBufferedBody, markFullyBufferedBody, preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { VINEXT_TRACE_BUFFERED_BODY_HEADER, VINEXT_TRACE_ERROR_HEADER, VINEXT_TRACE_ROUTE_HEADER } from "./headers.js";
 import { frameworkTracer } from "./tracer.js";
-import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { getResponseStartCompletion } from "./response-start-tracing.js";
 //#region src/server/request-tracing.ts
 const activeRequestTrace = getOrCreateAls("vinext.requestTracing.als");

package/dist/server/response-start-tracing.js

@@ -1,4 +1,5 @@
 import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
+import { observeStreamConsumption } from "./defer-until-stream-consumed.js";
 import { frameworkTracer } from "./tracer.js";
 import { copyLinkHeaderProvenance } from "./app-response-header-provenance.js";
 //#region src/server/response-start-tracing.ts
@@ -13,37 +14,14 @@ function createResponseStartSpanDescriptor() {
 	};
 }
 function traceResponseStartStream(stream, onSettled) {
-	const reader = stream.getReader();
 	const runInTraceContext = frameworkTracer.captureActiveContext();
-	let started = false;
-	return new ReadableStream({
-		async pull(controller) {
-			try {
-				const result = await reader.read();
-				if (result.done) {
-					onSettled();
-					controller.close();
-					return;
-				}
-				if (!started) {
-					started = true;
-					runInTraceContext(() => frameworkTracer.trace(createResponseStartSpanDescriptor(), () => void 0));
-					onSettled();
-				}
-				controller.enqueue(result.value);
-			} catch (error) {
-				onSettled();
-				controller.error(error);
-			}
+	return observeStreamConsumption(stream, {
+		onStart() {
+			runInTraceContext(() => frameworkTracer.trace(createResponseStartSpanDescriptor(), () => void 0));
+			onSettled();
 		},
-		async cancel(reason) {
-			try {
-				await reader.cancel(reason);
-			} finally {
-				onSettled();
-			}
-		}
-	}, { highWaterMark: 0 });
+		onFlush: onSettled
+	});
 }
 function traceResponseStartWithCompletion(response) {
 	const existing = tracedResponses.get(response);

package/dist/server/rsc-render-stream.d.ts

@@ -0,0 +1,4 @@
+//#region src/server/rsc-render-stream.d.ts
+export type RscRawRenderer = (model: unknown, options?: unknown) => ReadableStream<Uint8Array>;
+export declare function createRscRenderer(render: RscRawRenderer): RscRawRenderer;
+//#endregion

package/dist/server/rsc-render-stream.js

@@ -0,0 +1,25 @@
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
+import { createRenderStreamCancellation } from "./app-render-abort-error.js";
+//#region src/server/rsc-render-stream.ts
+const noop = () => {};
+function createRscRenderer(render) {
+	return (model, options) => {
+		const cancellation = createRenderStreamCancellation();
+		return deferUntilStreamConsumed(render(model, ignoreCancellationErrors(options, cancellation)), noop, void 0, cancellation.record);
+	};
+}
+/** A consumer cancelling the payload is not a render failure. */
+function ignoreCancellationErrors(options, cancellation) {
+	if (!options || typeof options !== "object") return options;
+	const onError = Reflect.get(options, "onError");
+	if (typeof onError !== "function") return options;
+	return {
+		...options,
+		onError(error, ...rest) {
+			if (cancellation.isReason(error)) return void 0;
+			return Reflect.apply(onError, options, [error, ...rest]);
+		}
+	};
+}
+//#endregion
+export { createRscRenderer };

package/dist/server/seed-cache.d.ts

@@ -30,4 +30,5 @@ type PrerenderCacheSeedOptions = {
  * @returns The number of routes seeded (0 if no manifest or no renderable routes).
  */
 export declare function seedMemoryCacheFromPrerender(serverDir: string, options?: PrerenderCacheSeedOptions): Promise<number>;
-//#endregion
+//#endregion
+export {};

package/dist/server/seed-cache.js

@@ -2,8 +2,8 @@ import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { appIsrCacheKey, appIsrFallbackShellKey, isrSet, isrSetPrerenderedAppPage } from "./isr-cache.js";
 import { addPregeneratedConcretePath, addPregeneratedRoute, clearPregeneratedConcretePaths, normalizePregeneratedPathname } from "./pregenerated-concrete-paths.js";
 import { getRenderedAppRoutes, getRenderedMetadataRoutes, isFallbackShellArtifactPath, readPrerenderManifest } from "./prerender-manifest.js";
-import { buildAppPageCacheTags, buildAppRouteCacheTags } from "./app-page-cache.js";
 import { getAppRouteOutputPath, getOutputPath, getRscOutputPath } from "../utils/prerender-output-paths.js";
+import { buildAppPageCacheTags, buildAppRouteCacheTags } from "./app-page-cache.js";
 import fs from "node:fs";
 //#region src/server/seed-cache.ts
 /**

package/dist/server/static-file-cache.d.ts

@@ -66,4 +66,5 @@ export declare class StaticFileCache {
  * so the caller can fall back to mtime-based ETags.
  */
 export declare function etagFromFilenameHash(relativePath: string, ext: string): string | null;
-//#endregion
+//#endregion
+export {};

package/dist/server/static-file-cache.js

@@ -37,6 +37,7 @@ const CONTENT_TYPES = {
 	".mp4": "video/mp4",
 	".ogg": "audio/ogg",
 	".ogv": "video/ogg",
+	".otf": "font/otf",
 	".pdf": "application/pdf",
 	".png": "image/png",
 	".rsc": "text/x-component",

package/dist/server/static-layout-client-reuse-proof.d.ts

@@ -10,4 +10,5 @@ type StaticLayoutClientReuseProofInput = Readonly<{
 export declare function createStaticLayoutClientReuseRouteId(layoutId: string): string;
 export declare function createStaticLayoutClientReusePayloadHash(input: StaticLayoutClientReuseProofInput): string;
 export declare function createStaticLayoutClientReuseArtifactCompatibility(input: StaticLayoutClientReuseProofInput): ArtifactCompatibilityEnvelope;
-//#endregion
+//#endregion
+export {};

package/dist/server/worker-revalidation-context.d.ts

@@ -9,4 +9,5 @@ type PlatformExecutionContext = Partial<ExecutionContextLike> & VinextRequestSta
  * on the normal header-scrubbing path.
  */
 export declare function createWorkerRevalidationContext(base: PlatformExecutionContext | undefined, handleInternalRequest: (request: Request, ctx: ExecutionContextLike) => Promise<Response>, defaultHostRuntime?: "node" | "worker"): ExecutionContextLike;
-//#endregion
+//#endregion
+export {};

package/dist/server/worker-stages.d.ts

@@ -40,4 +40,5 @@ export type WorkerResponseStageProps = PagesApiResponseStageProps | PagesPageRes
  */
 export type DispatchWorkerResponseStage = VinextResponseStageTransport<WorkerResponseStageProps>;
 export declare function isPagesResponseStageProps(value: unknown): value is WorkerResponseStageProps;
-//#endregion
+//#endregion
+export {};

package/dist/shims/app.d.ts

@@ -34,4 +34,5 @@ export default class App<P = any, CP = any, S = any> extends React.Component<P &
   static getInitialProps: typeof appGetInitialProps;
   render(): React.ReactElement;
 }
-//#endregion
+//#endregion
+export {};

package/dist/shims/cache-callable-runtime.d.ts

@@ -12,4 +12,5 @@ export declare function registerCachedFunction<TArgs extends unknown[], TResult>
 }): (...args: TArgs) => Promise<TResult>;
 /** Replay the persisted payload without re-reading or re-encoding caller objects. */
 export declare function invokeCacheFunction(invocation: VinextCacheFunctionInvocation, loadServerAction: (id: string) => Promise<unknown>): Promise<void>;
-//#endregion
+//#endregion
+export {};

package/dist/shims/cache-handler.d.ts

@@ -96,7 +96,7 @@ type MemoryCacheHandlerOptions = Pick<CacheHandlerContext, "maxMemoryCacheSize">
 };
 export declare class MemoryCacheHandler implements CacheHandler {
   private store;
-  private tagRevalidatedAt;
+  private tagsManifest;
   private readonly maxMemoryCacheSize;
   private currentMemoryCacheSize;
   constructor(options?: number | MemoryCacheHandlerOptions);
@@ -106,7 +106,11 @@ export declare class MemoryCacheHandler implements CacheHandler {
   private evictLeastRecentlyUsed;
   get(key: string, ctx?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
   set(key: string, data: IncrementalCacheValue | null, ctx?: Record<string, unknown>): Promise<void>;
-  revalidateTag(tags: string | string[]): Promise<void>;
+  revalidateTag(tags: string | string[], durations?: {
+    expire?: number;
+  }): Promise<void>;
+  private isTagExpired;
+  private isTagStale;
   resetRequestCache(): void;
 }
 export declare function configureMemoryCacheHandler(options?: MemoryCacheHandlerOptions): void;
@@ -121,4 +125,5 @@ export declare function registerLazyDataCacheHandler(load: () => Promise<void>):
 export declare function getDataCacheHandler(): CacheHandler;
 export declare function setCacheHandler(handler: CacheHandler): void;
 export declare function getCacheHandler(): CacheHandler;
-//#endregion
+//#endregion
+export {};

package/dist/shims/cache-handler.js

@@ -48,7 +48,7 @@ function readPositiveNumberField(ctx, field) {
 }
 var MemoryCacheHandler = class {
 	store = /* @__PURE__ */ new Map();
-	tagRevalidatedAt = /* @__PURE__ */ new Map();
+	tagsManifest = /* @__PURE__ */ new Map();
 	maxMemoryCacheSize;
 	currentMemoryCacheSize = 0;
 	constructor(options) {
@@ -77,19 +77,20 @@ var MemoryCacheHandler = class {
 	async get(key, ctx) {
 		const entry = this.store.get(key);
 		if (!entry) return null;
+		const now = Date.now();
+		let hasStaleTag = false;
 		for (const tag of entry.tags) {
-			const revalidatedAt = this.tagRevalidatedAt.get(tag);
-			if (revalidatedAt && revalidatedAt >= entry.lastModified) {
+			if (this.isTagExpired(tag, entry.lastModified, now)) {
 				this.deleteEntry(key);
 				return null;
 			}
+			hasStaleTag ||= this.isTagStale(tag, entry.lastModified);
 		}
 		for (const tag of readStringArrayField(ctx, "softTags")) {
-			const revalidatedAt = this.tagRevalidatedAt.get(tag);
-			if (revalidatedAt && revalidatedAt >= entry.lastModified) return null;
+			if (this.isTagExpired(tag, entry.lastModified, now)) return null;
+			hasStaleTag ||= this.isTagStale(tag, entry.lastModified);
 		}
 		this.touchEntry(key, entry);
-		const now = Date.now();
 		if (entry.expireAt !== null && now > entry.expireAt) return {
 			lastModified: entry.lastModified,
 			value: entry.value,
@@ -98,7 +99,7 @@ var MemoryCacheHandler = class {
 		};
 		const requestedRevalidate = readPositiveNumberField(ctx, "revalidate");
 		const requestedRevalidateAt = requestedRevalidate === void 0 ? null : entry.lastModified + requestedRevalidate * 1e3;
-		if (entry.revalidateAt !== null && now > entry.revalidateAt || requestedRevalidateAt !== null && now > requestedRevalidateAt) return {
+		if (hasStaleTag || entry.revalidateAt !== null && now > entry.revalidateAt || requestedRevalidateAt !== null && now > requestedRevalidateAt) return {
 			lastModified: entry.lastModified,
 			value: entry.value,
 			cacheState: "stale",
@@ -148,10 +149,29 @@ var MemoryCacheHandler = class {
 		this.currentMemoryCacheSize += entrySize;
 		this.evictLeastRecentlyUsed();
 	}
-	async revalidateTag(tags) {
+	async revalidateTag(tags, durations) {
 		const tagList = Array.isArray(tags) ? tags : [tags];
 		const now = Date.now();
-		for (const tag of tagList) this.tagRevalidatedAt.set(tag, now);
+		for (const tag of tagList) {
+			const existing = this.tagsManifest.get(tag) ?? {};
+			if (durations) this.tagsManifest.set(tag, {
+				...existing,
+				stale: now,
+				...durations.expire === void 0 ? {} : { expired: now + durations.expire * 1e3 }
+			});
+			else this.tagsManifest.set(tag, {
+				...existing,
+				expired: now
+			});
+		}
+	}
+	isTagExpired(tag, lastModified, now) {
+		const expired = this.tagsManifest.get(tag)?.expired;
+		return expired !== void 0 && expired <= now && expired >= lastModified;
+	}
+	isTagStale(tag, lastModified) {
+		const stale = this.tagsManifest.get(tag)?.stale;
+		return stale !== void 0 && stale > lastModified;
 	}
 	resetRequestCache() {}
 };

package/dist/shims/caught-not-found-boundaries.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+//#region src/shims/caught-not-found-boundaries.d.ts
+export declare const CAUGHT_NOT_FOUND_BOUNDARIES_GLOBAL = "__VINEXT_CAUGHT_NOT_FOUND__";
+/** The boundaries that caught, and those of them the document rendered. */
+export type CaughtNotFoundBoundaries = {
+  ids: ReadonlySet<string>;
+  rendered: Set<string>;
+};
+export declare const CaughtNotFoundBoundariesContext: React.Context<CaughtNotFoundBoundaries | null> | null;
+export declare function withCaughtNotFoundBoundaries(boundaries: CaughtNotFoundBoundaries, children: React.ReactElement): React.ReactElement;
+/** Whether the boundary with this id caught a notFound() in the document. */
+export declare function useCaughtNotFoundBoundary(id: string | undefined): boolean;
+/** A hydrated boundary consumes its id, so a later mount renders its children. */
+export declare function consumeCaughtNotFoundBoundary(id: string | undefined): void;
+//#endregion

package/dist/shims/caught-not-found-boundaries.js

@@ -0,0 +1,48 @@
+import React from "react";
+//#region src/shims/caught-not-found-boundaries.ts
+/**
+* The parallel slot not-found boundaries that caught a slot's notFound() in
+* the document. Fizz has no error boundaries, so a slot page's notFound()
+* rejects the shell; the App Router SSR entry then renders the document again
+* from the same Flight payload, with the boundaries that would have caught it
+* on the client rendering their fallback (Next.js renders them in the browser
+* after an empty error shell). The browser reads the same ids from
+* `self.__VINEXT_CAUGHT_NOT_FOUND__`, so those boundaries hydrate caught. Only
+* the boundaries the document rendered are sent, since one inside another
+* caught boundary never mounts to consume its id.
+*
+* Stored on a global symbol so duplicate module instances share one context,
+* and null in react-server, which has no createContext.
+*/
+const CAUGHT_NOT_FOUND_BOUNDARIES_CONTEXT_KEY = Symbol.for("vinext.caughtNotFoundBoundariesContext");
+const CAUGHT_NOT_FOUND_BOUNDARIES_GLOBAL = "__VINEXT_CAUGHT_NOT_FOUND__";
+function getCaughtNotFoundBoundariesContext() {
+	if (typeof React.createContext !== "function") return null;
+	const globalState = globalThis;
+	globalState[CAUGHT_NOT_FOUND_BOUNDARIES_CONTEXT_KEY] ??= React.createContext(null);
+	return globalState[CAUGHT_NOT_FOUND_BOUNDARIES_CONTEXT_KEY];
+}
+const CaughtNotFoundBoundariesContext = getCaughtNotFoundBoundariesContext();
+function withCaughtNotFoundBoundaries(boundaries, children) {
+	return CaughtNotFoundBoundariesContext ? React.createElement(CaughtNotFoundBoundariesContext.Provider, { value: boundaries }, children) : children;
+}
+/** Whether the boundary with this id caught a notFound() in the document. */
+function useCaughtNotFoundBoundary(id) {
+	const serverBoundaries = React.useContext(CaughtNotFoundBoundariesContext);
+	if (id === void 0) return false;
+	if (typeof window === "undefined") {
+		if (serverBoundaries?.ids.has(id) !== true) return false;
+		serverBoundaries.rendered.add(id);
+		return true;
+	}
+	return globalThis[CAUGHT_NOT_FOUND_BOUNDARIES_GLOBAL]?.includes(id) === true;
+}
+/** A hydrated boundary consumes its id, so a later mount renders its children. */
+function consumeCaughtNotFoundBoundary(id) {
+	if (id === void 0 || typeof window === "undefined") return;
+	const ids = globalThis[CAUGHT_NOT_FOUND_BOUNDARIES_GLOBAL];
+	const index = ids?.indexOf(id) ?? -1;
+	if (index !== -1) ids.splice(index, 1);
+}
+//#endregion
+export { CAUGHT_NOT_FOUND_BOUNDARIES_GLOBAL, CaughtNotFoundBoundariesContext, consumeCaughtNotFoundBoundary, useCaughtNotFoundBoundary, withCaughtNotFoundBoundaries };

package/dist/shims/cdn-purge-routes.d.ts

@@ -21,4 +21,5 @@ export declare function registerCdnPurgeRoutes(routes: CdnPurgeRoutes): void;
  * also the `/docs` page tag) always purge.
  */
 export declare function isPathKnownNotEdgeCached(path: string): boolean;
-//#endregion
+//#endregion
+export {};

package/dist/shims/client-locale.js

@@ -3,7 +3,8 @@ import { detectDomainLocale, getLocalePathPrefix } from "../utils/domain-locale.
 //#region src/shims/client-locale.ts
 function getCurrentBrowserLocale({ basePath, domainLocales, hostname }) {
 	if (typeof window === "undefined") return void 0;
-	const pathnameLocale = getLocalePathPrefix(stripBasePath(window.location.pathname, basePath), window.__VINEXT_LOCALES__);
+	const locales = window.__VINEXT_LOCALES__;
+	const pathnameLocale = locales?.length ? getLocalePathPrefix(stripBasePath(window.location.pathname, basePath), locales) : void 0;
 	if (pathnameLocale) return pathnameLocale;
 	return detectDomainLocale(domainLocales, hostname ?? void 0)?.defaultLocale ?? window.__VINEXT_LOCALE__ ?? window.__VINEXT_DEFAULT_LOCALE__;
 }

package/dist/shims/client-page-root.d.ts

@@ -21,4 +21,5 @@ export type ClientPageRootProps = {
  */
 export declare function createClientPageSearchParams(searchParams: URLSearchParams | null | undefined): Promise<ClientPageSearchParams>;
 export declare function ClientPageRoot({ Component, pageProps, emptySearchParams }: ClientPageRootProps): import("react").ReactElement<Record<string, unknown>, string | import("react").JSXElementConstructor<any>>;
-//#endregion
+//#endregion
+export {};

package/dist/shims/config.d.ts

@@ -24,4 +24,5 @@ export declare function setConfig(configValue: RuntimeConfig): void;
  * Default export — matches `import getConfig from "next/config"`.
  */
 export default function getConfig(): RuntimeConfig;
-//#endregion
+//#endregion
+export {};

package/dist/shims/default-forbidden.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+//#region src/shims/default-forbidden.d.ts
+export default function DefaultForbidden(): React.ReactElement;
+//#endregion

package/dist/shims/default-forbidden.js

@@ -0,0 +1,18 @@
+import { HTTPAccessErrorFallback } from "./http-access-error-fallback.js";
+import React from "react";
+//#region src/shims/default-forbidden.tsx
+/**
+* Ported from Next.js's built-in default forbidden component:
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/builtin/forbidden.tsx
+*
+* Rendered when `forbidden()` is called and no `app/forbidden.tsx` boundary
+* catches it.
+*/
+function DefaultForbidden() {
+	return React.createElement(HTTPAccessErrorFallback, {
+		status: 403,
+		message: "This page could not be accessed."
+	});
+}
+//#endregion
+export { DefaultForbidden as default };

package/dist/shims/default-not-found.d.ts

@@ -1,9 +1,4 @@
 import React from "react";
 //#region src/shims/default-not-found.d.ts
-/**
- * Mirrors `<HTTPAccessErrorFallback status={404} message="This page could not be found." />`
- * from Next.js. Kept in sync with the upstream component's structure so HTML
- * snapshot diffs between Next.js and vinext stay minimal.
- */
 export default function DefaultNotFound(): React.ReactElement;
 //#endregion