vinext 1.0.0-beta.8 → 1.0.0

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

@@ -51,7 +51,7 @@ function concatBytes(first, second) {
 	combined.set(second, first.byteLength);
 	return combined;
 }
-function indexOfByte(bytes, byte, from = 0) {
+function indexOfByte(bytes, byte, from) {
 	for (let index = from; index < bytes.byteLength; index++) if (bytes[index] === byte) return index;
 	return -1;
 }
@@ -70,8 +70,35 @@ function parseHexBytes(bytes, start, end) {
 function isUntaggedJsonRowStart(byte) {
 	return byte === 34 || byte === 45 || byte >= 48 && byte <= 57 || byte === 91 || byte === 102 || byte === 110 || byte === 116 || byte === 123;
 }
+const COLON_BYTE = 58;
+const COMMA_BYTE = 44;
+const NEWLINE_BYTE = 10;
+const HINT_TAG_BYTE = 72;
+const LINK_HINT_CODE_BYTE = 76;
+function createAsciiTagTable(tags) {
+	const table = /* @__PURE__ */ new Uint8Array(128);
+	for (const tag of tags) table[tag.charCodeAt(0)] = 1;
+	return table;
+}
+const LENGTH_PREFIXED_ROW_TAG_TABLE = createAsciiTagTable(LENGTH_PREFIXED_ROW_TAGS);
+const NEWLINE_PREFIXED_ROW_TAG_TABLE = createAsciiTagTable(NEWLINE_PREFIXED_ROW_TAGS);
+function isTagInTable(table, byte) {
+	return byte < 128 && table[byte] === 1;
+}
+/**
+* Rewrite stylesheet preload hints in a React Flight stream.
+*
+* The rewrite is byte-length preserving, so this transform keeps React's
+* text chunk boundaries instead of re-emitting one chunk per Flight row. Every
+* downstream consumer (the tee, the SSR Flight client, the inline RSC embed,
+* RSC response wrappers) pays a per-chunk cost, and splitting per row
+* multiplied the chunk count roughly 8x on content-heavy pages. Chunks with
+* no stylesheet hint are forwarded as-is without copying; only rows whose
+* tag is `HL` are decoded and inspected. Length-prefixed bodies remain separate
+* so binary bytes do not force adjacent text through the embed's base64 path.
+*/
 function normalizeReactFlightPreloadHints(stream) {
-	let carry = /* @__PURE__ */ new Uint8Array();
+	let carry = null;
 	let rawBytesRemaining = 0;
 	let passThrough = false;
 	return stream.pipeThrough(new TransformStream({
@@ -80,56 +107,64 @@ function normalizeReactFlightPreloadHints(stream) {
 				controller.enqueue(chunk);
 				return;
 			}
-			let bytes = concatBytes(carry, chunk);
-			carry = /* @__PURE__ */ new Uint8Array();
-			while (bytes.byteLength > 0) {
+			const bytes = carry === null ? chunk : concatBytes(carry, chunk);
+			carry = null;
+			const byteLength = bytes.byteLength;
+			let offset = 0;
+			let emittedThrough = 0;
+			let output = bytes;
+			let ownsOutput = bytes !== chunk;
+			while (offset < byteLength) {
 				if (rawBytesRemaining > 0) {
-					const length = Math.min(rawBytesRemaining, bytes.byteLength);
-					controller.enqueue(bytes.slice(0, length));
+					const length = Math.min(rawBytesRemaining, byteLength - offset);
+					if (offset > emittedThrough) controller.enqueue(output.subarray(emittedThrough, offset));
+					controller.enqueue(bytes.subarray(offset, offset + length));
 					rawBytesRemaining -= length;
-					bytes = bytes.subarray(length);
+					offset += length;
+					emittedThrough = offset;
 					continue;
 				}
-				const colon = indexOfByte(bytes, 58);
-				if (colon === -1 || colon + 1 === bytes.byteLength) {
-					carry = bytes.slice();
-					return;
-				}
-				const tag = String.fromCharCode(bytes[colon + 1]);
-				if (LENGTH_PREFIXED_ROW_TAGS.has(tag)) {
-					const comma = indexOfByte(bytes, 44, colon + 2);
-					if (comma === -1) {
-						carry = bytes.slice();
-						return;
-					}
+				const colon = indexOfByte(bytes, COLON_BYTE, offset);
+				if (colon === -1 || colon + 1 === byteLength) break;
+				const tagByte = bytes[colon + 1];
+				if (isTagInTable(LENGTH_PREFIXED_ROW_TAG_TABLE, tagByte)) {
+					const comma = indexOfByte(bytes, COMMA_BYTE, colon + 2);
+					if (comma === -1) break;
 					const length = parseHexBytes(bytes, colon + 2, comma);
 					if (length != null) {
-						controller.enqueue(bytes.slice(0, comma + 1));
 						rawBytesRemaining = length;
-						bytes = bytes.subarray(comma + 1);
+						offset = comma + 1;
 						continue;
 					}
 					passThrough = true;
-					controller.enqueue(bytes);
-					return;
+					offset = byteLength;
+					break;
 				}
-				const tagByte = bytes[colon + 1];
-				if (!NEWLINE_PREFIXED_ROW_TAGS.has(tag) && !isUntaggedJsonRowStart(tagByte)) {
+				if (!isTagInTable(NEWLINE_PREFIXED_ROW_TAG_TABLE, tagByte) && !isUntaggedJsonRowStart(tagByte)) {
 					passThrough = true;
-					controller.enqueue(bytes);
-					return;
+					offset = byteLength;
+					break;
 				}
-				const newline = indexOfByte(bytes, 10);
-				if (newline === -1) {
-					carry = bytes.slice();
-					return;
+				const newline = indexOfByte(bytes, NEWLINE_BYTE, offset);
+				if (newline === -1) break;
+				if (tagByte === HINT_TAG_BYTE && bytes[colon + 2] === LINK_HINT_CODE_BYTE) {
+					const line = bytes.subarray(offset, newline + 1);
+					const normalized = normalizeReactFlightHintLine(line);
+					if (normalized !== line) {
+						if (!ownsOutput) {
+							output = bytes.slice();
+							ownsOutput = true;
+						}
+						output.set(normalized, offset);
+					}
 				}
-				controller.enqueue(normalizeReactFlightHintLine(bytes.slice(0, newline + 1)));
-				bytes = bytes.subarray(newline + 1);
+				offset = newline + 1;
 			}
+			if (offset < byteLength) carry = bytes.slice(offset);
+			if (offset > emittedThrough) controller.enqueue(offset === byteLength && emittedThrough === 0 ? output : output.subarray(emittedThrough, offset));
 		},
 		flush(controller) {
-			if (carry.byteLength > 0) controller.enqueue(rawBytesRemaining > 0 ? carry : normalizeReactFlightHintLine(carry));
+			if (carry !== null && carry.byteLength > 0) controller.enqueue(rawBytesRemaining > 0 ? carry : normalizeReactFlightHintLine(carry));
 		}
 	}));
 }

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

@@ -28,6 +28,5 @@ type PrerenderCacheSeedOptions = {
  * @param serverDir - Path to `dist/server/` (where vinext-prerender.json lives)
  * @returns The number of routes seeded (0 if no manifest or no renderable routes).
  */
-declare function seedMemoryCacheFromPrerender(serverDir: string, options?: PrerenderCacheSeedOptions): Promise<number>;
-//#endregion
-export { seedMemoryCacheFromPrerender };
+export declare function seedMemoryCacheFromPrerender(serverDir: string, options?: PrerenderCacheSeedOptions): Promise<number>;
+//#endregion

package/dist/server/seed-cache.js

@@ -1,9 +1,9 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
-import { appIsrCacheKey, isrCacheKey, isrSet, isrSetPrerenderedAppPage } from "./isr-cache.js";
+import { appIsrCacheKey, isrSet, isrSetPrerenderedAppPage } from "./isr-cache.js";
+import { addPregeneratedConcretePath, addPregeneratedRoute, clearPregeneratedConcretePaths, normalizePregeneratedPathname } from "./pregenerated-concrete-paths.js";
 import { getRenderedAppRoutes, getRenderedMetadataRoutes, isFallbackShellArtifactPath, readPrerenderManifest } from "./prerender-manifest.js";
 import { buildAppPageCacheTags, buildAppRouteCacheTags } from "./app-page-cache.js";
 import { getAppRouteOutputPath, getOutputPath, getRscOutputPath } from "../utils/prerender-output-paths.js";
-import { addPregeneratedConcretePath, clearPregeneratedConcretePaths, normalizePregeneratedPathname } from "./pregenerated-concrete-paths.js";
 import fs from "node:fs";
 //#region src/server/seed-cache.ts
 /**
@@ -16,7 +16,7 @@ import fs from "node:fs";
 *
 * This is only useful for the MemoryCacheHandler (the default for Node.js
 * production). Persistent backends like KV already retain entries across
-* deploys and can be pre-populated via TPR or similar mechanisms.
+* deploys and can be pre-populated from prerendered artifacts.
 *
 * Consistency model:
 * - The manifest is authoritative for which routes were pre-rendered and their
@@ -47,7 +47,8 @@ import fs from "node:fs";
 */
 async function seedMemoryCacheFromPrerender(serverDir, options) {
 	clearPregeneratedConcretePaths();
-	const manifest = readPrerenderManifest(path.join(serverDir, "vinext-prerender.json"));
+	const manifestPath = path.join(serverDir, "vinext-prerender.json");
+	const manifest = readPrerenderManifest(manifestPath);
 	if (!manifest) return 0;
 	const { buildId, routes } = manifest;
 	if (!buildId || !Array.isArray(routes)) return 0;
@@ -56,15 +57,15 @@ async function seedMemoryCacheFromPrerender(serverDir, options) {
 	const writeAppPageEntry = options?.writeAppPageEntry ?? createDefaultAppPageEntryWriter();
 	const writeAppRouteEntry = options?.writeAppRouteEntry ?? isrSet;
 	let seeded = 0;
+	for (const route of routes) if (route.status === "skipped" && route.reason === "empty-static-params") addPregeneratedRoute(route.route);
 	const appRoutes = getRenderedAppRoutes(routes);
 	for (const route of appRoutes) {
 		const concretePathname = route.path ?? route.route;
 		if (!isFallbackShellArtifactPath(concretePathname, route)) addPregeneratedConcretePath(route.route, concretePathname);
 		const artifactPathname = route.path ?? route.route;
 		const cachePathname = normalizePregeneratedPathname(artifactPathname);
-		const baseKey = isrCacheKey("app", cachePathname, buildId);
-		const htmlKey = options?.buildAppPageHtmlKey?.(cachePathname) ?? baseKey + ":html";
-		const rscKey = options?.buildAppPageRscKey?.(cachePathname) ?? baseKey + ":rsc";
+		const htmlKey = options?.buildAppPageHtmlKey?.(cachePathname) ?? appIsrCacheKey(cachePathname, "html", buildId);
+		const rscKey = options?.buildAppPageRscKey?.(cachePathname) ?? appIsrCacheKey(cachePathname, "rsc", buildId);
 		const revalidateSeconds = typeof route.revalidate === "number" ? route.revalidate : void 0;
 		const expireSeconds = typeof route.expire === "number" ? route.expire : void 0;
 		const staleSeconds = typeof route.stale === "number" && route.stale >= 0 ? route.stale : void 0;

package/dist/server/server-action-not-found.d.ts

@@ -1,7 +1,7 @@
 //#region src/server/server-action-not-found.d.ts
-declare function getServerActionNotFoundMessage(actionId: string | null): string;
-declare function isServerActionNotFoundError(error: unknown, actionId: string | null): boolean;
-declare function createServerActionNotFoundResponse(): Response;
+export declare function getServerActionNotFoundMessage(actionId: string | null): string;
+export declare function isServerActionNotFoundError(error: unknown, actionId: string | null): boolean;
+export declare function createServerActionNotFoundResponse(): Response;
 /**
  * Throw an `UnrecognizedActionError` when the server reported the requested
  * server action id as unknown (the `x-nextjs-action-not-found` response
@@ -16,6 +16,5 @@ declare function createServerActionNotFoundResponse(): Response;
  * on this same response header:
  * https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/router-reducer/reducers/server-action-reducer.ts
  */
-declare function throwOnServerActionNotFound(response: Pick<Response, "headers">, actionId: string): void;
-//#endregion
-export { createServerActionNotFoundResponse, getServerActionNotFoundMessage, isServerActionNotFoundError, throwOnServerActionNotFound };
+export declare function throwOnServerActionNotFound(response: Pick<Response, "headers">, actionId: string): void;
+//#endregion

package/dist/server/server-globals.d.ts

@@ -1,4 +1,3 @@
 //#region src/server/server-globals.d.ts
-declare function installServerGlobals(): void;
-//#endregion
-export { installServerGlobals };
+export declare function installServerGlobals(): void;
+//#endregion

package/dist/server/server-globals.js

@@ -1,3 +1,4 @@
+import { getRequestExecutionContext } from "../shims/request-context.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/server/server-globals.ts
 /**
@@ -9,6 +10,8 @@ import { AsyncLocalStorage } from "node:async_hooks";
 * side-effect dependency. A runtime function call from the generated entry
 * body would run after static user imports have already evaluated.
 */
+const CACHEABILITY_REQUEST_STATE = Symbol.for("vinext.cacheabilityRequestState");
+const PHASE_PRODUCTION_BUILD = "phase-production-build";
 function clearBrowserGlobal(name) {
 	const descriptor = Object.getOwnPropertyDescriptor(globalThis, name);
 	if (!descriptor && typeof Reflect.get(globalThis, name) === "undefined") return;
@@ -29,6 +32,16 @@ function installServerGlobals() {
 		value: AsyncLocalStorage,
 		writable: true
 	});
+	const nextPhaseDescriptor = Object.getOwnPropertyDescriptor(globalThis, "__VINEXT_NEXT_PHASE");
+	if (!nextPhaseDescriptor || nextPhaseDescriptor.configurable) Object.defineProperty(globalThis, "__VINEXT_NEXT_PHASE", {
+		configurable: true,
+		get() {
+			const context = getRequestExecutionContext();
+			const state = context ? Reflect.get(context, CACHEABILITY_REQUEST_STATE) : void 0;
+			if (context?.isPrerenderPathDiscovery === true || Reflect.get(state ?? {}, "mode") === "probe") return PHASE_PRODUCTION_BUILD;
+			return Reflect.get(process.env, "NEXT_PHASE");
+		}
+	});
 }
 installServerGlobals();
 //#endregion

package/dist/server/skip-cache-proof.d.ts

@@ -3,7 +3,7 @@ import { StaticLayoutArtifactReuseDecision } from "./cache-proof.js";
 import { ClientReuseManifestEntry, ClientReuseManifestEntryRejection, ClientReuseManifestParseResult, ClientReuseManifestRejection, ClientReuseManifestSkipDisposition, ClientReuseManifestTraceFields } from "./client-reuse-manifest.js";
 import { createStaticLayoutClientReuseArtifactCompatibility, createStaticLayoutClientReusePayloadHash, createStaticLayoutClientReuseRouteId } from "./static-layout-client-reuse-proof.js";
 //#region src/server/skip-cache-proof.d.ts
-type SkipCacheInvalidationProof = Readonly<{
+export type SkipCacheInvalidationProof = Readonly<{
   kind: "invalidated";
   invalidationEpoch: string | null;
 }> | Readonly<{
@@ -54,7 +54,7 @@ type CreateClientReuseSkipTransportPlanInput = Readonly<{
   maxWireEntriesToVerify?: number;
   verifyEntry: (entry: ClientReuseManifestEntry) => SkipCacheCrossCheckResult;
 }>;
-declare function crossCheckClientReuseManifestEntryWithCache(input: CrossCheckClientReuseManifestEntryWithCacheInput): SkipCacheCrossCheckResult;
-declare function createClientReuseSkipTransportPlan(input: CreateClientReuseSkipTransportPlanInput): ClientReuseSkipTransportPlan;
+export declare function crossCheckClientReuseManifestEntryWithCache(input: CrossCheckClientReuseManifestEntryWithCacheInput): SkipCacheCrossCheckResult;
+export declare function createClientReuseSkipTransportPlan(input: CreateClientReuseSkipTransportPlanInput): ClientReuseSkipTransportPlan;
 //#endregion
-export { SkipCacheInvalidationProof, createClientReuseSkipTransportPlan, createStaticLayoutClientReuseArtifactCompatibility, createStaticLayoutClientReusePayloadHash, createStaticLayoutClientReuseRouteId, crossCheckClientReuseManifestEntryWithCache };
+export { createStaticLayoutClientReuseArtifactCompatibility, createStaticLayoutClientReusePayloadHash, createStaticLayoutClientReuseRouteId };

package/dist/server/socket-error-backstop.d.ts

@@ -4,7 +4,7 @@
  * one of `ECONNRESET` / `EPIPE` / `ECONNABORTED`, otherwise `undefined`.
  * Exported for unit testing in isolation (no process-state mutation).
  */
-declare function peerDisconnectCode(err: unknown): string | undefined;
+export declare function peerDisconnectCode(err: unknown): string | undefined;
 /**
  * Pure predicate: returns `true` when `err` is a benign failure from a
  * dynamic `import()` of a static asset URL — the "URL dependency" pattern
@@ -22,13 +22,12 @@ declare function peerDisconnectCode(err: unknown): string | undefined;
  * modules with no extension) returns `false` so real bugs still crash.
  * Exported for unit testing in isolation.
  */
-declare function isBenignAssetImportError(err: unknown): boolean;
+export declare function isBenignAssetImportError(err: unknown): boolean;
 /**
  * Test-only: returns whether the backstop has been installed in this
  * process. Used by the unit test to assert idempotent install via the
  * Symbol.for guard. Not part of the public API.
  */
-declare function isSocketErrorBackstopInstalled(): boolean;
-declare function installSocketErrorBackstop(): void;
-//#endregion
-export { installSocketErrorBackstop, isBenignAssetImportError, isSocketErrorBackstopInstalled, peerDisconnectCode };
+export declare function isSocketErrorBackstopInstalled(): boolean;
+export declare function installSocketErrorBackstop(): void;
+//#endregion

package/dist/server/socket-error-backstop.js

@@ -33,7 +33,7 @@
 *
 * **Prerender check is dynamic, not install-time.** Prerender (in
 * `build/prerender.ts` and `build/run-prerender.ts`) calls
-* `startProdServer()` from inside `vinext build` to render pages
+* `startProdServer()` from inside `vite build` to render pages
 * against a real HTTP server. User `fetch()` calls during prerender
 * hit external APIs that can drop connections; absorbing those would
 * silently produce corrupt prerendered output instead of crashing

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

@@ -1,8 +1,8 @@
 //#region src/server/static-file-cache.d.ts
 /** Content-type lookup for static assets. Shared with prod-server.ts. */
-declare const CONTENT_TYPES: Record<string, string>;
+export declare const CONTENT_TYPES: Record<string, string>;
 /** Resolve a path's MIME type with case-insensitive extension matching. */
-declare function contentTypeForPath(filePath: string): string;
+export declare function contentTypeForPath(filePath: string): string;
 /** A servable file variant with pre-computed response headers. */
 type FileVariant = {
   /** Absolute file path (used for streaming large files). */
@@ -38,7 +38,7 @@ type StaticFileEntry = {
  *   const entry = cache.lookup("/_next/static/app-abc123.js");
  *   // entry.br?.headers, entry.original.headers, etc.
  */
-declare class StaticFileCache {
+export declare class StaticFileCache {
   private readonly entries;
   private constructor();
   /**
@@ -65,6 +65,5 @@ declare class StaticFileCache {
  * Returns null if the filename doesn't contain a recognizable hash suffix,
  * so the caller can fall back to mtime-based ETags.
  */
-declare function etagFromFilenameHash(relativePath: string, ext: string): string | null;
-//#endregion
-export { CONTENT_TYPES, StaticFileCache, contentTypeForPath, etagFromFilenameHash };
+export declare function etagFromFilenameHash(relativePath: string, ext: string): string | null;
+//#endregion

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

@@ -61,7 +61,7 @@ function contentTypeForPath(filePath) {
 * 64KB covers virtually all precompressed assets (a 200KB JS bundle compresses
 * to ~50KB with brotli q5).
 */
-const BUFFER_THRESHOLD = 64 * 1024;
+const BUFFER_THRESHOLD = 65536;
 /** Temp files left by an interrupted atomic precompression write. */
 const PRECOMPRESSION_TEMP_FILE_RE = /\.(?:br|gz|zst)\.\d+\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.tmp$/i;
 /**
@@ -136,12 +136,14 @@ var StaticFileCache = class StaticFileCache {
 			}
 			const pathname = "/" + relativePath;
 			entries.set(pathname, entry);
-			if (ext === ".html") if (relativePath.endsWith("/index.html")) {
-				const dirPath = "/" + relativePath.slice(0, -11);
-				if (dirPath !== "/") entries.set(dirPath, entry);
-			} else {
-				const withoutExt = "/" + relativePath.slice(0, -ext.length);
-				entries.set(withoutExt, entry);
+			if (ext === ".html") {
+				if (relativePath.endsWith("/index.html")) {
+					const dirPath = "/" + relativePath.slice(0, -11);
+					if (dirPath !== "/") entries.set(dirPath, entry);
+				} else {
+					const withoutExt = "/" + relativePath.slice(0, -ext.length);
+					entries.set(withoutExt, entry);
+				}
 			}
 		}
 		const toBuffer = [];

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

@@ -0,0 +1,16 @@
+//#region src/server/static-file-signal.d.ts
+export type StaticFileSignalContext = {
+  headers: Headers | null;
+  status: number | null;
+};
+/** Create the only response shape that host runtimes may resolve as an asset. */
+export declare function createStaticFileSignal(pathname: string, context: StaticFileSignalContext): Response;
+/** Whether this response was created by vinext's public-file router. */
+export declare function isStaticFileSignal(response: Response): boolean;
+/** Return the encoded asset pathname only for a framework-created signal. */
+export declare function readStaticFileSignal(response: Response): string | null;
+/** Encode a framework-authenticated signal for a standards-only stage transport. */
+export declare function serializeStaticFileSignalForTransport(response: Response, token: string): Response;
+/** Restore and consume a signal returned by the trusted response-stage wrapper. */
+export declare function restoreStaticFileSignalFromTransport(response: Response, token: string): Response;
+//#endregion

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

@@ -0,0 +1,82 @@
+//#region src/server/static-file-signal.ts
+const STATIC_FILE_SIGNAL = Symbol.for("vinext.static-file-signal");
+const STATIC_FILE_SIGNAL_TRANSPORT_HEADER = "x-vinext-stage-static-file";
+const STATIC_FILE_REPRESENTATION_HEADERS = [
+	"content-encoding",
+	"content-length",
+	"content-type",
+	"transfer-encoding"
+];
+/**
+* Mark a response created by vinext's public-file router.
+*
+* The symbol carries the encoded pathname across the built RSC module boundary
+* before the host runtime can fetch the asset. Application response headers
+* remain ordinary metadata and cannot alter framework control flow.
+*/
+function markStaticFileSignal(response, pathname) {
+	return markEncodedStaticFileSignal(response, encodeURIComponent(pathname));
+}
+function markEncodedStaticFileSignal(response, encodedPathname) {
+	Object.defineProperty(response, STATIC_FILE_SIGNAL, { value: encodedPathname });
+	return response;
+}
+function withoutTransportHeader(response) {
+	if (!response.headers.has(STATIC_FILE_SIGNAL_TRANSPORT_HEADER)) return response;
+	const headers = new Headers(response.headers);
+	headers.delete(STATIC_FILE_SIGNAL_TRANSPORT_HEADER);
+	if (response.status < 200 || response.status > 599) return response;
+	const body = response.status === 204 || response.status === 205 || response.status === 304 ? null : response.body;
+	return new Response(body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
+/** Create the only response shape that host runtimes may resolve as an asset. */
+function createStaticFileSignal(pathname, context) {
+	const headers = new Headers();
+	if (context.headers) for (const [key, value] of context.headers) headers.append(key, value);
+	return markStaticFileSignal(new Response(null, {
+		status: context.status ?? 200,
+		headers
+	}), pathname);
+}
+/** Whether this response was created by vinext's public-file router. */
+function isStaticFileSignal(response) {
+	return typeof Reflect.get(response, STATIC_FILE_SIGNAL) === "string";
+}
+/** Return the encoded asset pathname only for a framework-created signal. */
+function readStaticFileSignal(response) {
+	const signal = Reflect.get(response, STATIC_FILE_SIGNAL);
+	return typeof signal === "string" ? signal : null;
+}
+/** Encode a framework-authenticated signal for a standards-only stage transport. */
+function serializeStaticFileSignalForTransport(response, token) {
+	const signal = readStaticFileSignal(response);
+	if (signal === null) return response;
+	const headers = new Headers(response.headers);
+	for (const name of STATIC_FILE_REPRESENTATION_HEADERS) headers.delete(name);
+	headers.set(STATIC_FILE_SIGNAL_TRANSPORT_HEADER, `${token}:${signal}`);
+	return new Response(null, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
+/** Restore and consume a signal returned by the trusted response-stage wrapper. */
+function restoreStaticFileSignalFromTransport(response, token) {
+	const transported = response.headers.get(STATIC_FILE_SIGNAL_TRANSPORT_HEADER);
+	const cleaned = withoutTransportHeader(response);
+	const prefix = `${token}:`;
+	if (transported === null || !transported.startsWith(prefix)) return cleaned;
+	const encodedPathname = transported.slice(prefix.length);
+	try {
+		if (!decodeURIComponent(encodedPathname).startsWith("/")) return cleaned;
+	} catch {
+		return cleaned;
+	}
+	return markEncodedStaticFileSignal(cleaned, encodedPathname);
+}
+//#endregion
+export { createStaticFileSignal, isStaticFileSignal, readStaticFileSignal, restoreStaticFileSignalFromTransport, serializeStaticFileSignalForTransport };

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

@@ -7,8 +7,7 @@ type StaticLayoutClientReuseProofInput = Readonly<{
   routeId: string;
   variantCacheKey: string;
 }>;
-declare function createStaticLayoutClientReuseRouteId(layoutId: string): string;
-declare function createStaticLayoutClientReusePayloadHash(input: StaticLayoutClientReuseProofInput): string;
-declare function createStaticLayoutClientReuseArtifactCompatibility(input: StaticLayoutClientReuseProofInput): ArtifactCompatibilityEnvelope;
-//#endregion
-export { createStaticLayoutClientReuseArtifactCompatibility, createStaticLayoutClientReusePayloadHash, createStaticLayoutClientReuseRouteId };
+export declare function createStaticLayoutClientReuseRouteId(layoutId: string): string;
+export declare function createStaticLayoutClientReusePayloadHash(input: StaticLayoutClientReuseProofInput): string;
+export declare function createStaticLayoutClientReuseArtifactCompatibility(input: StaticLayoutClientReuseProofInput): ArtifactCompatibilityEnvelope;
+//#endregion

package/dist/server/streaming-metadata.d.ts

@@ -1,4 +1,3 @@
 //#region src/server/streaming-metadata.d.ts
-declare function shouldServeStreamingMetadata(userAgent: string, htmlLimitedBots: string | undefined): boolean;
-//#endregion
-export { shouldServeStreamingMetadata };
+export declare function shouldServeStreamingMetadata(userAgent: string, htmlLimitedBots: string | undefined): boolean;
+//#endregion

package/dist/server/tracer.d.ts

@@ -0,0 +1,5 @@
+import { FrameworkTracer, FrameworkTracingIntegration } from "./framework-tracer.js";
+//#region src/server/tracer.d.ts
+export declare function registerFrameworkTracingIntegration(integration: FrameworkTracingIntegration): void;
+export declare const frameworkTracer: FrameworkTracer;
+//#endregion

package/dist/server/tracer.js

@@ -0,0 +1,13 @@
+import { createFrameworkTracer } from "./framework-tracer.js";
+import { openTelemetryTracingIntegration } from "./opentelemetry-tracing.js";
+//#region src/server/tracer.ts
+const INTEGRATIONS_KEY = Symbol.for("vinext.frameworkTracing.integrations");
+const globals = globalThis;
+const integrations = globals[INTEGRATIONS_KEY] ??= [];
+function registerFrameworkTracingIntegration(integration) {
+	if (!integrations.some(({ id }) => id === integration.id)) integrations.push(integration);
+}
+registerFrameworkTracingIntegration(openTelemetryTracingIntegration);
+const frameworkTracer = createFrameworkTracer(integrations);
+//#endregion
+export { frameworkTracer, registerFrameworkTracingIntegration };

package/dist/server/worker-prerender-discovery.d.ts

@@ -0,0 +1,18 @@
+import { ExecutionContextLike } from "../shims/request-context.js";
+//#region src/server/worker-prerender-discovery.d.ts
+export declare function isWorkerPrerenderDiscoveryPath(pathname: string): boolean;
+export declare function workerCapabilityMatches(provided: string, expected: string): boolean;
+/**
+ * Respond to an authenticated staged-version readiness request without
+ * invoking middleware, routing, or rendering. The CDN adapter validates the
+ * expected Worker version before callers return this response.
+ */
+export declare function createWorkerPrerenderReadinessResponse(ctx: ExecutionContextLike, request: Request): Response | null;
+/**
+ * Mark only a request carrying the current build's capability as an internal
+ * path-discovery request. The capability is compiled into the Worker entry and
+ * rotated on every build; the public version override proves which staged
+ * version Cloudflare invoked but is deliberately not treated as authorization.
+ */
+export declare function createWorkerPrerenderDiscoveryContext(base: ExecutionContextLike, request: Request, expectedSecret: string | null | undefined): ExecutionContextLike;
+//#endregion

package/dist/server/worker-prerender-discovery.js

@@ -0,0 +1,55 @@
+import { VINEXT_PRERENDER_SECRET_HEADER } from "../utils/protocol-headers.js";
+import { VINEXT_PRERENDER_METADATA_ROUTES_PATH, VINEXT_PRERENDER_PAGES_STATIC_PATHS_PATH, VINEXT_PRERENDER_READINESS_HEADER, VINEXT_PRERENDER_READINESS_PATH, VINEXT_PRERENDER_STATIC_PARAMS_PATH } from "./headers.js";
+//#region src/server/worker-prerender-discovery.ts
+const PRERENDER_DISCOVERY_PATHS = /* @__PURE__ */ new Set([
+	VINEXT_PRERENDER_STATIC_PARAMS_PATH,
+	VINEXT_PRERENDER_PAGES_STATIC_PATHS_PATH,
+	VINEXT_PRERENDER_METADATA_ROUTES_PATH,
+	VINEXT_PRERENDER_READINESS_PATH
+]);
+function isWorkerPrerenderDiscoveryPath(pathname) {
+	return PRERENDER_DISCOVERY_PATHS.has(pathname);
+}
+function workerCapabilityMatches(provided, expected) {
+	let mismatch = provided.length ^ expected.length;
+	for (let index = 0; index < expected.length; index++) mismatch |= (provided.charCodeAt(index) || 0) ^ expected.charCodeAt(index);
+	return mismatch === 0;
+}
+/**
+* Respond to an authenticated staged-version readiness request without
+* invoking middleware, routing, or rendering. The CDN adapter validates the
+* expected Worker version before callers return this response.
+*/
+function createWorkerPrerenderReadinessResponse(ctx, request) {
+	if (!request.url.includes("/__vinext/prerender/readiness")) return null;
+	if (new URL(request.url).pathname !== "/__vinext/prerender/readiness") return null;
+	if (ctx.isPrerenderPathDiscovery !== true || request.method !== "GET" && request.method !== "POST" || !request.headers.has("X-Vinext-Expected-Worker-Version")) return new Response(null, {
+		status: 404,
+		headers: { "Cache-Control": "no-store" }
+	});
+	return new Response(null, {
+		status: 204,
+		headers: {
+			"Cache-Control": "no-store",
+			[VINEXT_PRERENDER_READINESS_HEADER]: "1"
+		}
+	});
+}
+/**
+* Mark only a request carrying the current build's capability as an internal
+* path-discovery request. The capability is compiled into the Worker entry and
+* rotated on every build; the public version override proves which staged
+* version Cloudflare invoked but is deliberately not treated as authorization.
+*/
+function createWorkerPrerenderDiscoveryContext(base, request, expectedSecret) {
+	const providedSecret = request.headers.get(VINEXT_PRERENDER_SECRET_HEADER);
+	if (!expectedSecret || !providedSecret || !workerCapabilityMatches(providedSecret, expectedSecret)) return base;
+	const pathname = new URL(request.url).pathname;
+	if (!isWorkerPrerenderDiscoveryPath(pathname)) return base;
+	return {
+		...base,
+		isPrerenderPathDiscovery: true
+	};
+}
+//#endregion
+export { createWorkerPrerenderDiscoveryContext, createWorkerPrerenderReadinessResponse, isWorkerPrerenderDiscoveryPath, workerCapabilityMatches };

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

@@ -7,6 +7,5 @@ type PlatformExecutionContext = Partial<ExecutionContextLike>;
  * the authenticated protocol headers while keeping ordinary inbound requests
  * on the normal header-scrubbing path.
  */
-declare function createWorkerRevalidationContext(base: PlatformExecutionContext | undefined, handleInternalRequest: (request: Request, ctx: ExecutionContextLike) => Promise<Response>): ExecutionContextLike;
-//#endregion
-export { createWorkerRevalidationContext };
+export declare function createWorkerRevalidationContext(base: PlatformExecutionContext | undefined, handleInternalRequest: (request: Request, ctx: ExecutionContextLike) => Promise<Response>, defaultHostRuntime?: "node" | "worker"): ExecutionContextLike;
+//#endregion

package/dist/server/worker-revalidation-context.js

@@ -1,5 +1,5 @@
 //#region src/server/worker-revalidation-context.ts
-function deriveExecutionContext(base, dispatchPagesRevalidate, isInternalPagesRevalidation) {
+function deriveExecutionContext(base, dispatchPagesRevalidate, isInternalPagesRevalidation, defaultHostRuntime) {
 	return {
 		waitUntil(promise) {
 			if (typeof base?.waitUntil === "function") base.waitUntil(promise);
@@ -8,7 +8,7 @@ function deriveExecutionContext(base, dispatchPagesRevalidate, isInternalPagesRe
 		...typeof base?.passThroughOnException === "function" ? { passThroughOnException() {
 			base.passThroughOnException?.();
 		} } : {},
-		hostRuntime: "worker",
+		hostRuntime: base?.hostRuntime ?? defaultHostRuntime,
 		...base?.cache === void 0 ? {} : { cache: base.cache },
 		...base?.trustedRevalidateOrigin === void 0 ? {} : { trustedRevalidateOrigin: base.trustedRevalidateOrigin },
 		dispatchPagesRevalidate,
@@ -21,10 +21,10 @@ function deriveExecutionContext(base, dispatchPagesRevalidate, isInternalPagesRe
 * the authenticated protocol headers while keeping ordinary inbound requests
 * on the normal header-scrubbing path.
 */
-function createWorkerRevalidationContext(base, handleInternalRequest) {
+function createWorkerRevalidationContext(base, handleInternalRequest, defaultHostRuntime = "worker") {
 	if (typeof base?.dispatchPagesRevalidate === "function") return base;
-	const dispatchPagesRevalidate = (request) => handleInternalRequest(request, deriveExecutionContext(base, dispatchPagesRevalidate, true));
-	return deriveExecutionContext(base, dispatchPagesRevalidate, false);
+	const dispatchPagesRevalidate = (request) => handleInternalRequest(request, deriveExecutionContext(base, dispatchPagesRevalidate, true, defaultHostRuntime));
+	return deriveExecutionContext(base, dispatchPagesRevalidate, false, defaultHostRuntime);
 }
 //#endregion
 export { createWorkerRevalidationContext };