@qzsy/vinext 0.1.7

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

@@ -0,0 +1,231 @@
+import { normalizePathSeparators } from "../utils/path.js";
+import { ASSET_PREFIX_URL_DIR } from "../utils/asset-prefix.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region src/server/static-file-cache.ts
+/**
+* Startup metadata cache for static file serving.
+*
+* Walks dist/client/ once at server boot, pre-computes response headers for
+* every file variant (original, brotli, gzip, zstd), and caches everything
+* in memory. The per-request hot path is just: Map.get() → string compare
+* (ETag) → writeHead(precomputed) → pipe.
+*
+* Modeled after sirv's production mode. Key insight from sirv: pre-compute
+* ALL response headers at startup — Content-Type, Content-Length, ETag,
+* Cache-Control, Content-Encoding, Vary — as reusable objects. The common
+* per-request path (no extraHeaders) does zero object allocation for headers.
+*/
+/** Content-type lookup for static assets. Shared with prod-server.ts. */
+const CONTENT_TYPES = {
+	".js": "application/javascript",
+	".mjs": "application/javascript",
+	".css": "text/css",
+	".html": "text/html",
+	".json": "application/json",
+	".txt": "text/plain; charset=utf-8",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".svg": "image/svg+xml",
+	".ico": "image/x-icon",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".ttf": "font/ttf",
+	".eot": "application/vnd.ms-fontobject",
+	".webp": "image/webp",
+	".avif": "image/avif",
+	".map": "application/json",
+	".rsc": "text/x-component"
+};
+/**
+* Files below this size are buffered in memory at startup for zero-syscall
+* serving via res.end(buffer). Above this, files stream via createReadStream.
+* 64KB covers virtually all precompressed assets (a 200KB JS bundle compresses
+* to ~50KB with brotli q5).
+*/
+const BUFFER_THRESHOLD = 64 * 1024;
+/**
+* In-memory cache of static file metadata, populated once at server startup.
+*
+* Usage:
+*   const cache = await StaticFileCache.create(clientDir);
+*   const entry = cache.lookup("/_next/static/app-abc123.js");
+*   // entry.br?.headers, entry.original.headers, etc.
+*/
+var StaticFileCache = class StaticFileCache {
+	entries;
+	constructor(entries) {
+		this.entries = entries;
+	}
+	/**
+	* Scan the client directory and build the cache.
+	*
+	* Gracefully handles non-existent directories (returns an empty cache).
+	*/
+	static async create(clientDir) {
+		const entries = /* @__PURE__ */ new Map();
+		const allFiles = /* @__PURE__ */ new Map();
+		for await (const { relativePath, fullPath, stat } of walkFilesWithStats(clientDir)) allFiles.set(relativePath, {
+			fullPath,
+			size: stat.size,
+			mtimeMs: stat.mtimeMs
+		});
+		for (const [relativePath, fileInfo] of allFiles) {
+			if (relativePath.endsWith(".br") || relativePath.endsWith(".gz") || relativePath.endsWith(".zst")) continue;
+			if (relativePath.startsWith(".vite/") || relativePath === ".vite") continue;
+			const ext = path.extname(relativePath);
+			const contentType = CONTENT_TYPES[ext] ?? "application/octet-stream";
+			const isHashed = relativePath.startsWith(`_next/static/`) || relativePath.includes(`/_next/static/`);
+			const cacheControl = isHashed ? "public, max-age=31536000, immutable" : "public, max-age=3600";
+			const etag = isHashed && etagFromFilenameHash(relativePath, ext) || `W/"${fileInfo.size}-${Math.floor(fileInfo.mtimeMs / 1e3)}"`;
+			const baseHeaders = {
+				"Content-Type": contentType,
+				"Cache-Control": cacheControl,
+				ETag: etag
+			};
+			const original = {
+				path: fileInfo.fullPath,
+				size: fileInfo.size,
+				headers: {
+					...baseHeaders,
+					"Content-Length": String(fileInfo.size)
+				}
+			};
+			const entry = {
+				etag,
+				notModifiedHeaders: {
+					ETag: etag,
+					"Cache-Control": cacheControl
+				},
+				original
+			};
+			const brInfo = allFiles.get(relativePath + ".br");
+			if (brInfo) entry.br = buildVariant(brInfo, baseHeaders, "br");
+			const gzInfo = allFiles.get(relativePath + ".gz");
+			if (gzInfo) entry.gz = buildVariant(gzInfo, baseHeaders, "gzip");
+			const zstInfo = allFiles.get(relativePath + ".zst");
+			if (zstInfo) entry.zst = buildVariant(zstInfo, baseHeaders, "zstd");
+			if (entry.br || entry.gz || entry.zst) {
+				original.headers["Vary"] = "Accept-Encoding";
+				entry.notModifiedHeaders["Vary"] = "Accept-Encoding";
+			}
+			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);
+			}
+		}
+		const toBuffer = [];
+		const seenEntries = /* @__PURE__ */ new Set();
+		for (const entry of entries.values()) {
+			if (seenEntries.has(entry)) continue;
+			seenEntries.add(entry);
+			for (const variant of [
+				entry.original,
+				entry.br,
+				entry.gz,
+				entry.zst
+			]) {
+				if (!variant || variant.size > BUFFER_THRESHOLD) continue;
+				toBuffer.push(variant);
+			}
+		}
+		for (let i = 0; i < toBuffer.length; i += 64) await Promise.all(toBuffer.slice(i, i + 64).map(async (v) => {
+			v.buffer = await fs.readFile(v.path);
+		}));
+		return new StaticFileCache(entries);
+	}
+	/**
+	* Look up cached metadata for a URL pathname.
+	*
+	* Returns undefined if the file is not in the cache. The root path "/"
+	* always returns undefined — index.html is served by SSR/RSC.
+	*/
+	lookup(pathname) {
+		if (pathname === "/") return void 0;
+		if (pathname.startsWith("/.vite/") || pathname === "/.vite") return void 0;
+		return this.entries.get(pathname);
+	}
+};
+/**
+* Extract a stable weak ETag from a Vite hashed filename (e.g. `app-DqZc3R4n.js`).
+* The hash is a content hash computed by the bundler — deterministic across
+* identical builds regardless of filesystem timestamps.
+*
+* Must be a weak validator (W/) because the same tag is shared across
+* content-encoded variants (original, .br, .gz, .zst) which are byte-different.
+* Returns null if the filename doesn't contain a recognizable hash suffix,
+* so the caller can fall back to mtime-based ETags.
+*/
+function etagFromFilenameHash(relativePath, ext) {
+	const basename = path.basename(relativePath, ext);
+	const lastDash = basename.lastIndexOf("-");
+	if (lastDash !== -1 && lastDash !== basename.length - 1) {
+		const suffix = basename.slice(lastDash + 1);
+		if (suffix.length >= 6 && suffix.length <= 12 && /^[A-Za-z0-9_-]+$/.test(suffix)) return `W/"${suffix}"`;
+	}
+	const normalizedPath = normalizePathSeparators(relativePath);
+	const managedMediaSegment = `${ASSET_PREFIX_URL_DIR}/media/`;
+	if (normalizedPath.startsWith(managedMediaSegment) || normalizedPath.includes(`/${managedMediaSegment}`)) {
+		const lastDot = basename.lastIndexOf(".");
+		if (lastDot !== -1) {
+			const suffix = basename.slice(lastDot + 1);
+			if (/^[0-9a-f]{8}$/.test(suffix)) return `W/"${suffix}"`;
+		}
+	}
+	return null;
+}
+function buildVariant(info, baseHeaders, encoding) {
+	return {
+		path: info.fullPath,
+		size: info.size,
+		headers: {
+			...baseHeaders,
+			"Content-Encoding": encoding,
+			"Content-Length": String(info.size),
+			Vary: "Accept-Encoding"
+		}
+	};
+}
+/** Batch size for concurrent stat() calls during directory walk. */
+const STAT_BATCH_SIZE = 64;
+/**
+* Walk a directory recursively, yielding file paths and stats.
+*
+* Batches stat() calls per directory to avoid sequential syscall overhead
+* for large dist/client/ directories.
+*/
+async function* walkFilesWithStats(dir, base = dir) {
+	let entries;
+	try {
+		entries = await fs.readdir(dir, { withFileTypes: true });
+	} catch {
+		return;
+	}
+	const files = [];
+	for (const entry of entries) {
+		const fullPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) yield* walkFilesWithStats(fullPath, base);
+		else if (entry.isFile()) files.push(fullPath);
+	}
+	for (let i = 0; i < files.length; i += STAT_BATCH_SIZE) {
+		const batch = files.slice(i, i + STAT_BATCH_SIZE);
+		const stats = await Promise.all(batch.map((f) => fs.stat(f)));
+		for (let j = 0; j < batch.length; j++) yield {
+			relativePath: normalizePathSeparators(path.relative(base, batch[j])),
+			fullPath: batch[j],
+			stat: {
+				size: stats[j].size,
+				mtimeMs: stats[j].mtimeMs
+			}
+		};
+	}
+}
+//#endregion
+export { CONTENT_TYPES, StaticFileCache, etagFromFilenameHash };

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

@@ -0,0 +1,15 @@
+import { ArtifactCompatibilityEnvelope } from "./artifact-compatibility.js";
+
+//#region src/server/static-layout-client-reuse-proof.d.ts
+type StaticLayoutClientReuseProofInput = Readonly<{
+  artifactCompatibility: ArtifactCompatibilityEnvelope;
+  layoutId: string;
+  rootBoundaryId: string | null;
+  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 };

package/dist/server/static-layout-client-reuse-proof.js

@@ -0,0 +1,33 @@
+import { ARTIFACT_COMPATIBILITY_PROOF_FIELDS } from "./artifact-compatibility.js";
+import { createClientReusePayloadHash } from "./client-reuse-manifest.js";
+//#region src/server/static-layout-client-reuse-proof.ts
+function createStaticLayoutClientReuseRouteId(layoutId) {
+	return `static-layout:${createClientReusePayloadHash(layoutId)}`;
+}
+function createCanonicalProofPairs(input) {
+	return ARTIFACT_COMPATIBILITY_PROOF_FIELDS.map((field) => [field, input.artifactCompatibility[field]]);
+}
+function createStaticLayoutClientReusePayloadHash(input) {
+	return createClientReusePayloadHash(JSON.stringify({
+		artifactCompatibilityPairs: createCanonicalProofPairs(input),
+		layoutId: input.layoutId,
+		rootBoundaryId: input.rootBoundaryId,
+		variantCacheKey: input.variantCacheKey
+	}));
+}
+function createStaticLayoutClientReuseArtifactCompatibility(input) {
+	return {
+		...input.artifactCompatibility,
+		graphVersion: `static-layout-graph:${createClientReusePayloadHash(JSON.stringify({
+			layoutId: input.layoutId,
+			rootBoundaryId: input.rootBoundaryId
+		}))}`,
+		renderEpoch: `static-layout:${createClientReusePayloadHash(JSON.stringify({
+			layoutId: input.layoutId,
+			rootBoundaryId: input.rootBoundaryId,
+			variantCacheKey: input.variantCacheKey
+		}))}`
+	};
+}
+//#endregion
+export { createStaticLayoutClientReuseArtifactCompatibility, createStaticLayoutClientReusePayloadHash, createStaticLayoutClientReuseRouteId };

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

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

package/dist/server/streaming-metadata.js

@@ -0,0 +1,8 @@
+import { getHtmlLimitedBotRegex } from "../utils/html-limited-bots.js";
+//#region src/server/streaming-metadata.ts
+function shouldServeStreamingMetadata(userAgent, htmlLimitedBots) {
+	if (!userAgent) return true;
+	return !getHtmlLimitedBotRegex(htmlLimitedBots).test(userAgent);
+}
+//#endregion
+export { shouldServeStreamingMetadata };

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

@@ -0,0 +1,7 @@
+//#region src/server/worker-utils.d.ts
+declare function mergeHeaders(response: Response, extraHeaders: Record<string, string | string[]>, statusOverride?: number): Response;
+declare function resolveStaticAssetSignal(signalResponse: Response, options: {
+  fetchAsset(path: string): Promise<Response>;
+}): Promise<Response | null>;
+//#endregion
+export { mergeHeaders, resolveStaticAssetSignal };

package/dist/server/worker-utils.js

@@ -0,0 +1,99 @@
+import { VINEXT_STATIC_FILE_HEADER } from "./headers.js";
+//#region src/server/worker-utils.ts
+/**
+* Shared utilities for Cloudflare Worker entries.
+*
+* Used by hand-written example worker entries and by the generated Pages
+* Router worker entry through "vinext/server/worker-utils".
+*/
+/**
+* Merge middleware/config headers into a response.
+* Response headers take precedence over middleware headers for all headers
+* except Set-Cookie, which is additive (both middleware and response cookies
+* are preserved). Uses getSetCookie() to preserve multiple Set-Cookie values.
+* Keep this in sync with prod-server.ts.
+*/
+const NO_BODY_RESPONSE_STATUSES = new Set([
+	204,
+	205,
+	304
+]);
+function isVinextStreamedHtmlResponse(response) {
+	return response.__vinextStreamedHtmlResponse === true;
+}
+function isContentLengthHeader(name) {
+	return name.toLowerCase() === "content-length";
+}
+function cancelResponseBody(response) {
+	const body = response.body;
+	if (!body || body.locked) return;
+	body.cancel().catch(() => {});
+}
+function buildHeaderRecord(response, omitNames = []) {
+	const omitted = new Set(omitNames.map((name) => name.toLowerCase()));
+	const headers = {};
+	response.headers.forEach((value, key) => {
+		if (omitted.has(key.toLowerCase()) || key === "set-cookie") return;
+		headers[key] = value;
+	});
+	const cookies = response.headers.getSetCookie?.() ?? [];
+	if (cookies.length > 0) headers["set-cookie"] = cookies;
+	return headers;
+}
+function mergeHeaders(response, extraHeaders, statusOverride) {
+	const status = statusOverride ?? response.status;
+	const merged = new Headers();
+	for (const [k, v] of Object.entries(extraHeaders)) {
+		if (isContentLengthHeader(k)) continue;
+		if (Array.isArray(v)) for (const item of v) merged.append(k, item);
+		else merged.set(k, v);
+	}
+	response.headers.forEach((v, k) => {
+		if (k === "set-cookie") return;
+		merged.set(k, v);
+	});
+	const responseCookies = response.headers.getSetCookie?.() ?? [];
+	for (const cookie of responseCookies) merged.append("set-cookie", cookie);
+	const shouldDropBody = NO_BODY_RESPONSE_STATUSES.has(status);
+	const shouldStripStreamLength = isVinextStreamedHtmlResponse(response) && merged.has("content-length");
+	if (!Object.keys(extraHeaders).some((key) => !isContentLengthHeader(key)) && statusOverride === void 0 && !shouldDropBody && !shouldStripStreamLength) return response;
+	if (shouldDropBody) {
+		cancelResponseBody(response);
+		merged.delete("content-encoding");
+		merged.delete("content-length");
+		merged.delete("content-type");
+		merged.delete("transfer-encoding");
+		return new Response(null, {
+			status,
+			statusText: status === response.status ? response.statusText : void 0,
+			headers: merged
+		});
+	}
+	if (shouldStripStreamLength) merged.delete("content-length");
+	return new Response(response.body, {
+		status,
+		statusText: status === response.status ? response.statusText : void 0,
+		headers: merged
+	});
+}
+async function resolveStaticAssetSignal(signalResponse, options) {
+	const signal = signalResponse.headers.get(VINEXT_STATIC_FILE_HEADER);
+	if (!signal) return null;
+	let assetPath = "/";
+	try {
+		assetPath = decodeURIComponent(signal);
+	} catch {
+		assetPath = signal;
+	}
+	const extraHeaders = buildHeaderRecord(signalResponse, [
+		VINEXT_STATIC_FILE_HEADER,
+		"content-encoding",
+		"content-length",
+		"content-type"
+	]);
+	cancelResponseBody(signalResponse);
+	const assetResponse = await options.fetchAsset(assetPath);
+	return mergeHeaders(assetResponse, extraHeaders, assetResponse.ok && signalResponse.status !== 200 ? signalResponse.status : void 0);
+}
+//#endregion
+export { mergeHeaders, resolveStaticAssetSignal };

package/dist/shims/amp.d.ts

@@ -0,0 +1,19 @@
+//#region src/shims/amp.d.ts
+/**
+ * next/amp shim
+ *
+ * AMP support was deprecated in Next.js 13+ and removed in later versions.
+ * These are no-op stubs for apps that still import from next/amp.
+ */
+/**
+ * Check if the current page is being served as AMP.
+ * Always returns false — AMP is not supported.
+ */
+declare function useAmp(): boolean;
+/**
+ * Check if AMP is enabled for the current page.
+ * Always returns false.
+ */
+declare function isInAmpMode(): boolean;
+//#endregion
+export { isInAmpMode, useAmp };

package/dist/shims/amp.js

@@ -0,0 +1,23 @@
+//#region src/shims/amp.ts
+/**
+* next/amp shim
+*
+* AMP support was deprecated in Next.js 13+ and removed in later versions.
+* These are no-op stubs for apps that still import from next/amp.
+*/
+/**
+* Check if the current page is being served as AMP.
+* Always returns false — AMP is not supported.
+*/
+function useAmp() {
+	return false;
+}
+/**
+* Check if AMP is enabled for the current page.
+* Always returns false.
+*/
+function isInAmpMode() {
+	return false;
+}
+//#endregion
+export { isInAmpMode, useAmp };

package/dist/shims/app-router-scroll-state.d.ts

@@ -0,0 +1,15 @@
+//#region src/shims/app-router-scroll-state.d.ts
+type AppRouterScrollIntent = Readonly<{
+  commitId: number | null;
+  hash: string | null;
+  id: number;
+  targetHoistedInHead: boolean;
+}>;
+declare function beginAppRouterScrollIntent(hash: string | null): AppRouterScrollIntent;
+declare function clearAppRouterScrollIntent(): void;
+declare function getPendingAppRouterScrollIntent(): AppRouterScrollIntent | null;
+declare function claimAppRouterScrollIntentForCommit(expected: AppRouterScrollIntent | null | undefined, commitId: number): void;
+declare function markAppRouterScrollIntentHeadHoisted(expected: AppRouterScrollIntent | null | undefined, commitId: number): void;
+declare function consumeAppRouterScrollIntent(expected: AppRouterScrollIntent | null | undefined, commitId?: number): AppRouterScrollIntent | null;
+//#endregion
+export { AppRouterScrollIntent, beginAppRouterScrollIntent, claimAppRouterScrollIntentForCommit, clearAppRouterScrollIntent, consumeAppRouterScrollIntent, getPendingAppRouterScrollIntent, markAppRouterScrollIntentHeadHoisted };

package/dist/shims/app-router-scroll-state.js

@@ -0,0 +1,61 @@
+//#region src/shims/app-router-scroll-state.ts
+const _SCROLL_INTENT_KEY = Symbol.for("vinext.appRouterScrollIntent");
+function getScrollIntentStore() {
+	const globalState = globalThis;
+	globalState[_SCROLL_INTENT_KEY] ??= {
+		nextId: 0,
+		pending: null
+	};
+	return globalState[_SCROLL_INTENT_KEY];
+}
+function beginAppRouterScrollIntent(hash) {
+	const store = getScrollIntentStore();
+	store.nextId += 1;
+	const intent = {
+		commitId: null,
+		hash,
+		id: store.nextId,
+		targetHoistedInHead: false
+	};
+	store.pending = intent;
+	return intent;
+}
+function clearAppRouterScrollIntent() {
+	getScrollIntentStore().pending = null;
+}
+function getPendingAppRouterScrollIntent() {
+	return getScrollIntentStore().pending;
+}
+function claimAppRouterScrollIntentForCommit(expected, commitId) {
+	const store = getScrollIntentStore();
+	const intent = store.pending;
+	if (expected === null || expected === void 0 || intent === null) return;
+	if (intent.id !== expected.id) return;
+	store.pending = {
+		...intent,
+		commitId
+	};
+}
+function markAppRouterScrollIntentHeadHoisted(expected, commitId) {
+	const store = getScrollIntentStore();
+	const intent = store.pending;
+	if (expected === null || expected === void 0 || intent === null) return;
+	if (intent.id !== expected.id) return;
+	if (intent.commitId !== commitId) return;
+	store.pending = {
+		...intent,
+		targetHoistedInHead: true
+	};
+}
+function consumeAppRouterScrollIntent(expected, commitId) {
+	if (expected === null || expected === void 0) return null;
+	const store = getScrollIntentStore();
+	const intent = store.pending;
+	if (intent === null) return null;
+	if (intent.id !== expected.id) return null;
+	if (commitId !== void 0 && intent.commitId !== commitId) return null;
+	store.pending = null;
+	return intent;
+}
+//#endregion
+export { beginAppRouterScrollIntent, claimAppRouterScrollIntentForCommit, clearAppRouterScrollIntent, consumeAppRouterScrollIntent, getPendingAppRouterScrollIntent, markAppRouterScrollIntentHeadHoisted };

package/dist/shims/app-router-scroll.d.ts

@@ -0,0 +1,29 @@
+import * as React$1 from "react";
+
+//#region src/shims/app-router-scroll.d.ts
+declare class AppRouterScrollTargetInner extends React$1.Component<{
+  children: React$1.ReactNode;
+  commitId: number | null;
+}> {
+  scheduledCommitId: number | null;
+  schedulePotentialScroll: () => void;
+  handlePotentialScroll: () => void;
+  componentDidMount(): void;
+  componentDidUpdate(): void;
+  componentWillUnmount(): void;
+  render(): React$1.ReactNode;
+}
+declare function AppRouterScrollCommitProvider({
+  children,
+  commitId
+}: {
+  children?: React$1.ReactNode;
+  commitId: number | null;
+}): React$1.JSX.Element;
+declare function AppRouterScrollTarget({
+  children
+}: {
+  children: React$1.ReactNode;
+}): React$1.JSX.Element;
+//#endregion
+export { AppRouterScrollCommitProvider, AppRouterScrollTarget, AppRouterScrollTargetInner };