vinext 0.0.54 → 0.1.0

package/dist/server/app-page-stream.d.ts

@@ -1,3 +1,4 @@
+import { NavigationContext } from "../shims/navigation.js";
 import { AppPageFontPreload } from "./app-page-execution.js";
 import { RootParams } from "../shims/root-params.js";
 import { ReactFormState } from "react-dom/client";
@@ -13,8 +14,14 @@ type CreateAppPageFontDataOptions = {
   getPreloads: () => AppPageFontPreload[];
   getStyles: () => string[];
 };
+type AppSsrRenderResult = {
+  htmlStream: ReadableStream<Uint8Array>;
+  metadataReady: Promise<void>;
+  capturedRscData: Promise<ArrayBuffer> | null;
+};
+declare function isAppSsrRenderResult(value: unknown): value is AppSsrRenderResult;
 type AppPageSsrHandler = {
-  handleSsr: (rscStream: ReadableStream<Uint8Array>, navigationContext: unknown, fontData: AppPageFontData, options?: {
+  handleSsr: (rscStream: ReadableStream<Uint8Array>, navigationContext: NavigationContext | null, fontData: AppPageFontData, options?: {
     formState?: ReactFormState | null;
     scriptNonce?: string;
     basePath?: string;
@@ -28,13 +35,14 @@ type AppPageSsrHandler = {
     capturedRscDataRef?: {
       value: Promise<ArrayBuffer> | null;
     }; /** When true, wait for the full React tree before emitting bytes. */
-    waitForAllReady?: boolean;
-  }) => Promise<ReadableStream<Uint8Array>>;
+    waitForAllReady?: boolean; /** Dev-only: original server error to surface in the browser overlay. */
+    initialDevServerError?: unknown;
+  }) => Promise<ReadableStream<Uint8Array> | AppSsrRenderResult>;
 };
 type RenderAppPageHtmlStreamOptions = {
   fontData: AppPageFontData;
   formState?: ReactFormState | null;
-  navigationContext: unknown;
+  navigationContext: NavigationContext | null;
   rscStream: ReadableStream<Uint8Array>;
   scriptNonce?: string;
   basePath?: string;
@@ -52,7 +60,8 @@ type RenderAppPageHtmlStreamOptions = {
   capturedRscDataRef?: {
     value: Promise<ArrayBuffer> | null;
   }; /** When true, wait for the full React tree before emitting bytes. */
-  waitForAllReady?: boolean;
+  waitForAllReady?: boolean; /** Dev-only: original server error to surface in the browser overlay. */
+  initialDevServerError?: unknown;
 };
 type RenderAppPageHtmlResponseOptions = {
   clearRequestContext: () => void;
@@ -64,11 +73,13 @@ type RenderAppPageHtmlResponseOptions = {
 type AppPageHtmlStreamRecoveryResult = {
   htmlStream: ReadableStream<Uint8Array> | null;
   response: Response | null;
+  metadataReady: Promise<void>;
+  capturedRscData: Promise<ArrayBuffer> | null;
 };
 type RenderAppPageHtmlStreamWithRecoveryOptions<TSpecialError> = {
   onShellRendered?: () => void;
   renderErrorBoundaryResponse: (error: unknown) => Promise<Response | null>;
-  renderHtmlStream: () => Promise<ReadableStream<Uint8Array>>;
+  renderHtmlStream: () => Promise<ReadableStream<Uint8Array> | AppSsrRenderResult>;
   renderSpecialErrorResponse: (specialError: TSpecialError) => Promise<Response>;
   resolveSpecialError: (error: unknown) => TSpecialError | null;
 };
@@ -88,7 +99,7 @@ type ShouldRerenderAppPageWithGlobalErrorOptions = {
   hasLocalBoundary: boolean;
 };
 declare function createAppPageFontData(options: CreateAppPageFontDataOptions): AppPageFontData;
-declare function renderAppPageHtmlStream(options: RenderAppPageHtmlStreamOptions): Promise<ReadableStream<Uint8Array>>;
+declare function renderAppPageHtmlStream(options: RenderAppPageHtmlStreamOptions): Promise<AppSsrRenderResult>;
 /**
  * Wraps a stream so that `onFlush` is called when the last byte has been read
  * by the downstream consumer (i.e. when the HTTP layer finishes draining the
@@ -102,5 +113,4 @@ declare function renderAppPageHtmlStreamWithRecovery<TSpecialError>(options: Ren
 declare function createAppPageRscErrorTracker(baseOnError: (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown): AppPageRscErrorTracker;
 declare function shouldRerenderAppPageWithGlobalError(options: ShouldRerenderAppPageWithGlobalErrorOptions): boolean;
 //#endregion
-export { AppPageFontData, AppPageSsrHandler, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError };
-//# sourceMappingURL=app-page-stream.d.ts.map
+export { AppPageFontData, AppPageSsrHandler, AppSsrRenderResult, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError };

package/dist/server/app-page-stream.js

@@ -2,6 +2,18 @@ import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 //#region src/server/app-page-stream.ts
+function isAppSsrRenderResult(value) {
+	return typeof value === "object" && value !== null && "htmlStream" in value && "metadataReady" in value;
+}
+const resolvedMetadataReady = Promise.resolve();
+function normalizeAppSsrRenderResult(raw, fallbackCapturedRscData = null) {
+	if (isAppSsrRenderResult(raw)) return raw;
+	return {
+		htmlStream: raw,
+		metadataReady: resolvedMetadataReady,
+		capturedRscData: fallbackCapturedRscData
+	};
+}
 function createAppPageFontData(options) {
 	return {
 		links: options.getLinks(),
@@ -18,9 +30,10 @@ async function renderAppPageHtmlStream(options) {
 		rootParams: options.rootParams,
 		sideStream: options.sideStream,
 		capturedRscDataRef: options.capturedRscDataRef,
-		waitForAllReady: options.waitForAllReady
+		waitForAllReady: options.waitForAllReady,
+		initialDevServerError: options.initialDevServerError
 	};
-	return options.ssrHandler.handleSsr(options.rscStream, options.navigationContext, options.fontData, ssrOptions);
+	return normalizeAppSsrRenderResult(await options.ssrHandler.handleSsr(options.rscStream, options.navigationContext, options.fontData, ssrOptions), options.capturedRscDataRef?.value ?? null);
 }
 /**
 * Wraps a stream so that `onFlush` is called when the last byte has been read
@@ -58,7 +71,8 @@ function deferUntilStreamConsumed(stream, onFlush) {
 	});
 }
 async function renderAppPageHtmlResponse(options) {
-	const safeStream = deferUntilStreamConsumed(await renderAppPageHtmlStream(options), () => {
+	const { htmlStream } = await renderAppPageHtmlStream(options);
+	const safeStream = deferUntilStreamConsumed(htmlStream, () => {
 		options.clearRequestContext();
 	});
 	const headers = new Headers({
@@ -75,22 +89,28 @@ async function renderAppPageHtmlResponse(options) {
 }
 async function renderAppPageHtmlStreamWithRecovery(options) {
 	try {
-		const htmlStream = await options.renderHtmlStream();
+		const { htmlStream, metadataReady, capturedRscData } = normalizeAppSsrRenderResult(await options.renderHtmlStream());
 		options.onShellRendered?.();
 		return {
 			htmlStream,
-			response: null
+			response: null,
+			metadataReady,
+			capturedRscData
 		};
 	} catch (error) {
 		const specialError = options.resolveSpecialError(error);
 		if (specialError) return {
 			htmlStream: null,
-			response: await options.renderSpecialErrorResponse(specialError)
+			response: await options.renderSpecialErrorResponse(specialError),
+			metadataReady: resolvedMetadataReady,
+			capturedRscData: null
 		};
 		const boundaryResponse = await options.renderErrorBoundaryResponse(error);
 		if (boundaryResponse) return {
 			htmlStream: null,
-			response: boundaryResponse
+			response: boundaryResponse,
+			metadataReady: resolvedMetadataReady,
+			capturedRscData: null
 		};
 		throw error;
 	}
@@ -117,6 +137,4 @@ function shouldRerenderAppPageWithGlobalError(options) {
 	return Boolean(options.capturedError) && !options.hasLocalBoundary;
 }
 //#endregion
-export { createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError };
-
-//# sourceMappingURL=app-page-stream.js.map
+export { createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError };

package/dist/server/app-pages-bridge.d.ts

@@ -0,0 +1,25 @@
+import { AppMiddlewareContext } from "./app-middleware.js";
+
+//#region src/server/app-pages-bridge.d.ts
+type PagesEntry = {
+  handleApiRoute?: (request: Request, url: string) => Promise<Response> | Response;
+  renderPage?: (request: Request, url: string, query: Record<string, unknown>, parsedUrl: unknown, middlewareRequestHeaders?: Headers | null) => Promise<Response> | Response;
+};
+type RenderPagesFallbackDependencies = {
+  loadPagesEntry: () => Promise<PagesEntry> | PagesEntry;
+  buildRequestHeaders: (requestHeaders: Headers, middlewareRequestHeaders: Headers) => Headers | null;
+  decodePathParams: (pathname: string) => string;
+  applyRouteHandlerMiddlewareContext: (response: Response, middlewareContext: AppMiddlewareContext) => Response;
+};
+type RenderPagesFallbackOptions = {
+  isRscRequest: boolean;
+  middlewareContext: AppMiddlewareContext;
+  request: Request;
+  url: URL;
+};
+/**
+ * Fallback handler to route App Router requests to the Pages Router when no App Router route matches.
+ */
+declare function renderPagesFallback(options: RenderPagesFallbackOptions, dependencies: RenderPagesFallbackDependencies): Promise<Response | null>;
+//#endregion
+export { PagesEntry, renderPagesFallback };

package/dist/server/app-pages-bridge.js

@@ -0,0 +1,34 @@
+//#region src/server/app-pages-bridge.ts
+/**
+* Fallback handler to route App Router requests to the Pages Router when no App Router route matches.
+*/
+async function renderPagesFallback(options, dependencies) {
+	const { isRscRequest, middlewareContext, request, url } = options;
+	const { loadPagesEntry, buildRequestHeaders, decodePathParams, applyRouteHandlerMiddlewareContext } = dependencies;
+	if (isRscRequest) return null;
+	const pagesEntry = await loadPagesEntry();
+	const pagesRequestHeaders = middlewareContext.requestHeaders ? buildRequestHeaders(request.headers, middlewareContext.requestHeaders) : null;
+	let pagesRequest = request;
+	if (pagesRequestHeaders) {
+		const pagesRequestInit = {
+			method: request.method,
+			headers: pagesRequestHeaders
+		};
+		if (request.method !== "GET" && request.method !== "HEAD") {
+			pagesRequestInit.body = request.body;
+			pagesRequestInit.duplex = "half";
+		}
+		pagesRequest = new Request(request.url, pagesRequestInit);
+	}
+	const pagesUrl = decodePathParams(url.pathname) + (url.search || "");
+	const pagesPathname = url.pathname;
+	if (pagesPathname.startsWith("/api/") || pagesPathname === "/api") {
+		if (typeof pagesEntry.handleApiRoute !== "function") return null;
+		return applyRouteHandlerMiddlewareContext(await pagesEntry.handleApiRoute(pagesRequest, pagesUrl), middlewareContext);
+	}
+	if (typeof pagesEntry.renderPage !== "function") return null;
+	const pagesRes = await pagesEntry.renderPage(pagesRequest, pagesUrl, {}, void 0, middlewareContext.requestHeaders);
+	return pagesRes.status !== 404 ? pagesRes : null;
+}
+//#endregion
+export { renderPagesFallback };

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

@@ -12,5 +12,4 @@ import { RequestContext } from "../config/config-matchers.js";
  */
 declare function buildPostMwRequestContext(request: Request): RequestContext;
 //#endregion
-export { buildPostMwRequestContext };
-//# sourceMappingURL=app-post-middleware-context.d.ts.map
+export { buildPostMwRequestContext };

package/dist/server/app-post-middleware-context.js

@@ -24,5 +24,3 @@ function buildPostMwRequestContext(request) {
 }
 //#endregion
 export { buildPostMwRequestContext };
-
-//# sourceMappingURL=app-post-middleware-context.js.map

package/dist/server/app-ppr-fallback-shell.d.ts

@@ -0,0 +1,21 @@
+//#region src/server/app-ppr-fallback-shell.d.ts
+type AppPprFallbackShellRoute = {
+  params: readonly string[];
+  pattern: string;
+  rootParamNames?: readonly string[] | null;
+};
+type AppPprFallbackShell = {
+  fallbackParamNames: readonly string[];
+  pathname: string;
+  params: Record<string, string | string[]>;
+};
+declare function createAppPprFallbackShell(route: AppPprFallbackShellRoute, matchedParams: Record<string, string | string[]>): AppPprFallbackShell | null;
+declare function createAppPprFallbackShells(route: AppPprFallbackShellRoute, matchedParams: Record<string, string | string[]>): AppPprFallbackShell[];
+declare function rewriteAppPprFallbackShellHtmlNavigation(options: {
+  html: string;
+  params: Record<string, string | string[]>;
+  pathname: string;
+  searchParams: URLSearchParams;
+}): string;
+//#endregion
+export { createAppPprFallbackShell, createAppPprFallbackShells, rewriteAppPprFallbackShellHtmlNavigation };

package/dist/server/app-ppr-fallback-shell.js

@@ -0,0 +1,82 @@
+import { createInlineScriptTag } from "./html.js";
+import { createNavigationRuntimeRscMetadataScript } from "./app-ssr-stream.js";
+//#region src/server/app-ppr-fallback-shell.ts
+function routeRootParamNames(route) {
+	return new Set(route.rootParamNames ?? []);
+}
+function placeholderForParam(part, paramName) {
+	if (part.endsWith("+")) return [`[...${paramName}]`];
+	if (part.endsWith("*")) return [`[[...${paramName}]]`];
+	return `[${paramName}]`;
+}
+function pushParamValue(segments, value) {
+	if (Array.isArray(value)) {
+		if (value.length === 0) return false;
+		segments.push(...value.map((item) => encodeURIComponent(item)));
+		return true;
+	}
+	if (typeof value !== "string") return false;
+	segments.push(encodeURIComponent(value));
+	return true;
+}
+function createAppPprFallbackShell(route, matchedParams) {
+	return createAppPprFallbackShells(route, matchedParams).at(-1) ?? null;
+}
+function createAppPprFallbackShells(route, matchedParams) {
+	const rootParamNames = routeRootParamNames(route);
+	if (rootParamNames.size === 0) return [];
+	let minKeptParamCount = 0;
+	for (const rootParamName of rootParamNames) {
+		const rootParamIndex = route.params.indexOf(rootParamName);
+		if (rootParamIndex === -1 || matchedParams[rootParamName] === void 0) return [];
+		minKeptParamCount = Math.max(minKeptParamCount, rootParamIndex + 1);
+	}
+	if (minKeptParamCount >= route.params.length) return [];
+	const shells = [];
+	for (let keptParamCount = route.params.length - 1; keptParamCount >= minKeptParamCount; keptParamCount--) {
+		const keptParamNames = new Set(route.params.slice(0, keptParamCount));
+		const fallbackParamNames = route.params.filter((name) => !keptParamNames.has(name));
+		if (fallbackParamNames.length === 0) continue;
+		const fallbackParamNameSet = new Set(fallbackParamNames);
+		const segments = [];
+		const fallbackParams = {};
+		let isValidShell = true;
+		for (const part of route.pattern.split("/").filter(Boolean)) {
+			if (part.startsWith(":")) {
+				const paramName = part.endsWith("+") || part.endsWith("*") ? part.slice(1, -1) : part.slice(1);
+				if (fallbackParamNameSet.has(paramName)) {
+					const placeholder = placeholderForParam(part, paramName);
+					segments.push(...Array.isArray(placeholder) ? placeholder : [placeholder]);
+					fallbackParams[paramName] = placeholder;
+					continue;
+				}
+				const value = matchedParams[paramName];
+				if (!pushParamValue(segments, value)) {
+					isValidShell = false;
+					break;
+				}
+				fallbackParams[paramName] = value;
+				continue;
+			}
+			segments.push(part);
+		}
+		if (!isValidShell) continue;
+		shells.push({
+			fallbackParamNames,
+			pathname: "/" + segments.join("/"),
+			params: fallbackParams
+		});
+	}
+	return shells;
+}
+function rewriteAppPprFallbackShellHtmlNavigation(options) {
+	const metadataScript = createInlineScriptTag(createNavigationRuntimeRscMetadataScript(options.params, {
+		pathname: options.pathname,
+		searchParams: [...options.searchParams.entries()]
+	}));
+	const headCloseIndex = options.html.indexOf("</head>");
+	if (headCloseIndex !== -1) return options.html.slice(0, headCloseIndex) + metadataScript + options.html.slice(headCloseIndex);
+	return metadataScript + options.html;
+}
+//#endregion
+export { createAppPprFallbackShell, createAppPprFallbackShells, rewriteAppPprFallbackShellHtmlNavigation };

package/dist/server/app-prerender-endpoints.d.ts

@@ -15,5 +15,4 @@ type HandleAppPrerenderEndpointOptions = {
 };
 declare function handleAppPrerenderEndpoint(request: Request, options: HandleAppPrerenderEndpointOptions): Promise<Response | null>;
 //#endregion
-export { handleAppPrerenderEndpoint };
-//# sourceMappingURL=app-prerender-endpoints.d.ts.map
+export { handleAppPrerenderEndpoint };

package/dist/server/app-prerender-endpoints.js

@@ -93,5 +93,3 @@ function isStringArray(value) {
 }
 //#endregion
 export { handleAppPrerenderEndpoint };
-
-//# sourceMappingURL=app-prerender-endpoints.js.map

package/dist/server/app-prerender-static-params.d.ts

@@ -4,6 +4,20 @@ import { RootParams } from "../shims/root-params.js";
 type GenerateStaticParamsFunction = (input: {
   params: RootParams;
 }) => unknown;
+/**
+ * Build a prerender `generateStaticParams` resolver for one route pattern.
+ *
+ * `sources` may mix eager functions (layout `generateStaticParams`, which stay
+ * eagerly imported) and lazy `{ load }` page sources (code-split page modules).
+ * Lazy sources are imported once on first invocation. The returned resolver:
+ *
+ *  - returns `null` when, after resolving every source, no `generateStaticParams`
+ *    export exists for the pattern — the sentinel the prerender driver uses to
+ *    skip the route (or error under `output: export`);
+ *  - otherwise composes all sources into the cartesian set of param objects.
+ *
+ * Returns `null` (no resolver) only when the pattern has zero sources at all.
+ */
 declare function createAppPrerenderStaticParamsResolver(sources: readonly unknown[], rootParamNames?: readonly string[]): GenerateStaticParamsFunction | null;
 type CallAppPrerenderStaticParamsOptions = {
   fn: GenerateStaticParamsFunction;
@@ -13,5 +27,4 @@ type CallAppPrerenderStaticParamsOptions = {
 };
 declare function callAppPrerenderStaticParams(options: CallAppPrerenderStaticParamsOptions): Promise<unknown>;
 //#endregion
-export { callAppPrerenderStaticParams, createAppPrerenderStaticParamsResolver };
-//# sourceMappingURL=app-prerender-static-params.d.ts.map
+export { callAppPrerenderStaticParams, createAppPrerenderStaticParamsResolver };

package/dist/server/app-prerender-static-params.js

@@ -1,29 +1,62 @@
+import { isUnknownRecord } from "../utils/record.js";
 import { pickRootParams, runWithRootParamsScope } from "../shims/root-params.js";
 //#region src/server/app-prerender-static-params.ts
 function isGenerateStaticParamsFunction(value) {
 	return typeof value === "function";
 }
+function isLazyStaticParamsSource(value) {
+	return typeof value === "object" && value !== null && "load" in value && typeof value.load === "function";
+}
 function isRootParams(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
+	return isUnknownRecord(value);
 }
+/**
+* Build a prerender `generateStaticParams` resolver for one route pattern.
+*
+* `sources` may mix eager functions (layout `generateStaticParams`, which stay
+* eagerly imported) and lazy `{ load }` page sources (code-split page modules).
+* Lazy sources are imported once on first invocation. The returned resolver:
+*
+*  - returns `null` when, after resolving every source, no `generateStaticParams`
+*    export exists for the pattern — the sentinel the prerender driver uses to
+*    skip the route (or error under `output: export`);
+*  - otherwise composes all sources into the cartesian set of param objects.
+*
+* Returns `null` (no resolver) only when the pattern has zero sources at all.
+*/
 function createAppPrerenderStaticParamsResolver(sources, rootParamNames) {
-	const generateStaticParamsFns = sources.filter(isGenerateStaticParamsFunction);
-	if (generateStaticParamsFns.length === 0) return null;
+	const usableSources = sources.filter((source) => isGenerateStaticParamsFunction(source) || isLazyStaticParamsSource(source));
+	if (usableSources.length === 0) return null;
 	const filterRootParams = (params) => pickRootParams(params, rootParamNames ?? []);
-	if (generateStaticParamsFns.length === 1) {
-		const single = generateStaticParamsFns[0];
-		return async (input) => {
+	let resolvedFns = null;
+	let resolvePromise = null;
+	const resolveFns = () => {
+		if (resolvedFns) return Promise.resolve(resolvedFns);
+		if (!resolvePromise) resolvePromise = (async () => {
+			resolvedFns = (await Promise.all(usableSources.map(async (source) => {
+				if (isGenerateStaticParamsFunction(source)) return source;
+				const mod = await source.load();
+				const fn = mod && typeof mod === "object" ? mod.generateStaticParams : void 0;
+				return isGenerateStaticParamsFunction(fn) ? fn : null;
+			}))).filter((fn) => fn !== null);
+			return resolvedFns;
+		})();
+		return resolvePromise;
+	};
+	return async (input) => {
+		const fns = await resolveFns();
+		if (fns.length === 0) return null;
+		if (fns.length === 1) {
+			const single = fns[0];
 			return runWithRootParamsScope(filterRootParams(input.params), async () => {
 				const result = await single(input);
 				if (!Array.isArray(result)) return [];
 				for (const item of result) if (!isRootParams(item)) return [];
 				return result;
 			});
-		};
-	}
-	return async ({ params }) => {
-		let paramSets = [params];
-		for (const generateStaticParams of generateStaticParamsFns) {
+		}
+		let paramSets = [input.params];
+		for (const generateStaticParams of fns) {
 			const nextParamSets = [];
 			for (const parentParams of paramSets) {
 				const result = await runWithRootParamsScope(filterRootParams(parentParams), async () => generateStaticParams({ params: parentParams }));
@@ -46,5 +79,3 @@ async function callAppPrerenderStaticParams(options) {
 }
 //#endregion
 export { callAppPrerenderStaticParams, createAppPrerenderStaticParamsResolver };
-
-//# sourceMappingURL=app-prerender-static-params.js.map

package/dist/server/app-render-dependency.d.ts

@@ -5,9 +5,10 @@ type AppRenderDependency = {
   promise: Promise<void>;
   release: () => void;
 };
+declare function registerAppElementRenderDependencies(elements: Readonly<Record<string, unknown>>, dependenciesByElementId: ReadonlyMap<string, AppRenderDependency>): void;
+declare function releaseAppElementRenderDependency(elements: Readonly<Record<string, unknown>>, elementId: string): void;
 declare function createAppRenderDependency(): AppRenderDependency;
 declare function renderAfterAppDependencies(children: ReactNode, dependencies: readonly AppRenderDependency[]): ReactNode;
 declare function renderWithAppDependencyBarrier(children: ReactNode, dependency: AppRenderDependency): ReactNode;
 //#endregion
-export { AppRenderDependency, createAppRenderDependency, renderAfterAppDependencies, renderWithAppDependencyBarrier };
-//# sourceMappingURL=app-render-dependency.d.ts.map
+export { AppRenderDependency, createAppRenderDependency, registerAppElementRenderDependencies, releaseAppElementRenderDependency, renderAfterAppDependencies, renderWithAppDependencyBarrier };

package/dist/server/app-render-dependency.js

@@ -1,5 +1,13 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 //#region src/server/app-render-dependency.tsx
+const appElementRenderDependencies = /* @__PURE__ */ new WeakMap();
+function registerAppElementRenderDependencies(elements, dependenciesByElementId) {
+	if (dependenciesByElementId.size === 0) return;
+	appElementRenderDependencies.set(elements, dependenciesByElementId);
+}
+function releaseAppElementRenderDependency(elements, elementId) {
+	appElementRenderDependencies.get(elements)?.get(elementId)?.release();
+}
 function createAppRenderDependency() {
 	let released = false;
 	let resolve;
@@ -30,6 +38,4 @@ function renderWithAppDependencyBarrier(children, dependency) {
 	return /* @__PURE__ */ jsxs(Fragment, { children: [children, /* @__PURE__ */ jsx(ReleaseAppRenderDependency, {})] });
 }
 //#endregion
-export { createAppRenderDependency, renderAfterAppDependencies, renderWithAppDependencyBarrier };
-
-//# sourceMappingURL=app-render-dependency.js.map
+export { createAppRenderDependency, registerAppElementRenderDependencies, releaseAppElementRenderDependency, renderAfterAppDependencies, renderWithAppDependencyBarrier };

package/dist/server/app-request-context.d.ts

@@ -18,5 +18,4 @@ declare function setAppNavigationContext(ctx: NavigationContext | null): void;
  */
 declare function clearAppRequestContext(): void;
 //#endregion
-export { clearAppRequestContext, setAppNavigationContext };
-//# sourceMappingURL=app-request-context.d.ts.map
+export { clearAppRequestContext, setAppNavigationContext };

package/dist/server/app-request-context.js

@@ -26,5 +26,3 @@ function clearAppRequestContext() {
 }
 //#endregion
 export { clearAppRequestContext, setAppNavigationContext };
-
-//# sourceMappingURL=app-request-context.js.map

package/dist/server/app-route-handler-cache.d.ts

@@ -42,5 +42,4 @@ type ReadAppRouteHandlerCacheOptions = {
 };
 declare function readAppRouteHandlerCacheResponse(options: ReadAppRouteHandlerCacheOptions): Promise<Response | null>;
 //#endregion
-export { readAppRouteHandlerCacheResponse };
-//# sourceMappingURL=app-route-handler-cache.d.ts.map
+export { readAppRouteHandlerCacheResponse };

package/dist/server/app-route-handler-cache.js

@@ -75,5 +75,3 @@ async function readAppRouteHandlerCacheResponse(options) {
 }
 //#endregion
 export { readAppRouteHandlerCacheResponse };
-
-//# sourceMappingURL=app-route-handler-cache.js.map

package/dist/server/app-route-handler-dispatch.d.ts

@@ -45,5 +45,4 @@ type DispatchAppRouteHandlerOptions = {
 };
 declare function dispatchAppRouteHandler(options: DispatchAppRouteHandlerOptions): Promise<Response>;
 //#endregion
-export { dispatchAppRouteHandler };
-//# sourceMappingURL=app-route-handler-dispatch.d.ts.map
+export { dispatchAppRouteHandler };

package/dist/server/app-route-handler-dispatch.js

@@ -151,5 +151,3 @@ async function dispatchAppRouteHandler(options) {
 }
 //#endregion
 export { dispatchAppRouteHandler };
-
-//# sourceMappingURL=app-route-handler-dispatch.js.map

package/dist/server/app-route-handler-execution.d.ts

@@ -82,5 +82,4 @@ type ExecuteAppRouteHandlerOptions = {
 declare function runAppRouteHandler(options: RunAppRouteHandlerOptions): Promise<RunAppRouteHandlerResult>;
 declare function executeAppRouteHandler(options: ExecuteAppRouteHandlerOptions): Promise<Response>;
 //#endregion
-export { AppRouteDebugLogger, AppRouteDynamicUsageFn, AppRouteHandlerFunction, AppRouteParams, MarkAppRouteDynamicUsageFn, RouteHandlerCacheSetter, executeAppRouteHandler, runAppRouteHandler };
-//# sourceMappingURL=app-route-handler-execution.d.ts.map
+export { AppRouteDebugLogger, AppRouteDynamicUsageFn, AppRouteHandlerFunction, AppRouteParams, MarkAppRouteDynamicUsageFn, RouteHandlerCacheSetter, executeAppRouteHandler, runAppRouteHandler };

package/dist/server/app-route-handler-execution.js

@@ -46,6 +46,7 @@ async function executeAppRouteHandler(options) {
 		assertSupportedAppRouteHandlerResponse(response);
 		const handlerSetCacheControl = response.headers.has("cache-control");
 		if (dynamicUsedInHandler) markKnownDynamicAppRoute(options.routePattern);
+		const routeTags = options.buildPageCacheTags(options.cleanPathname, options.getCollectedFetchTags());
 		if (shouldApplyAppRouteHandlerRevalidateHeader({
 			dynamicUsedInHandler,
 			handlerSetCacheControl,
@@ -55,7 +56,7 @@ async function executeAppRouteHandler(options) {
 		})) {
 			const revalidateSeconds = options.revalidateSeconds;
 			if (revalidateSeconds == null) throw new Error("Expected route handler revalidate seconds");
-			applyRouteHandlerRevalidateHeader(response, revalidateSeconds, options.expireSeconds);
+			applyRouteHandlerRevalidateHeader(response, revalidateSeconds, options.expireSeconds, routeTags);
 		}
 		if (shouldWriteAppRouteHandlerCache({
 			dynamicConfig: options.handler.dynamic,
@@ -71,7 +72,6 @@ async function executeAppRouteHandler(options) {
 			const routeKey = options.isrRouteKey(options.cleanPathname);
 			const revalidateSeconds = options.revalidateSeconds;
 			if (revalidateSeconds == null) throw new Error("Expected route handler cache revalidate seconds");
-			const routeTags = options.buildPageCacheTags(options.cleanPathname, options.getCollectedFetchTags());
 			const routeWritePromise = (async () => {
 				try {
 					const routeCacheValue = await buildAppRouteCacheValue(routeClone);
@@ -124,5 +124,3 @@ async function executeAppRouteHandler(options) {
 }
 //#endregion
 export { executeAppRouteHandler, runAppRouteHandler };
-
-//# sourceMappingURL=app-route-handler-execution.js.map

package/dist/server/app-route-handler-policy.d.ts

@@ -51,5 +51,4 @@ declare function shouldApplyAppRouteHandlerRevalidateHeader(options: Omit<AppRou
 declare function shouldWriteAppRouteHandlerCache(options: AppRouteHandlerResponseCacheOptions): boolean;
 declare function resolveAppRouteHandlerSpecialError(error: unknown, requestUrl: string, options?: AppRouteHandlerSpecialErrorOptions): AppRouteHandlerSpecialError | null;
 //#endregion
-export { AppRouteHandlerModule, getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, isPossibleAppRouteActionRequest, resolveAppRouteHandlerMethod, resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldReadAppRouteHandlerCache, shouldWriteAppRouteHandlerCache };
-//# sourceMappingURL=app-route-handler-policy.d.ts.map
+export { AppRouteHandlerModule, getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, isPossibleAppRouteActionRequest, resolveAppRouteHandlerMethod, resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldReadAppRouteHandlerCache, shouldWriteAppRouteHandlerCache };

package/dist/server/app-route-handler-policy.js

@@ -61,5 +61,3 @@ function resolveAppRouteHandlerSpecialError(error, requestUrl, options) {
 }
 //#endregion
 export { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, isPossibleAppRouteActionRequest, resolveAppRouteHandlerMethod, resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldReadAppRouteHandlerCache, shouldWriteAppRouteHandlerCache };
-
-//# sourceMappingURL=app-route-handler-policy.js.map

package/dist/server/app-route-handler-response.d.ts

@@ -20,10 +20,9 @@ type FinalizeRouteHandlerResponseOptions = {
 declare function applyRouteHandlerMiddlewareContext(response: Response, middlewareContext: RouteHandlerMiddlewareContext): Response;
 declare function assertSupportedAppRouteHandlerResponse(response: Response): void;
 declare function buildRouteHandlerCachedResponse(cachedValue: CachedRouteValue, options: BuildRouteHandlerCachedResponseOptions): Response;
-declare function applyRouteHandlerRevalidateHeader(response: Response, revalidateSeconds: number, expireSeconds?: number): void;
+declare function applyRouteHandlerRevalidateHeader(response: Response, revalidateSeconds: number, expireSeconds?: number, tags?: readonly string[]): void;
 declare function markRouteHandlerCacheMiss(response: Response): void;
 declare function buildAppRouteCacheValue(response: Response): Promise<CachedRouteValue>;
 declare function finalizeRouteHandlerResponse(response: Response, options: FinalizeRouteHandlerResponseOptions): Response;
 //#endregion
-export { RouteHandlerMiddlewareContext, applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss };
-//# sourceMappingURL=app-route-handler-response.d.ts.map
+export { RouteHandlerMiddlewareContext, applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss };