vinext 1.2.1 → 1.3.1

package/dist/shims/cache.js

@@ -3,7 +3,6 @@ import { getRequestContext, isInsideUnifiedScope } from "./unified-request-conte
 import { getRequestExecutionContext, runWithExecutionContext } from "./request-context.js";
 import { isInsideWorkStoreScope } from "./internal/work-store-scope.js";
 import { workUnitAsyncStorage } from "./internal/work-unit-async-storage.js";
-import { getCdnCacheAdapter } from "./cdn-cache.js";
 import { isStagedCacheabilityProbeActive } from "./cacheability-classification.js";
 import { MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, registerDataCacheHandler, registerLazyDataCacheHandler, setCacheHandler, setDataCacheHandler } from "./cache-handler.js";
 import { encodeCacheTag, encodeCacheTags } from "../utils/encode-cache-tag.js";
@@ -13,7 +12,8 @@ import { makeHangingPromise } from "./internal/make-hanging-promise.js";
 import { getHeadersAccessPhase, markDynamicUsage } from "./internal/headers-state.js";
 import { isDraftModeEnabled } from "./headers.js";
 import { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext } from "./internal/cache-context-accessor.js";
-import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, markActionRevalidation, recordUnstableCacheObservation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
+import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, markActionRevalidation, recordUnstableCacheObservation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
+import { isPathKnownNotEdgeCached } from "./cdn-purge-routes.js";
 //#region src/shims/cache.ts
 /**
 * next/cache shim
@@ -69,7 +69,7 @@ function revalidateTag(tag, profile) {
 	if (!profile || !durations || durations.expire === 0) markActionRevalidation(1);
 	const encodedTag = encodeCacheTag(tag);
 	_markPendingRevalidatedTag(encodedTag);
-	return scheduleRevalidation(_invalidateEncodedTag(encodedTag, durations));
+	return scheduleTagInvalidation(encodedTag, durations);
 }
 /**
 * Invalidate one already-encoded tag across both cache layers.
@@ -79,10 +79,18 @@ function revalidateTag(tag, profile) {
 * default CDN adapter), THEN ask the CDN adapter to purge its edge (a no-op for
 * the default adapter). Purging the edge before the store is invalidated would
 * let the edge re-fetch and re-cache stale data.
+*
+* The data cache is invalidated right away, so reads later in the same action
+* see it. Inside a Server Action or Route Handler the purge waits for the
+* request boundary, which sends one batched adapter call per profile.
 */
-async function _invalidateEncodedTag(encoded, durations) {
+function scheduleTagInvalidation(encoded, durations) {
+	const dataInvalidation = invalidateDataCacheTag(encoded, durations);
+	if (_queuePendingCdnTagInvalidation(encoded, durations, dataInvalidation)) return scheduleRevalidation(dataInvalidation);
+	return scheduleRevalidation(dataInvalidation.then(() => _revalidateCdnTags(encoded, durations)));
+}
+async function invalidateDataCacheTag(encoded, durations) {
 	await getDataCacheHandler().revalidateTag(encoded, durations);
-	await getCdnCacheAdapter().revalidateTag(encoded, durations);
 }
 /**
 * Revalidate cached data associated with a specific path.
@@ -109,7 +117,8 @@ function revalidatePath(path, type) {
 	const tag = type ? `_N_T_${stem}/${type}` : `_N_T_${stem || "/"}`;
 	const encodedTag = encodeCacheTag(tag);
 	_markPendingRevalidatedTag(encodedTag);
-	return scheduleRevalidation(_invalidateEncodedTag(encodedTag));
+	if (isPathKnownNotEdgeCached(stem || "/")) return scheduleRevalidation(invalidateDataCacheTag(encodedTag));
+	return scheduleTagInvalidation(encodedTag);
 }
 /**
 * No-op shim for API compatibility.
@@ -140,7 +149,7 @@ function updateTag(tag) {
 	markActionRevalidation(1);
 	const encodedTag = encodeCacheTag(tag);
 	_markPendingRevalidatedTag(encodedTag);
-	return scheduleRevalidation(_invalidateEncodedTag(encodedTag));
+	return scheduleTagInvalidation(encodedTag);
 }
 /**
 * Opt out of static rendering and indicate a particular component should not be cached.
@@ -464,4 +473,4 @@ function unstable_cache(fn, keyParts, options) {
 	return cachedFn;
 }
 //#endregion
-export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, MemoryCacheHandler, NoOpCacheHandler, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLife, cacheLifeProfiles, cacheTag, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, io, isInsideUnstableCacheScope, markActionRevalidation, unstable_noStore as noStore, unstable_noStore, recordUnstableCacheObservation, refresh, registerDataCacheHandler, registerLazyDataCacheHandler, revalidatePath, revalidateTag, runWithDetachedCacheObservations, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry, unstable_cache, unstable_cacheLife, unstable_cacheTag, unstable_io, updateTag };
+export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, MemoryCacheHandler, NoOpCacheHandler, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLife, cacheLifeProfiles, cacheTag, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, io, isInsideUnstableCacheScope, markActionRevalidation, unstable_noStore as noStore, unstable_noStore, recordUnstableCacheObservation, refresh, registerDataCacheHandler, registerLazyDataCacheHandler, revalidatePath, revalidateTag, runWithDetachedCacheObservations, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry, unstable_cache, unstable_cacheLife, unstable_cacheTag, unstable_io, updateTag };

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

@@ -0,0 +1,25 @@
+//#region src/shims/cdn-purge-routes.d.ts
+type CdnPurgeRoute = {
+  patternParts: readonly string[];
+  routeSegments: readonly string[];
+};
+type CdnPurgeRoutes = {
+  metadataRoutes: readonly (Omit<CdnPurgeRoute, "patternParts"> & {
+    patternParts: readonly string[] | null;
+    servedUrl: string;
+  })[];
+  routes: readonly (CdnPurgeRoute & {
+    forceDynamic?: boolean;
+  })[];
+};
+/** Register the App Router's routes. Apps with a Pages Router never register. */
+export declare function registerCdnPurgeRoutes(routes: CdnPurgeRoutes): void;
+/**
+ * Whether no edge-cacheable response can carry the implicit tags of
+ * `revalidatePath(path)`, for any `type`. Paths that need encoding, the
+ * `/index` alias, and paths ending in a derived tag suffix (`/docs/page` is
+ * also the `/docs` page tag) always purge.
+ */
+export declare function isPathKnownNotEdgeCached(path: string): boolean;
+//#endregion
+export {};

package/dist/shims/cdn-purge-routes.js

@@ -0,0 +1,77 @@
+import { matchRoutePatternPrefix, routePatternParts } from "../routing/route-pattern.js";
+//#region src/shims/cdn-purge-routes.ts
+/**
+* Build-time route facts that let `revalidatePath()` skip a CDN purge no
+* edge-cached response could match.
+*
+* Edge purges are rate limited (Workers Cache allows 5 a minute per account),
+* and a `dynamic = "force-dynamic"` App route never stores a response the
+* edge can serve. The check is conservative: it only skips a path when at
+* least one App route could serve it and every such route is force-dynamic.
+* The data cache is always invalidated.
+*/
+const CDN_PURGE_ROUTES_KEY = Symbol.for("vinext.cdnPurgeRoutes");
+const globals = globalThis;
+const DERIVED_TAG_SUFFIXES = /* @__PURE__ */ new Set([
+	"layout",
+	"page",
+	"route"
+]);
+/** Register the App Router's routes. Apps with a Pages Router never register. */
+function registerCdnPurgeRoutes(routes) {
+	globals[CDN_PURGE_ROUTES_KEY] = routes;
+}
+/** Whether some URL matched by `patternParts` starts with `pathParts`. */
+function canServeUnder(pathParts, patternParts) {
+	const last = patternParts.at(-1) ?? "";
+	const endsInCatchAll = last.startsWith(":") && (last.endsWith("+") || last.endsWith("*"));
+	if (patternParts.length < pathParts.length && !endsInCatchAll) return false;
+	return matchRoutePatternPrefix(pathParts, patternParts.slice(0, pathParts.length));
+}
+/**
+* Whether a response from `route` could carry a `revalidatePath(path)` tag.
+* Implicit tags use either the URL (`/blog/a`) or the route's segments
+* (`/(site)/blog/[slug]`), so check both as prefixes.
+*/
+function couldCarryPathTag(pathParts, route) {
+	return canServeUnder(pathParts, route.patternParts) || canServeUnder(pathParts, routePatternParts(route.routeSegments.join("/")));
+}
+/**
+* Whether a metadata route, or a child it generates (`/icon/small` from
+* `generateImageMetadata`, `/sitemap/0.xml` from `generateSitemaps`), could
+* carry a `revalidatePath(path)` tag.
+*/
+function metadataCouldCarryPathTag(pathParts, route) {
+	const patternParts = route.patternParts ?? routePatternParts(route.servedUrl);
+	const childParts = [
+		...patternParts.slice(0, -1),
+		(patternParts.at(-1) ?? "").replace(/\.[^.]*$/, ""),
+		":children*"
+	];
+	return couldCarryPathTag(pathParts, {
+		patternParts,
+		routeSegments: route.routeSegments
+	}) || canServeUnder(pathParts, childParts);
+}
+/**
+* Whether no edge-cacheable response can carry the implicit tags of
+* `revalidatePath(path)`, for any `type`. Paths that need encoding, the
+* `/index` alias, and paths ending in a derived tag suffix (`/docs/page` is
+* also the `/docs` page tag) always purge.
+*/
+function isPathKnownNotEdgeCached(path) {
+	const registered = globals[CDN_PURGE_ROUTES_KEY];
+	if (!registered || path === "/index" || /[^\x21-\x7e]|%/.test(path)) return false;
+	const pathParts = path.split("/").filter(Boolean);
+	if (DERIVED_TAG_SUFFIXES.has(pathParts.at(-1) ?? "")) return false;
+	if (registered.metadataRoutes.some((route) => metadataCouldCarryPathTag(pathParts, route))) return false;
+	let matched = false;
+	for (const route of registered.routes) {
+		if (!couldCarryPathTag(pathParts, route)) continue;
+		if (route.forceDynamic !== true) return false;
+		matched = true;
+	}
+	return matched;
+}
+//#endregion
+export { isPathKnownNotEdgeCached, registerCdnPurgeRoutes };

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

package/dist/shims/default-not-found.js

@@ -1,59 +1,23 @@
+import { HTTPAccessErrorFallback } from "./http-access-error-fallback.js";
 import React from "react";
 //#region src/shims/default-not-found.tsx
 /**
 * Ported from Next.js's built-in default not-found component:
 *   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/builtin/not-found.tsx
-*   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/http-access-fallback/error-fallback.tsx
 *
 * Rendered when an App Router request resolves to a 404 and the user has not
 * supplied their own `app/not-found.tsx` (or `app/global-not-found.tsx`).
-* Matches Next.js's `HTTPAccessErrorFallback` exactly: a centered 404 / message
-* pair with minified theme CSS and dark-mode media query.
 *
 * The message string `"This page could not be found."` (note the trailing
 * period) is the canonical body asserted by Next.js's deploy suite
 * (`test/e2e/app-dir/prefetching-not-found/prefetching-not-found.test.ts`,
 * `test/e2e/basepath/error-pages.test.ts`).
 */
-const styles = {
-	error: {
-		fontFamily: "system-ui,\"Segoe UI\",Roboto,Helvetica,Arial,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\"",
-		height: "100vh",
-		textAlign: "center",
-		display: "flex",
-		flexDirection: "column",
-		alignItems: "center",
-		justifyContent: "center"
-	},
-	desc: { display: "inline-block" },
-	h1: {
-		display: "inline-block",
-		margin: "0 20px 0 0",
-		padding: "0 23px 0 0",
-		fontSize: 24,
-		fontWeight: 500,
-		verticalAlign: "top",
-		lineHeight: "49px"
-	},
-	h2: {
-		fontSize: 14,
-		fontWeight: 400,
-		lineHeight: "49px",
-		margin: 0
-	}
-};
-const STATUS = 404;
-const MESSAGE = "This page could not be found.";
-/**
-* 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.
-*/
 function DefaultNotFound() {
-	return React.createElement(React.Fragment, null, React.createElement("title", null, `${STATUS}: ${MESSAGE}`), React.createElement("div", { style: styles.error }, React.createElement("div", null, React.createElement("style", { dangerouslySetInnerHTML: { __html: "body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}" } }), React.createElement("h1", {
-		className: "next-error-h1",
-		style: styles.h1
-	}, STATUS), React.createElement("div", { style: styles.desc }, React.createElement("h2", { style: styles.h2 }, MESSAGE)))));
+	return React.createElement(HTTPAccessErrorFallback, {
+		status: 404,
+		message: "This page could not be found."
+	});
 }
 //#endregion
 export { DefaultNotFound as default };

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

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

package/dist/shims/default-unauthorized.js

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

package/dist/shims/dynamic.js

@@ -52,13 +52,26 @@ function normalizeDynamicOptions(dynamicInput, options) {
 		...options
 	};
 }
-function createLazyComponent(loader) {
-	return React.lazy(async () => {
+function createLazyComponent(loader, share = (load) => load) {
+	return React.lazy(() => share((async () => {
 		const mod = await loader();
 		if (hasDefaultExport(mod)) return mod;
 		return { default: mod };
-	});
+	})()));
 }
+const SHARE_ISOLATE_PROMISE_KEY = Symbol.for("vinext.shareIsolatePromise");
+/**
+* The server React.lazy is created once per dynamic() call, so every request
+* in the isolate renders the same load. On Workers, the request that starts it
+* owns its I/O; if that request is canceled first, the load never settles and
+* every later render of the component hangs. The server installs
+* `shareIsolatePromise` on a global symbol, which keeps the starting request
+* alive until the load settles, without this shim importing request state.
+*/
+const shareServerLoad = (load) => {
+	const share = globalThis[SHARE_ISOLATE_PROMISE_KEY];
+	return share ? share(load) : load;
+};
 function useRetryableLazyComponent(loader, initialLazyComponent) {
 	const [LazyComponent, setLazyComponent] = React.useState(() => initialLazyComponent);
 	const [retryKey, setRetryKey] = React.useState(0);
@@ -218,7 +231,7 @@ function dynamic(dynamicInput, options) {
 			AsyncServerDynamic.displayName = "DynamicAsyncServer";
 			return AsyncServerDynamic;
 		}
-		const LazyServer = createLazyComponent(loader);
+		const LazyServer = createLazyComponent(loader, shareServerLoad);
 		const ServerDynamic = (props) => {
 			const isAppRouterTree = useIsAppRouterTree();
 			const fallback = LoadingComponent ? React.createElement(LoadingComponent, createDynamicLoadingProps()) : null;

package/dist/shims/error-boundary.d.ts

@@ -78,12 +78,47 @@ type NotFoundBoundaryProps = {
   fallback: React.ReactNode;
   children: React.ReactNode;
   resetKey?: string | null;
+  /** A parallel slot boundary's id, which the document may render caught. */
+  caughtId?: string;
 };
+type NotFoundBoundaryInnerProps = {
+  pathname: string | null;
+  initiallyNotFound?: boolean;
+} & NotFoundBoundaryProps;
+type NotFoundBoundaryState = {
+  notFound: boolean;
+  previousPathname: string | null;
+  previousResetKey: string | null;
+};
+/**
+ * Inner class component that catches notFound() errors and renders the
+ * not-found.tsx fallback. Resets when the pathname or the caller's segment
+ * reset key changes.
+ *
+ * The ErrorBoundary above re-throws notFound errors so they propagate up to this
+ * boundary. This must be placed above the ErrorBoundary in the component tree.
+ */
+export declare class NotFoundBoundaryInner extends React.Component<NotFoundBoundaryInnerProps, NotFoundBoundaryState> {
+  constructor(props: NotFoundBoundaryInnerProps);
+  componentDidMount(): void;
+  static getDerivedStateFromProps(props: NotFoundBoundaryInnerProps, state: NotFoundBoundaryState): NotFoundBoundaryState | null;
+  static getDerivedStateFromError(error: unknown): Partial<NotFoundBoundaryState>;
+  render(): string | number | bigint | boolean | React.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | Iterable<React.ReactNode> | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | React.ReactPortal | null | undefined> | null | undefined;
+}
+/**
+ * Fallback for a page-level access boundary whose file belongs to an ancestor
+ * layout. Rethrowing from the fallback hands the signal to the next boundary
+ * up, so that layout's copy renders in place of the layouts below it while the
+ * page-level boundary keeps the element shape sibling routes share.
+ */
+export declare function HttpAccessFallbackPassthrough({ status }: {
+  status: 401 | 403 | 404;
+}): never;
 /**
  * Wrapper that reads the current pathname and passes it to the inner class
- * component. Segment reset keys own App Router remount semantics when present.
+ * component.
  */
-export declare function NotFoundBoundary({ fallback, children, resetKey }: NotFoundBoundaryProps): React.JSX.Element;
+export declare function NotFoundBoundary({ fallback, children, resetKey, caughtId }: NotFoundBoundaryProps): React.JSX.Element;
 type ForbiddenBoundaryProps = {
   fallback: React.ReactNode;
   children: React.ReactNode;
@@ -144,4 +179,5 @@ export declare class DevRecoveryBoundary extends React.Component<DevRecoveryBoun
   componentDidCatch(): void;
   render(): React.ReactNode;
 }
-//#endregion
+//#endregion
+export {};

package/dist/shims/error-boundary.js

@@ -1,11 +1,12 @@
 "use client";
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
-import { decodeRedirectError, isRedirectError } from "./navigation-errors.js";
+import { decodeRedirectError, forbidden, isRedirectError, notFound, unauthorized } from "./navigation-errors.js";
 import "./navigation-server.js";
 import { isRedirectToCurrentUrl, useErrorBoundaryPathname, useErrorBoundaryRouter } from "./error-boundary-navigation.js";
 import DefaultGlobalError from "./default-global-error.js";
 import { handleAppNavigationFailure } from "../client/app-nav-failure-handler.js";
 import { VINEXT_DEV_ERROR_RECOVERY_EVENT } from "../utils/dev-error-recovery-event.js";
+import { consumeCaughtNotFoundBoundary, useCaughtNotFoundBoundary } from "./caught-not-found-boundaries.js";
 import React from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 //#region src/shims/error-boundary.tsx
@@ -29,11 +30,8 @@ function readBoundaryResetState(props) {
 		previousResetKey: normalizeBoundaryResetKey(props.resetKey)
 	};
 }
-function shouldResetBoundary(nextResetState, previousResetState) {
-	const nextResetKey = normalizeBoundaryResetKey(nextResetState.previousResetKey);
-	const previousResetKey = normalizeBoundaryResetKey(previousResetState.previousResetKey);
-	if (nextResetKey !== null || previousResetKey !== null) return nextResetKey !== previousResetKey;
-	return nextResetState.previousPathname !== previousResetState.previousPathname;
+function shouldResetSegmentBoundary(nextResetState, previousResetState) {
+	return nextResetState.previousPathname !== previousResetState.previousPathname || normalizeBoundaryResetKey(nextResetState.previousResetKey) !== normalizeBoundaryResetKey(previousResetState.previousResetKey);
 }
 function addDevErrorRecoveryListener(listener) {
 	if (typeof window === "undefined") return;
@@ -136,7 +134,7 @@ var ErrorBoundaryInner = class extends React.Component {
 			error: null,
 			...nextResetState
 		};
-		if (state.error && shouldResetBoundary(nextResetState, state)) return {
+		if (state.error && shouldResetSegmentBoundary(nextResetState, state)) return {
 			error: null,
 			...nextResetState
 		};
@@ -196,8 +194,8 @@ function GlobalErrorBoundary({ fallback, children }) {
 }
 /**
 * Inner class component that catches notFound() errors and renders the
-* not-found.tsx fallback. Resets on the caller's segment reset key when one is
-* provided, otherwise falls back to pathname changes for legacy callers.
+* not-found.tsx fallback. Resets when the pathname or the caller's segment
+* reset key changes.
 *
 * The ErrorBoundary above re-throws notFound errors so they propagate up to this
 * boundary. This must be placed above the ErrorBoundary in the component tree.
@@ -206,13 +204,16 @@ var NotFoundBoundaryInner = class extends React.Component {
 	constructor(props) {
 		super(props);
 		this.state = {
-			notFound: false,
+			notFound: props.initiallyNotFound === true,
 			...readBoundaryResetState(props)
 		};
 	}
+	componentDidMount() {
+		if (this.props.initiallyNotFound === true) consumeCaughtNotFoundBoundary(this.props.caughtId);
+	}
 	static getDerivedStateFromProps(props, state) {
 		const nextResetState = readBoundaryResetState(props);
-		if (state.notFound && shouldResetBoundary(nextResetState, state)) return {
+		if (state.notFound && shouldResetSegmentBoundary(nextResetState, state)) return {
 			notFound: false,
 			...nextResetState
 		};
@@ -237,15 +238,29 @@ var NotFoundBoundaryInner = class extends React.Component {
 	}
 };
 /**
+* Fallback for a page-level access boundary whose file belongs to an ancestor
+* layout. Rethrowing from the fallback hands the signal to the next boundary
+* up, so that layout's copy renders in place of the layouts below it while the
+* page-level boundary keeps the element shape sibling routes share.
+*/
+function HttpAccessFallbackPassthrough({ status }) {
+	if (status === 403) forbidden();
+	if (status === 401) unauthorized();
+	notFound();
+}
+/**
 * Wrapper that reads the current pathname and passes it to the inner class
-* component. Segment reset keys own App Router remount semantics when present.
+* component.
 */
-function NotFoundBoundary({ fallback, children, resetKey }) {
+function NotFoundBoundary({ fallback, children, resetKey, caughtId }) {
 	const pathname = useErrorBoundaryPathname();
+	const initiallyNotFound = useCaughtNotFoundBoundary(caughtId);
 	return /* @__PURE__ */ jsx(NotFoundBoundaryInner, {
 		pathname,
 		resetKey,
 		fallback,
+		caughtId,
+		initiallyNotFound,
 		children
 	});
 }
@@ -259,7 +274,7 @@ var ForbiddenBoundaryInner = class extends React.Component {
 	}
 	static getDerivedStateFromProps(props, state) {
 		const nextResetState = readBoundaryResetState(props);
-		if (state.forbidden && shouldResetBoundary(nextResetState, state)) return {
+		if (state.forbidden && shouldResetSegmentBoundary(nextResetState, state)) return {
 			forbidden: false,
 			...nextResetState
 		};
@@ -301,7 +316,7 @@ var UnauthorizedBoundaryInner = class extends React.Component {
 	}
 	static getDerivedStateFromProps(props, state) {
 		const nextResetState = readBoundaryResetState(props);
-		if (state.unauthorized && shouldResetBoundary(nextResetState, state)) return {
+		if (state.unauthorized && shouldResetSegmentBoundary(nextResetState, state)) return {
 			unauthorized: false,
 			...nextResetState
 		};
@@ -374,4 +389,4 @@ var DevRecoveryBoundary = class extends React.Component {
 	}
 };
 //#endregion
-export { DevRecoveryBoundary, ErrorBoundary, ErrorBoundaryInner, ForbiddenBoundary, ForbiddenBoundaryInner, GlobalErrorBoundary, NotFoundBoundary, RedirectBoundary, RedirectErrorBoundary, SerializedErrorBoundary, UnauthorizedBoundary, UnauthorizedBoundaryInner };
+export { DevRecoveryBoundary, ErrorBoundary, ErrorBoundaryInner, ForbiddenBoundary, ForbiddenBoundaryInner, GlobalErrorBoundary, HttpAccessFallbackPassthrough, NotFoundBoundary, NotFoundBoundaryInner, RedirectBoundary, RedirectErrorBoundary, SerializedErrorBoundary, UnauthorizedBoundary, UnauthorizedBoundaryInner };

package/dist/shims/font-google.js

@@ -1,2 +1 @@
-import googleFonts, { buildGoogleFontsUrl, createFontLoader, getSSRFontLinks, getSSRFontPreloads, getSSRFontStyles } from "./font-google-base.js";
-export { buildGoogleFontsUrl, createFontLoader, googleFonts as default, getSSRFontLinks, getSSRFontPreloads, getSSRFontStyles };
+export { buildGoogleFontsUrl, createFontLoader, default, getSSRFontLinks, getSSRFontPreloads, getSSRFontStyles } from "./font-google-base.js";

package/dist/shims/font-utils.d.ts

@@ -47,9 +47,10 @@ export declare function resolveGoogleFontStyle(style: string | string[] | undefi
 export declare function resolveSingleFaceStyle(input: FontFaceStyleInput): FontStyle;
 export declare function formatFontClassRule(className: string, style: FontStyle): string;
 /**
- * Determine the MIME type for a font file based on its extension.
+ * Determine the preload `type` for a font file based on its extension.
  * Uses endsWith() only to avoid false positives from substring matches
- * (e.g. ".woff" matching ".woff2").
+ * (e.g. ".woff" matching ".woff2"). Matches Next.js, which emits
+ * `font/${ext}` for every font preload (including `font/eot`).
  */
 export declare function getFontMimeType(pathOrUrl: string): string;
 //#endregion