vinext 0.1.4 → 0.1.5

package/dist/server/app-ssr-entry.js

@@ -1,12 +1,13 @@
 import "./server-globals.js";
 import { notFoundResponse } from "./http-error-responses.js";
-import { isOpenRedirectShaped } from "./request-pipeline.js";
-import { isPprFallbackShellAbortError } from "../shims/ppr-fallback-shell.js";
+import { isOpenRedirectShaped } from "./open-redirect.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
+import { isPprFallbackShellAbortError } from "../shims/ppr-fallback-shell.js";
 import { AppRouterContext } from "../shims/internal/app-router-context.js";
 import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
-import { ServerInsertedHTMLContext, appRouterInstance, clearServerInsertedHTML, getBfcacheIdMapContext, renderServerInsertedHTML, setNavigationContext, useServerInsertedHTML } from "../shims/navigation.js";
+import { ServerInsertedHTMLContext, clearServerInsertedHTML, getBfcacheIdMapContext, registerServerInsertedHTMLCallback, renderServerInsertedHTML, setNavigationContext } from "../shims/navigation-context-state.js";
+import "../shims/navigation-server.js";
 import { runWithNavigationContext } from "../shims/navigation-state.js";
 import { withScriptNonce } from "../shims/script-nonce-context.js";
 import { createInlineScriptTag, createNonceAttribute, escapeHtmlAttr, safeJsonStringify } from "./html.js";
@@ -15,14 +16,15 @@ import DefaultGlobalError from "../shims/default-global-error.js";
 import { BfcacheStateKeyMapContext, ElementsContext, Slot } from "../shims/slot.js";
 import { createSsrErrorMetaRenderer } from "./app-ssr-error-meta.js";
 import { createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform } from "./app-ssr-stream.js";
-import { BeforeInteractiveContext } from "../shims/before-interactive-context.js";
-import { runWithRootParamsScope } from "../shims/root-params.js";
-import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap } from "./app-browser-state.js";
+import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap } from "./app-bfcache-identity.js";
 import { RSC_FORM_STATE_GLOBAL } from "./app-browser-hydration.js";
 import { createClientReferencePreloader } from "./app-client-reference-preloader.js";
-import { deferUntilStreamConsumed } from "./app-page-stream.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
+import { runWithRootParamsScope } from "../shims/root-params.js";
+import { BeforeInteractiveContext } from "../shims/before-interactive-context.js";
 import { renderBeforeInteractiveInlineScripts } from "./before-interactive-head.js";
 import { createInitialDevServerErrorScript } from "./dev-initial-server-error.js";
+import { ssrAppRouterInstance } from "./app-ssr-router-instance.js";
 import { Fragment, createElement, use } from "react";
 import { renderToReadableStream, renderToStaticMarkup } from "react-dom/server.edge";
 import { createFromReadableStream } from "@vitejs/plugin-rsc/ssr";
@@ -192,8 +194,8 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 					return BfcacheIdMapContext ? createElement(BfcacheIdMapContext.Provider, { value: createInitialBfcacheIdMap(elements) }, stateKeyTree) : stateKeyTree;
 				}
 				const flightRootElement = createElement(VinextFlightRoot);
-				const root = AppRouterContext ? createElement(AppRouterContext.Provider, { value: appRouterInstance }, flightRootElement) : flightRootElement;
-				const ssrTree = ServerInsertedHTMLContext ? createElement(ServerInsertedHTMLContext.Provider, { value: useServerInsertedHTML }, root) : root;
+				const root = AppRouterContext ? createElement(AppRouterContext.Provider, { value: ssrAppRouterInstance }, flightRootElement) : flightRootElement;
+				const ssrTree = ServerInsertedHTMLContext ? createElement(ServerInsertedHTMLContext.Provider, { value: registerServerInsertedHTMLCallback }, root) : root;
 				const beforeInteractiveInlineScripts = [];
 				const registerBeforeInteractiveInlineScript = (script) => {
 					beforeInteractiveInlineScripts.push(script);

package/dist/server/app-ssr-router-instance.d.ts

@@ -0,0 +1,6 @@
+import { AppRouterInstance } from "../shims/internal/app-router-context.js";
+
+//#region src/server/app-ssr-router-instance.d.ts
+declare const ssrAppRouterInstance: AppRouterInstance;
+//#endregion
+export { ssrAppRouterInstance };

package/dist/server/app-ssr-router-instance.js

@@ -0,0 +1,24 @@
+import { assertSafeNavigationUrl } from "../shims/url-safety.js";
+import "./app-bfcache-id.js";
+//#region src/server/app-ssr-router-instance.ts
+function validateNavigationHref(href) {
+	assertSafeNavigationUrl(href);
+}
+const ssrAppRouterInstance = {
+	bfcacheId: "0",
+	back() {},
+	forward() {},
+	refresh() {},
+	push(href, _options) {
+		validateNavigationHref(href);
+	},
+	replace(href, _options) {
+		validateNavigationHref(href);
+	},
+	prefetch(href) {
+		validateNavigationHref(href);
+	}
+};
+if (process.env.__NEXT_GESTURE_TRANSITION) ssrAppRouterInstance.experimental_gesturePush = validateNavigationHref;
+//#endregion
+export { ssrAppRouterInstance };

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

@@ -1,6 +1,6 @@
-import { NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION } from "../client/navigation-runtime.js";
 import { createInlineScriptTag, escapeHtmlAttr, htmlTokenListContains, safeJsonStringify } from "./html.js";
 import { bytesToBase64, concatUint8Arrays } from "./app-rsc-embedded-chunks.js";
+import { NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION } from "../client/navigation-runtime.js";
 //#region src/server/app-ssr-stream.ts
 const NAVIGATION_RUNTIME_REFERENCE = `self[Symbol.for(${safeJsonStringify(NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION)})]`;
 function navigationRuntimeRscBootstrapExpression() {

package/dist/server/artifact-compatibility.js

@@ -1,5 +1,5 @@
-import { fnv1a64 } from "../utils/hash.js";
 import { isUnknownRecord } from "../utils/record.js";
+import { fnv1a64 } from "../utils/hash.js";
 //#region src/server/artifact-compatibility.ts
 const ARTIFACT_COMPATIBILITY_SCHEMA_VERSION = 1;
 const APP_ELEMENTS_SCHEMA_VERSION = 1;

package/dist/server/client-reuse-manifest.js

@@ -1,5 +1,5 @@
-import { fnv1a64 } from "../utils/hash.js";
 import { isUnknownRecord } from "../utils/record.js";
+import { fnv1a64 } from "../utils/hash.js";
 import { parseArtifactCompatibilityEnvelope } from "./artifact-compatibility.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import { isNonNegativeSafeInteger } from "../utils/number.js";

package/dist/server/defer-until-stream-consumed.d.ts

@@ -0,0 +1,7 @@
+//#region src/server/defer-until-stream-consumed.d.ts
+/**
+ * Defers cleanup until the downstream consumer drains or cancels the stream.
+ */
+declare function deferUntilStreamConsumed(stream: ReadableStream<Uint8Array>, onFlush: () => void): ReadableStream<Uint8Array>;
+//#endregion
+export { deferUntilStreamConsumed };

package/dist/server/defer-until-stream-consumed.js

@@ -0,0 +1,34 @@
+//#region src/server/defer-until-stream-consumed.ts
+/**
+* Defers cleanup until the downstream consumer drains or cancels the stream.
+*/
+function deferUntilStreamConsumed(stream, onFlush) {
+	let called = false;
+	const once = () => {
+		if (!called) {
+			called = true;
+			onFlush();
+		}
+	};
+	const cleanup = new TransformStream({ flush() {
+		once();
+	} });
+	const reader = stream.pipeThrough(cleanup).getReader();
+	return new ReadableStream({
+		pull(controller) {
+			return reader.read().then(({ done, value }) => {
+				if (done) controller.close();
+				else controller.enqueue(value);
+			}, (error) => {
+				once();
+				controller.error(error);
+			});
+		},
+		cancel(reason) {
+			once();
+			return reader.cancel(reason);
+		}
+	});
+}
+//#endregion
+export { deferUntilStreamConsumed };

package/dist/server/dev-server.js

@@ -7,10 +7,10 @@ import { normalizeStaticPathname } from "../routing/route-pattern.js";
 import { importModule, reportRequestError } from "./instrumentation.js";
 import { buildCacheStateHeaders } from "./cache-headers.js";
 import { isUnknownRecord } from "../utils/record.js";
-import { _runWithCacheState } from "../shims/cache.js";
 import { NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL } from "./cache-control.js";
 import { buildMissIsrCacheControl, decideIsr } from "./isr-decision.js";
 import { PRERENDER_REVALIDATE_HEADER, buildPagesCacheValue, getRevalidateDuration, isOnDemandRevalidateRequest, isrCacheKey, isrGet, isrSet, setRevalidateDuration, triggerBackgroundRegeneration } from "./isr-cache.js";
+import { _runWithCacheState } from "../shims/cache-request-state.js";
 import { ensureFetchPatch, runWithFetchCache } from "../shims/fetch-cache.js";
 import { runWithPrivateCache } from "../shims/cache-runtime.js";
 import { mergeRouteParamsIntoQuery, parseQueryString } from "../utils/query.js";

package/dist/server/instrumentation.js

@@ -51,7 +51,7 @@ async function importModule(runner, id) {
 const INSTRUMENTATION_LOCATIONS = ["", "src/"];
 function findInstrumentationHookFile(root, basename, fileMatcher) {
 	for (const dir of INSTRUMENTATION_LOCATIONS) for (const ext of fileMatcher.dottedExtensions) {
-		const fullPath = path.join(root, dir, `${basename}${ext}`);
+		const fullPath = path.posix.join(root, dir, `${basename}${ext}`);
 		if (fs.existsSync(fullPath)) return fullPath;
 	}
 	return null;

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

@@ -1,5 +1,5 @@
 import { RenderObservation } from "./cache-proof.js";
-import { CacheHandlerValue, CachedAppPageValue, CachedPagesValue, IncrementalCacheValue } from "../shims/cache.js";
+import { CacheHandlerValue, CachedAppPageValue, CachedPagesValue, IncrementalCacheValue } from "../shims/cache-handler.js";
 import { OnRequestErrorContext } from "./instrumentation.js";
 import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";

package/dist/server/isr-cache.js

@@ -1,7 +1,7 @@
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { reportRequestError } from "./instrumentation.js";
-import { fnv1a64 } from "../utils/hash.js";
 import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
+import { fnv1a64 } from "../utils/hash.js";
 import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 import { APP_RSC_RENDER_MODE_NAVIGATION, getRscRenderModeCacheVariant } from "./app-rsc-render-mode.js";
 import { normalizeAppPageInterceptionProofPathname } from "./app-page-render-identity.js";

package/dist/server/isr-decision.d.ts

@@ -1,4 +1,4 @@
-import { CacheControlMetadata } from "../shims/cache.js";
+import { CacheControlMetadata } from "../shims/cache-handler.js";
 import { NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL } from "./cache-control.js";
 
 //#region src/server/isr-decision.d.ts

package/dist/server/middleware-matcher.js

@@ -48,17 +48,19 @@ function stripLocalePrefix(pathname, i18nConfig) {
 	const segments = pathname.split("/");
 	const firstSegment = segments[1];
 	if (!firstSegment || !i18nConfig.locales.includes(firstSegment)) return null;
-	return removeTrailingSlash("/" + segments.slice(2).join("/"));
+	return "/" + segments.slice(2).join("/");
 }
 function matchPattern(pathname, pattern) {
-	let cached = _mwPatternCache.get(pattern);
+	const normalizedPattern = /[\\():*+?]/.test(pattern) ? pattern : removeTrailingSlash(pattern);
+	let cached = _mwPatternCache.get(normalizedPattern);
 	if (cached === void 0) {
-		cached = compileMatcherPattern(pattern);
-		_mwPatternCache.set(pattern, cached);
+		cached = compileMatcherPattern(normalizedPattern);
+		_mwPatternCache.set(normalizedPattern, cached);
 	}
 	if (cached === UNSAFE_MATCHER_PATTERN) return true;
-	if (cached === null) return pathname === pattern;
-	return cached.test(pathname);
+	if (cached === null) return removeTrailingSlash(pathname) === normalizedPattern;
+	if (cached.test(pathname)) return true;
+	return pathname.endsWith("/") && cached.test(removeTrailingSlash(pathname));
 }
 function extractConstraint(str, re) {
 	if (str[re.lastIndex] !== "(") return null;

package/dist/server/middleware-runtime.js

@@ -1,5 +1,5 @@
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
-import { addBasePathToPathname, hasBasePath, stripBasePath } from "../utils/base-path.js";
+import { addBasePathToPathname, hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
 import "./server-globals.js";
 import { getRequestExecutionContext, runWithExecutionContext } from "../shims/request-context.js";
 import { MIDDLEWARE_REWRITE_HEADER } from "./headers.js";
@@ -130,7 +130,7 @@ async function executeMiddleware(options) {
 	const matchPathname = options.basePath ? stripBasePath(normalizedPathname, options.basePath) : normalizedPathname;
 	if (!matchesMiddleware(matchPathname, middlewareMatcher(options.module), options.request, options.i18nConfig)) return { continue: true };
 	const nextRequest = createNextRequest(options.request, normalizedPathname, options.i18nConfig, options.basePath, options.trailingSlash, hadBasePath);
-	const fetchEvent = new NextFetchEvent({ page: matchPathname });
+	const fetchEvent = new NextFetchEvent({ page: removeTrailingSlash(matchPathname) });
 	let response;
 	try {
 		response = await middlewareFn(nextRequest, fetchEvent);

package/dist/server/open-redirect.d.ts

@@ -0,0 +1,12 @@
+//#region src/server/open-redirect.d.ts
+/**
+ * Returns true if a request pathname looks like a protocol-relative open
+ * redirect, in either literal or percent-encoded form.
+ *
+ * A pathname is considered "open redirect shaped" when its first segment,
+ * after decoding backslashes and encoded delimiters, would cause a browser
+ * to resolve a `Location` containing the pathname as protocol-relative.
+ */
+declare function isOpenRedirectShaped(rawPathname: string): boolean;
+//#endregion
+export { isOpenRedirectShaped };

package/dist/server/open-redirect.js

@@ -0,0 +1,21 @@
+//#region src/server/open-redirect.ts
+/**
+* Returns true if a request pathname looks like a protocol-relative open
+* redirect, in either literal or percent-encoded form.
+*
+* A pathname is considered "open redirect shaped" when its first segment,
+* after decoding backslashes and encoded delimiters, would cause a browser
+* to resolve a `Location` containing the pathname as protocol-relative.
+*/
+function isOpenRedirectShaped(rawPathname) {
+	if (!rawPathname.startsWith("/")) return false;
+	const afterSlash = rawPathname.slice(1);
+	if (afterSlash.startsWith("/") || afterSlash.startsWith("\\")) return true;
+	if (afterSlash.length >= 3 && afterSlash[0] === "%") {
+		const encoded = afterSlash.slice(0, 3).toLowerCase();
+		if (encoded === "%5c" || encoded === "%2f") return true;
+	}
+	return false;
+}
+//#endregion
+export { isOpenRedirectShaped };

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

@@ -1,6 +1,6 @@
 import { Route } from "../routing/pages-router.js";
 import { VinextNextData } from "../client/vinext-next-data.js";
-import { CachedPagesValue } from "../shims/cache.js";
+import { CachedPagesValue } from "../shims/cache-handler.js";
 import { ISRCacheEntry } from "./isr-cache.js";
 import { PagesGsspResponse, PagesI18nRenderContext, PagesNextDataExtras } from "./pages-page-response.js";
 import { ReactNode } from "react";

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

@@ -1,5 +1,5 @@
 import { VinextNextData } from "../client/vinext-next-data.js";
-import { CachedPagesValue } from "../shims/cache.js";
+import { CachedPagesValue } from "../shims/cache-handler.js";
 import { RenderPageEnhancers } from "./pages-document-initial-props.js";
 import { ComponentType, ReactNode } from "react";
 

package/dist/server/pages-page-response.js

@@ -1,10 +1,10 @@
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { reportRequestError } from "./instrumentation.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
-import { fnv1a52 } from "../utils/hash.js";
-import { encodeCacheTag } from "../utils/encode-cache-tag.js";
 import { NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, applyCdnResponseHeaders } from "./cache-control.js";
 import { buildMissIsrCacheControl } from "./isr-decision.js";
+import { fnv1a52 } from "../utils/hash.js";
+import { encodeCacheTag } from "../utils/encode-cache-tag.js";
 import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
 import { withScriptNonce } from "../shims/script-nonce-context.js";
 import { createNonceAttribute, escapeHtmlAttr } from "./html.js";

package/dist/server/prod-server.js

@@ -3,7 +3,8 @@ import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_STATIC_FILE_HEADER } from "./headers.js";
 import { normalizePath } from "./normalize-path.js";
 import { notFoundResponse } from "./http-error-responses.js";
-import { filterInternalHeaders, isOpenRedirectShaped } from "./request-pipeline.js";
+import { isOpenRedirectShaped } from "./open-redirect.js";
+import { filterInternalHeaders } from "./request-pipeline.js";
 import { isUnknownRecord } from "../utils/record.js";
 import { resolveRequestHost, resolveRequestProtocol, trustProxy, trustedHosts } from "./proxy-trust.js";
 import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isImageOptimizationPath, isSafeImageContentType, parseImageParams } from "./image-optimization.js";

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

@@ -1,6 +1,7 @@
 import { NextHeader } from "../config/next-config.js";
 import { BasePathMatchState, RequestContext } from "../config/config-matchers.js";
 import { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS } from "./headers.js";
+import { isOpenRedirectShaped } from "./open-redirect.js";
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 
 //#region src/server/request-pipeline.d.ts
@@ -42,30 +43,6 @@ import { hasBasePath, stripBasePath } from "../utils/base-path.js";
  * @returns A 404 Response if the path is protocol-relative, or null to continue
  */
 declare function guardProtocolRelativeUrl(rawPathname: string): Response | null;
-/**
- * Returns true if a request pathname looks like a protocol-relative open
- * redirect, in either literal or percent-encoded form.
- *
- * Exported for call sites that need to replicate the guard inline (Pages
- * Router worker codegen, Node production server) and for defense-in-depth
- * checks inside redirect emitters.
- *
- * A pathname is considered "open redirect shaped" when its first segment,
- * after decoding backslashes and encoded delimiters, would cause a browser
- * to resolve a `Location` containing the pathname as protocol-relative:
- *
- *   - literal   `//evil.com`
- *   - literal   `/\evil.com`             (browsers normalize `\` to `/`)
- *   - encoded   `/%5Cevil.com`           (`%5C` decodes to `\` in Location)
- *   - encoded   `/%2F/evil.com`          (`%2F` decodes to `/` → `//`)
- *   - mixed     `/%5C%2F`, `/%5C%5C`     (and other combinations)
- *
- * We explicitly do not require a valid percent sequence elsewhere in the
- * pathname — we only examine the leading bytes (up to the second real or
- * encoded delimiter) so malformed suffixes can still reach the normal
- * "400 Bad Request" decode path instead of being masked as "404".
- */
-declare function isOpenRedirectShaped(rawPathname: string): boolean;
 type HeaderRecord = Record<string, string | string[]>;
 type ApplyConfigHeadersOptions = {
   configHeaders: NextHeader[];

package/dist/server/request-pipeline.js

@@ -2,6 +2,7 @@ import { hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-p
 import { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS, VINEXT_STATIC_FILE_HEADER } from "./headers.js";
 import { matchHeaders } from "../config/config-matchers.js";
 import { forbiddenResponse, notFoundResponse } from "./http-error-responses.js";
+import { isOpenRedirectShaped } from "./open-redirect.js";
 //#region src/server/request-pipeline.ts
 /**
 * Shared request pipeline utilities.
@@ -44,39 +45,6 @@ function guardProtocolRelativeUrl(rawPathname) {
 	if (isOpenRedirectShaped(rawPathname)) return notFoundResponse();
 	return null;
 }
-/**
-* Returns true if a request pathname looks like a protocol-relative open
-* redirect, in either literal or percent-encoded form.
-*
-* Exported for call sites that need to replicate the guard inline (Pages
-* Router worker codegen, Node production server) and for defense-in-depth
-* checks inside redirect emitters.
-*
-* A pathname is considered "open redirect shaped" when its first segment,
-* after decoding backslashes and encoded delimiters, would cause a browser
-* to resolve a `Location` containing the pathname as protocol-relative:
-*
-*   - literal   `//evil.com`
-*   - literal   `/\evil.com`             (browsers normalize `\` to `/`)
-*   - encoded   `/%5Cevil.com`           (`%5C` decodes to `\` in Location)
-*   - encoded   `/%2F/evil.com`          (`%2F` decodes to `/` → `//`)
-*   - mixed     `/%5C%2F`, `/%5C%5C`     (and other combinations)
-*
-* We explicitly do not require a valid percent sequence elsewhere in the
-* pathname — we only examine the leading bytes (up to the second real or
-* encoded delimiter) so malformed suffixes can still reach the normal
-* "400 Bad Request" decode path instead of being masked as "404".
-*/
-function isOpenRedirectShaped(rawPathname) {
-	if (!rawPathname.startsWith("/")) return false;
-	const afterSlash = rawPathname.slice(1);
-	if (afterSlash.startsWith("/") || afterSlash.startsWith("\\")) return true;
-	if (afterSlash.length >= 3 && afterSlash[0] === "%") {
-		const encoded = afterSlash.slice(0, 3).toLowerCase();
-		if (encoded === "%5c" || encoded === "%2f") return true;
-	}
-	return false;
-}
 const FILE_LIKE_PATHNAME_RE = /\.[^/]+\/?$/;
 function isWellKnownPathname(pathname) {
 	return pathname === "/.well-known" || pathname.startsWith("/.well-known/");

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

@@ -1,4 +1,4 @@
-import { CachedAppPageValue } from "../shims/cache.js";
+import { CachedAppPageValue } from "../shims/cache-handler.js";
 
 //#region src/server/seed-cache.d.ts
 type PrerenderCacheSeedMetadata = {

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

@@ -0,0 +1,106 @@
+import { RenderObservation } from "../server/cache-proof.js";
+
+//#region src/shims/cache-handler.d.ts
+type CacheHandlerValue = {
+  lastModified: number;
+  age?: number;
+  cacheState?: string;
+  cacheControl?: CacheControlMetadata;
+  value: IncrementalCacheValue | null;
+};
+type CacheControlMetadata = {
+  revalidate: number;
+  expire?: number;
+};
+type IncrementalCacheValue = CachedFetchValue | CachedAppPageValue | CachedPagesValue | CachedRouteValue | CachedRedirectValue | CachedImageValue;
+type CachedFetchValue = {
+  kind: "FETCH";
+  data: {
+    headers: Record<string, string>;
+    body: string;
+    url: string;
+    status?: number;
+  };
+  tags?: string[];
+  revalidate: number | false;
+};
+type CachedAppPageValue = {
+  kind: "APP_PAGE";
+  html: string;
+  rscData: ArrayBuffer | undefined;
+  headers: Record<string, string | string[]> | undefined;
+  postponed: string | undefined;
+  renderObservation?: RenderObservation;
+  status: number | undefined;
+};
+type CachedPagesValue = {
+  kind: "PAGES";
+  html: string;
+  pageData: object;
+  generatedFromDataRequest?: boolean;
+  headers: Record<string, string | string[]> | undefined;
+  status: number | undefined;
+};
+type CachedRouteValue = {
+  kind: "APP_ROUTE";
+  body: ArrayBuffer;
+  status: number;
+  headers: Record<string, string | string[]>;
+};
+type CachedRedirectValue = {
+  kind: "REDIRECT";
+  props: object;
+};
+type CachedImageValue = {
+  kind: "IMAGE";
+  etag: string;
+  buffer: ArrayBuffer;
+  extension: string;
+  revalidate?: number;
+};
+type CacheHandlerContext = {
+  dev?: boolean;
+  maxMemoryCacheSize?: number;
+  revalidatedTags?: string[];
+  [key: string]: unknown;
+};
+type CacheHandler = {
+  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[], durations?: {
+    expire?: number;
+  }): Promise<void>;
+  resetRequestCache?(): void;
+};
+declare class NoOpCacheHandler implements CacheHandler {
+  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[], _durations?: {
+    expire?: number;
+  }): Promise<void>;
+}
+type MemoryCacheHandlerOptions = Pick<CacheHandlerContext, "maxMemoryCacheSize"> & {
+  cacheMaxMemorySize?: number;
+};
+declare class MemoryCacheHandler implements CacheHandler {
+  private store;
+  private tagRevalidatedAt;
+  private readonly maxMemoryCacheSize;
+  private currentMemoryCacheSize;
+  constructor(options?: number | MemoryCacheHandlerOptions);
+  private estimateEntrySize;
+  private deleteEntry;
+  private touchEntry;
+  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>;
+  resetRequestCache(): void;
+}
+declare function configureMemoryCacheHandler(options?: MemoryCacheHandlerOptions): void;
+declare function setDataCacheHandler(handler: CacheHandler): void;
+declare function getDataCacheHandler(): CacheHandler;
+declare function setCacheHandler(handler: CacheHandler): void;
+declare function getCacheHandler(): CacheHandler;
+//#endregion
+export { CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, setCacheHandler, setDataCacheHandler };