vinext 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/shims/unified-request-context.d.ts

@@ -8,6 +8,7 @@ import { PrivateCacheState } from "./cache-runtime.js";
 import { HeadState } from "./head-state.js";
 import { I18nState } from "./i18n-state.js";
 import { NavigationState } from "./navigation-state.js";
+import "./request-state-types.js";
 //#region src/shims/unified-request-context.d.ts
 /**
  * Flat union of all per-request state previously spread across
@@ -17,14 +18,18 @@ import { NavigationState } from "./navigation-state.js";
  * Each field group is documented with its source shim module.
  */
 type UnifiedRequestContext = {
-  /** Cloudflare Workers ExecutionContext, or null on Node.js dev. */executionContext: ExecutionContextLike | null; /** Per-request cache for cacheForRequest(). Keyed by factory function reference. */
-  requestCache: WeakMap<(...args: any[]) => any, unknown>; /** Shared lifecycle state for work deferred until the response closes. */
+  /** Cloudflare Workers ExecutionContext, or null on Node.js dev. */
+  executionContext: ExecutionContextLike | null;
+  /** Per-request cache for cacheForRequest(). Keyed by factory function reference. */
+  requestCache: WeakMap<(...args: any[]) => any, unknown>;
+  /** Shared lifecycle state for work deferred until the response closes. */
   afterContext: AfterRequestContext;
 } & VinextHeadersShimState & I18nState & NavigationState & CacheState & PrivateCacheState & FetchCacheState & RouterState & HeadState & RootParamsState;
 type AfterRequestContext = {
   callbacks: Array<() => unknown>;
   responseClosed: boolean;
   pendingCallbacks: number;
+  pendingPromises: number;
   completion: Promise<void> | null;
   resolveCompletion: (() => void) | null;
 };
@@ -35,6 +40,8 @@ type AfterRequestContext = {
 declare function createRequestContext(opts?: Partial<UnifiedRequestContext>): UnifiedRequestContext;
 /** Queue a callback until response close, or start it immediately once closed. */
 declare function queueAfterCallback(ctx: UnifiedRequestContext, callback: () => unknown): void;
+/** Track promise-form after() work that can register a callback before settling. */
+declare function trackAfterPromise<T>(ctx: UnifiedRequestContext, promise: Promise<T>): Promise<T>;
 /** Bind a callback to every AsyncLocalStorage context active at registration. */
 declare function bindRequestContextSnapshot<T>(ctx: UnifiedRequestContext, callback: () => T): () => T;
 /**
@@ -42,7 +49,40 @@ declare function bindRequestContextSnapshot<T>(ctx: UnifiedRequestContext, callb
  * All queued callbacks start together, matching Next.js' unbounded PromiseQueue.
  */
 declare function closeAfterResponse(ctx: UnifiedRequestContext): Promise<void>;
-/** Wrap a response so deferred callbacks start on stream completion or cancellation. */
+/**
+ * Whether this request has function-form `after()` work that still needs to
+ * observe the response body closing.
+ *
+ * Promise-form `after(promise)` is included because its continuation can
+ * register a function-form `after()` before the promise settles. Function-form
+ * work needs the body's close observed because its contract is "run once the
+ * response has been sent". `resolveCompletion` stays non-null for as long as
+ * any callback is queued or in flight, so checking it alongside the explicit
+ * counters keeps this correct on re-entry after callbacks have started.
+ */
+declare function requiresResponseCloseTracking(ctx: UnifiedRequestContext): boolean;
+/**
+ * Mark a response whose body vinext constructed from a fully in-memory string
+ * or byte array, as opposed to a body handed back by user code, which could
+ * still be producing. With no producer left, no `after()` call can originate
+ * from this body — the one signal that makes it safe for
+ * `closeAfterResponseWithBody()` to skip close tracking.
+ *
+ * Not set for a metadata route's `result instanceof Response` passthrough (a
+ * user `icon.tsx`/`opengraph-image.tsx` can return a streaming
+ * `ImageResponse`) or any handler-returned `new Response(stream)` — those
+ * bodies can still be producing and must keep close tracking.
+ */
+declare function markFullyBufferedBody(response: Response): Response;
+/** Preserve the internal buffered-body signal when response metadata is rebuilt. */
+declare function preserveFullyBufferedBodyMetadata(source: Response, target: Response): Response;
+/**
+ * Wrap a response so deferred `after()` callbacks start on stream completion
+ * or cancellation. Skipped only when the body is marked fully buffered (see
+ * `markFullyBufferedBody`) and nothing is currently registered — that lets
+ * the runtime send it with an accurate `Content-Length` instead of chunked
+ * transfer encoding.
+ */
 declare function closeAfterResponseWithBody(response: Response, ctx: UnifiedRequestContext): Response;
 /**
  * Run `fn` within a unified request context scope.
@@ -84,4 +124,4 @@ declare function getRequestContext(): UnifiedRequestContext;
  */
 declare function isInsideUnifiedScope(): boolean;
 //#endregion
-export { AfterRequestContext, UnifiedRequestContext, bindRequestContextSnapshot, closeAfterResponse, closeAfterResponseWithBody, createRequestContext, getRequestContext, isInsideUnifiedScope, queueAfterCallback, runWithRequestContext, runWithUnifiedStateMutation };
+export { AfterRequestContext, UnifiedRequestContext, bindRequestContextSnapshot, closeAfterResponse, closeAfterResponseWithBody, createRequestContext, getRequestContext, isInsideUnifiedScope, markFullyBufferedBody, preserveFullyBufferedBodyMetadata, queueAfterCallback, requiresResponseCloseTracking, runWithRequestContext, runWithUnifiedStateMutation, trackAfterPromise };

package/dist/shims/unified-request-context.js

@@ -47,6 +47,7 @@ function createRequestContext(opts) {
 			callbacks: [],
 			responseClosed: false,
 			pendingCallbacks: 0,
+			pendingPromises: 0,
 			completion: null,
 			resolveCompletion: null
 		},
@@ -92,6 +93,13 @@ function queueAfterCallback(ctx, callback) {
 	if (ctx.afterContext.responseClosed) startAfterCallback(ctx, callback);
 	else ctx.afterContext.callbacks.push(callback);
 }
+/** Track promise-form after() work that can register a callback before settling. */
+function trackAfterPromise(ctx, promise) {
+	ctx.afterContext.pendingPromises += 1;
+	return promise.finally(() => {
+		ctx.afterContext.pendingPromises -= 1;
+	});
+}
 /** Bind a callback to every AsyncLocalStorage context active at registration. */
 function bindRequestContextSnapshot(ctx, callback) {
 	const constructor = _als.constructor;
@@ -115,12 +123,57 @@ async function closeAfterResponse(ctx) {
 	}
 	return state.completion ?? Promise.resolve();
 }
-/** Wrap a response so deferred callbacks start on stream completion or cancellation. */
+/**
+* Whether this request has function-form `after()` work that still needs to
+* observe the response body closing.
+*
+* Promise-form `after(promise)` is included because its continuation can
+* register a function-form `after()` before the promise settles. Function-form
+* work needs the body's close observed because its contract is "run once the
+* response has been sent". `resolveCompletion` stays non-null for as long as
+* any callback is queued or in flight, so checking it alongside the explicit
+* counters keeps this correct on re-entry after callbacks have started.
+*/
+function requiresResponseCloseTracking(ctx) {
+	const state = ctx.afterContext;
+	return state.callbacks.length > 0 || state.pendingCallbacks > 0 || state.pendingPromises > 0 || state.resolveCompletion !== null;
+}
+/**
+* Mark a response whose body vinext constructed from a fully in-memory string
+* or byte array, as opposed to a body handed back by user code, which could
+* still be producing. With no producer left, no `after()` call can originate
+* from this body — the one signal that makes it safe for
+* `closeAfterResponseWithBody()` to skip close tracking.
+*
+* Not set for a metadata route's `result instanceof Response` passthrough (a
+* user `icon.tsx`/`opengraph-image.tsx` can return a streaming
+* `ImageResponse`) or any handler-returned `new Response(stream)` — those
+* bodies can still be producing and must keep close tracking.
+*/
+function markFullyBufferedBody(response) {
+	response.__vinextFullyBufferedBody = true;
+	return response;
+}
+function isFullyBufferedBody(response) {
+	return response.__vinextFullyBufferedBody === true;
+}
+/** Preserve the internal buffered-body signal when response metadata is rebuilt. */
+function preserveFullyBufferedBodyMetadata(source, target) {
+	return isFullyBufferedBody(source) ? markFullyBufferedBody(target) : target;
+}
+/**
+* Wrap a response so deferred `after()` callbacks start on stream completion
+* or cancellation. Skipped only when the body is marked fully buffered (see
+* `markFullyBufferedBody`) and nothing is currently registered — that lets
+* the runtime send it with an accurate `Content-Length` instead of chunked
+* transfer encoding.
+*/
 function closeAfterResponseWithBody(response, ctx) {
 	if (!response.body) {
 		queueMicrotask(() => void closeAfterResponse(ctx));
 		return response;
 	}
+	if (isFullyBufferedBody(response) && !requiresResponseCloseTracking(ctx)) return response;
 	const passthrough = new TransformStream();
 	response.body.pipeTo(passthrough.writable).then(() => void closeAfterResponse(ctx), () => void closeAfterResponse(ctx));
 	const wrapped = new Response(passthrough.readable, {
@@ -129,6 +182,7 @@ function closeAfterResponseWithBody(response, ctx) {
 		headers: response.headers
 	});
 	wrapped.__vinextStreamedHtmlResponse = response.__vinextStreamedHtmlResponse;
+	wrapped.__vinextStreamedApiResponse = response.__vinextStreamedApiResponse;
 	return wrapped;
 }
 function runWithRequestContext(ctx, fn) {
@@ -167,4 +221,4 @@ function isInsideUnifiedScope() {
 	return _als.getStore() != null;
 }
 //#endregion
-export { bindRequestContextSnapshot, closeAfterResponse, closeAfterResponseWithBody, createRequestContext, getRequestContext, isInsideUnifiedScope, queueAfterCallback, runWithRequestContext, runWithUnifiedStateMutation };
+export { bindRequestContextSnapshot, closeAfterResponse, closeAfterResponseWithBody, createRequestContext, getRequestContext, isInsideUnifiedScope, markFullyBufferedBody, preserveFullyBufferedBodyMetadata, queueAfterCallback, requiresResponseCloseTracking, runWithRequestContext, runWithUnifiedStateMutation, trackAfterPromise };

package/dist/shims/use-merged-ref.d.ts

@@ -1,5 +1,4 @@
 import { Ref } from "react";
-
 //#region src/shims/use-merged-ref.d.ts
 declare function useMergedRef<TElement>(refA: Ref<TElement>, refB: Ref<TElement>): Ref<TElement>;
 //#endregion

package/dist/shims/web-vitals.d.ts

@@ -1,5 +1,4 @@
 import { MetricType } from "web-vitals";
-
 //#region src/shims/web-vitals.d.ts
 type WebVitalsMetric = MetricType;
 type ReportWebVitalsCallback = (metric: WebVitalsMetric) => void;

package/dist/typegen.d.ts

@@ -9,7 +9,6 @@ type GenerateRouteTypesResult = {
   nextEnvPath: string;
   nextEnvStatus: "created" | "updated" | "unchanged";
 };
-declare function nextEnvFileContent(hasNext: boolean, hasAppDir: boolean, eol?: string): string;
 declare function generateRouteTypes(options: GenerateRouteTypesOptions): Promise<GenerateRouteTypesResult>;
 //#endregion
-export { GenerateRouteTypesResult, generateRouteTypes, nextEnvFileContent };
+export { GenerateRouteTypesResult, generateRouteTypes };

package/dist/typegen.js

@@ -285,4 +285,4 @@ function quote(value) {
 	return JSON.stringify(value);
 }
 //#endregion
-export { generateRouteTypes, nextEnvFileContent };
+export { generateRouteTypes };

package/dist/utils/cache-control-metadata.d.ts

@@ -1,5 +1,17 @@
 //#region src/utils/cache-control-metadata.d.ts
 declare function readCacheControlNumberField(ctx: Record<string, unknown> | undefined, field: string): number | undefined;
 declare function readCacheControlRevalidateField(ctx: Record<string, unknown> | undefined): number | false | undefined;
+/**
+ * Client-reuse seconds from a resolved `cacheLife`. Shared by every emitter
+ * (ISR write, hit replay, prerender seed, done-script) so warm hits claim what
+ * the producing render claimed. Two rules: never synthesize `stale` from
+ * `revalidate`/`expire` (the `default` profile would license ~136y of reuse),
+ * and never clamp it by them (Next.js replays the stored value verbatim;
+ * `expire` is a serve-side ceiling, not a client bound). A literal `stale: 0`
+ * is still a real client claim; it must not be treated as absent.
+ */
+declare function resolveClientStaleTimeSeconds(cacheLife: {
+  stale?: number;
+} | null | undefined): number | undefined;
 //#endregion
-export { readCacheControlNumberField, readCacheControlRevalidateField };
+export { readCacheControlNumberField, readCacheControlRevalidateField, resolveClientStaleTimeSeconds };

package/dist/utils/cache-control-metadata.js

@@ -12,5 +12,21 @@ function readCacheControlRevalidateField(ctx) {
 	const value = readRecordField(ctx, "cacheControl")?.revalidate ?? ctx?.revalidate;
 	return typeof value === "number" || value === false ? value : void 0;
 }
+function isFiniteNonNegative(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+/**
+* Client-reuse seconds from a resolved `cacheLife`. Shared by every emitter
+* (ISR write, hit replay, prerender seed, done-script) so warm hits claim what
+* the producing render claimed. Two rules: never synthesize `stale` from
+* `revalidate`/`expire` (the `default` profile would license ~136y of reuse),
+* and never clamp it by them (Next.js replays the stored value verbatim;
+* `expire` is a serve-side ceiling, not a client bound). A literal `stale: 0`
+* is still a real client claim; it must not be treated as absent.
+*/
+function resolveClientStaleTimeSeconds(cacheLife) {
+	const stale = cacheLife?.stale;
+	return isFiniteNonNegative(stale) ? stale : void 0;
+}
 //#endregion
-export { readCacheControlNumberField, readCacheControlRevalidateField };
+export { readCacheControlNumberField, readCacheControlRevalidateField, resolveClientStaleTimeSeconds };

package/dist/utils/client-build-manifest.d.ts

@@ -1,5 +1,4 @@
 import { BuildManifestChunk } from "./lazy-chunks.js";
-
 //#region src/utils/client-build-manifest.d.ts
 type ClientBuildManifest = Record<string, BuildManifestChunk>;
 declare function readClientBuildManifest(manifestPath: string): ClientBuildManifest | undefined;

package/dist/utils/domain-locale.d.ts

@@ -16,11 +16,7 @@ declare function normalizeDomainHostname(hostname: string | null | undefined): s
 declare function detectDomainLocale(domainItems?: readonly DomainLocale[], hostname?: string, detectedLocale?: string): DomainLocale | undefined;
 declare function addLocalePrefix(path: string, locale: string, localeDefault: string): string;
 declare function getLocalePathPrefix(path: string, locales: readonly string[] | undefined): string | undefined;
-declare function getDomainLocaleUrl(url: string, locale: string, {
-  basePath,
-  currentHostname,
-  domainItems
-}: {
+declare function getDomainLocaleUrl(url: string, locale: string, { basePath, currentHostname, domainItems }: {
   basePath?: string;
   currentHostname?: string | null;
   domainItems?: readonly DomainLocale[];

package/dist/utils/html-limited-bots.js

@@ -1,5 +1,5 @@
 //#region src/utils/html-limited-bots.ts
-const HTML_LIMITED_BOT_UA_RE_STRING = String.raw`[\w-]+-Google|Google-[\w-]+|Chrome-Lighthouse|Slurp|DuckDuckBot|baiduspider|yandex|sogou|bitlybot|tumblr|vkShare|quora link preview|redditbot|ia_archiver|Bingbot|BingPreview|applebot|facebookexternalhit|facebookcatalog|meta-externalagent|meta-externalfetcher|Twitterbot|LinkedInBot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|Yeti|googleweblight`;
+const HTML_LIMITED_BOT_UA_RE_STRING = String.raw`(?:^|[^\w-])[\w-]+-Google|Google-[\w-]+|Chrome-Lighthouse|Slurp|DuckDuckBot|baiduspider|yandex|sogou|bitlybot|tumblr|vkShare|quora link preview|redditbot|ia_archiver|Bingbot|BingPreview|applebot|facebookexternalhit|facebookcatalog|meta-externalagent|meta-externalfetcher|Twitterbot|LinkedInBot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|Yeti|googleweblight`;
 const HEADLESS_BROWSER_BOT_UA_RE = /Googlebot(?!-)|Googlebot$/i;
 const htmlLimitedBotRegexCache = /* @__PURE__ */ new Map();
 function getHtmlLimitedBotRegex(htmlLimitedBots) {

package/dist/utils/middleware-request-headers.d.ts

@@ -1,11 +1,23 @@
 //#region src/utils/middleware-request-headers.d.ts
 type MiddlewareHeaderValue = string | string[];
 type MiddlewareHeaderSource = Headers | Record<string, MiddlewareHeaderValue>;
-type BuildRequestHeadersOptions = {
-  preserveCredentialHeaders?: boolean;
-};
+/**
+ * Return truthy forwarded values that Next.js does not consume through the
+ * override list. Its subsequent generic middleware-header merge exposes these
+ * under their literal protocol-header names on both the request and response.
+ */
+declare function getUnconsumedMiddlewareRequestHeaders(source: MiddlewareHeaderSource): Map<string, string>;
 declare function encodeMiddlewareRequestHeaders(targetHeaders: Headers, requestHeaders: Headers): void;
-declare function buildRequestHeadersFromMiddlewareResponse(baseHeaders: Headers, middlewareHeaders: MiddlewareHeaderSource, options?: BuildRequestHeadersOptions): Headers | null;
+/**
+ * A non-empty `x-middleware-override-headers` value lists the complete
+ * post-middleware header set, so any name absent from it was deleted by
+ * middleware. Never re-add absent headers from the base request — that would
+ * resurrect credentials the app explicitly stripped before an external
+ * rewrite. Next.js treats the empty value emitted for `new Headers()` as no
+ * override. Any unconsumed `x-middleware-request-*` values are subsequently
+ * copied to the request under their literal protocol-header names.
+ */
+declare function buildRequestHeadersFromMiddlewareResponse(baseHeaders: Headers, middlewareHeaders: MiddlewareHeaderSource): Headers | null;
 declare function shouldKeepMiddlewareHeader(key: string): boolean;
 //#endregion
-export { buildRequestHeadersFromMiddlewareResponse, encodeMiddlewareRequestHeaders, shouldKeepMiddlewareHeader };
+export { buildRequestHeadersFromMiddlewareResponse, encodeMiddlewareRequestHeaders, getUnconsumedMiddlewareRequestHeaders, shouldKeepMiddlewareHeader };

package/dist/utils/middleware-request-headers.js

@@ -1,15 +1,12 @@
 import { MIDDLEWARE_OVERRIDE_HEADERS, MIDDLEWARE_REQUEST_HEADER_PREFIX } from "./protocol-headers.js";
 //#region src/utils/middleware-request-headers.ts
-const CREDENTIAL_REQUEST_HEADERS = ["authorization", "cookie"];
 function getMiddlewareHeaderValue(source, key) {
 	if (source instanceof Headers) return source.get(key);
 	const value = source[key];
 	if (value === void 0) return null;
 	return Array.isArray(value) ? value[0] ?? null : value;
 }
-function getOverrideHeaderNames(source) {
-	const rawValue = getMiddlewareHeaderValue(source, MIDDLEWARE_OVERRIDE_HEADERS);
-	if (rawValue === null) return null;
+function parseOverrideHeaderNames(rawValue) {
 	return rawValue.split(",").map((key) => key.trim()).filter(Boolean);
 }
 function getForwardedRequestHeaders(source) {
@@ -25,41 +22,53 @@ function getForwardedRequestHeaders(source) {
 	}
 	return forwardedHeaders;
 }
-function cloneHeaders(source) {
-	const cloned = new Headers();
-	for (const [key, value] of source.entries()) cloned.append(key, value);
-	return cloned;
+/**
+* Return truthy forwarded values that Next.js does not consume through the
+* override list. Its subsequent generic middleware-header merge exposes these
+* under their literal protocol-header names on both the request and response.
+*/
+function getUnconsumedMiddlewareRequestHeaders(source) {
+	const rawOverrideHeader = getMiddlewareHeaderValue(source, MIDDLEWARE_OVERRIDE_HEADERS);
+	const overriddenHeaders = rawOverrideHeader ? new Set(parseOverrideHeaderNames(rawOverrideHeader)) : null;
+	const unconsumedHeaders = /* @__PURE__ */ new Map();
+	for (const [key, value] of getForwardedRequestHeaders(source)) if (value && !overriddenHeaders?.has(key)) unconsumedHeaders.set(`${MIDDLEWARE_REQUEST_HEADER_PREFIX}${key}`, value);
+	return unconsumedHeaders;
 }
 function encodeMiddlewareRequestHeaders(targetHeaders, requestHeaders) {
 	const overrideHeaderNames = [...requestHeaders.keys()];
 	targetHeaders.set(MIDDLEWARE_OVERRIDE_HEADERS, overrideHeaderNames.join(","));
 	for (const [key, value] of requestHeaders.entries()) targetHeaders.set(`${MIDDLEWARE_REQUEST_HEADER_PREFIX}${key}`, value);
 }
-function buildRequestHeadersFromMiddlewareResponse(baseHeaders, middlewareHeaders, options = {}) {
-	const overrideHeaderNames = getOverrideHeaderNames(middlewareHeaders);
+/**
+* A non-empty `x-middleware-override-headers` value lists the complete
+* post-middleware header set, so any name absent from it was deleted by
+* middleware. Never re-add absent headers from the base request — that would
+* resurrect credentials the app explicitly stripped before an external
+* rewrite. Next.js treats the empty value emitted for `new Headers()` as no
+* override. Any unconsumed `x-middleware-request-*` values are subsequently
+* copied to the request under their literal protocol-header names.
+*/
+function buildRequestHeadersFromMiddlewareResponse(baseHeaders, middlewareHeaders) {
 	const forwardedHeaders = getForwardedRequestHeaders(middlewareHeaders);
-	if (overrideHeaderNames === null && forwardedHeaders.size === 0) return null;
-	const nextHeaders = overrideHeaderNames === null ? cloneHeaders(baseHeaders) : new Headers();
-	if (overrideHeaderNames === null) {
-		for (const [key, value] of forwardedHeaders) nextHeaders.set(key, value);
+	const unconsumedHeaders = getUnconsumedMiddlewareRequestHeaders(middlewareHeaders);
+	const rawOverrideHeader = getMiddlewareHeaderValue(middlewareHeaders, MIDDLEWARE_OVERRIDE_HEADERS);
+	if (!rawOverrideHeader) {
+		if (unconsumedHeaders.size === 0) return null;
+		const nextHeaders = new Headers(baseHeaders);
+		for (const [key, value] of unconsumedHeaders) nextHeaders.set(key, value);
 		return nextHeaders;
 	}
-	if (options.preserveCredentialHeaders) {
-		const overrideHeaderNameSet = new Set(overrideHeaderNames);
-		for (const key of CREDENTIAL_REQUEST_HEADERS) {
-			if (overrideHeaderNameSet.has(key)) continue;
-			const value = baseHeaders.get(key);
-			if (value !== null) nextHeaders.set(key, value);
-		}
-	}
+	const overrideHeaderNames = parseOverrideHeaderNames(rawOverrideHeader);
+	const nextHeaders = new Headers();
 	for (const key of overrideHeaderNames) {
 		const value = forwardedHeaders.get(key);
 		if (value !== void 0) nextHeaders.set(key, value);
 	}
+	for (const [key, value] of unconsumedHeaders) nextHeaders.set(key, value);
 	return nextHeaders;
 }
 function shouldKeepMiddlewareHeader(key) {
 	return key === "x-middleware-override-headers" || key === "x-middleware-cache" || key === "x-middleware-set-cookie" || key.startsWith("x-middleware-request-");
 }
 //#endregion
-export { buildRequestHeadersFromMiddlewareResponse, encodeMiddlewareRequestHeaders, shouldKeepMiddlewareHeader };
+export { buildRequestHeadersFromMiddlewareResponse, encodeMiddlewareRequestHeaders, getUnconsumedMiddlewareRequestHeaders, shouldKeepMiddlewareHeader };

package/dist/utils/precompressed-variant.d.ts

@@ -0,0 +1,9 @@
+//#region src/utils/precompressed-variant.d.ts
+type PrecompressedEncoding = "br" | "gzip" | "zstd";
+/**
+ * Return whether an encoded representation reduces conservative HTTP/1 wire
+ * bytes after accounting for the response fields needed to negotiate it.
+ */
+declare function isPrecompressedVariantBeneficial(compressedSize: number, originalSize: number, encoding: PrecompressedEncoding): boolean;
+//#endregion
+export { PrecompressedEncoding, isPrecompressedVariantBeneficial };

package/dist/utils/precompressed-variant.js

@@ -0,0 +1,15 @@
+//#region src/utils/precompressed-variant.ts
+const RESPONSE_HEADER_OVERHEAD = {
+	br: 45,
+	gzip: 47,
+	zstd: 47
+};
+/**
+* Return whether an encoded representation reduces conservative HTTP/1 wire
+* bytes after accounting for the response fields needed to negotiate it.
+*/
+function isPrecompressedVariantBeneficial(compressedSize, originalSize, encoding) {
+	return originalSize - compressedSize > RESPONSE_HEADER_OVERHEAD[encoding];
+}
+//#endregion
+export { isPrecompressedVariantBeneficial };

package/dist/utils/project.d.ts

@@ -79,11 +79,16 @@ type ProjectInfo = {
   hasCloudflarePlugin: boolean;
   hasRscPlugin: boolean;
   hasWrangler: boolean;
-  projectName: string; /** Pages that use `revalidate` (ISR) */
-  hasISR: boolean; /** package.json has "type": "module" */
-  hasTypeModule: boolean; /** .mdx files detected in app/ or pages/ */
-  hasMDX: boolean; /** CodeHike is a dependency */
-  hasCodeHike: boolean; /** Native Node modules that need stubbing for Workers */
+  projectName: string;
+  /** Pages that use `revalidate` (ISR) */
+  hasISR: boolean;
+  /** package.json has "type": "module" */
+  hasTypeModule: boolean;
+  /** .mdx files detected in app/ or pages/ */
+  hasMDX: boolean;
+  /** CodeHike is a dependency */
+  hasCodeHike: boolean;
+  /** Native Node modules that need stubbing for Workers */
   nativeModulesToStub: string[];
 };
 /** Check whether a wrangler config file exists in the given directory. */
@@ -103,8 +108,8 @@ type MissingDep = {
  * module resolution. Handles hoisting, pnpm symlinks, monorepos, and Yarn PnP.
  */
 declare function isPackageResolvable(root: string, packageName: string): boolean;
-declare function getMissingDeps(info: ProjectInfo, /** Override for testing — defaults to `isPackageResolvable` */
-
+declare function getMissingDeps(info: ProjectInfo,
+/** Override for testing — defaults to `isPackageResolvable` */
 _isResolvable?: (root: string, pkg: string) => boolean): MissingDep[];
 /**
  * Return the first candidate directory (resolved against `root`) that exists,

package/dist/utils/public-file-path.d.ts

@@ -0,0 +1,5 @@
+//#region src/utils/public-file-path.d.ts
+/** Precompute keys for both encoded requests and decoded proxy/dev variants. */
+declare function publicFilePathVariants(pathname: string): string[];
+//#endregion
+export { publicFilePathVariants };

package/dist/utils/public-file-path.js

@@ -0,0 +1,12 @@
+//#region src/utils/public-file-path.ts
+/** Encode each pathname segment without encoding `/` separators. */
+function encodePublicFilePath(pathname) {
+	return pathname.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+}
+/** Precompute keys for both encoded requests and decoded proxy/dev variants. */
+function publicFilePathVariants(pathname) {
+	const encoded = encodePublicFilePath(pathname);
+	return encoded === pathname ? [pathname] : [pathname, encoded];
+}
+//#endregion
+export { publicFilePathVariants };

package/dist/utils/public-routes.d.ts

@@ -1,4 +1,4 @@
 //#region src/utils/public-routes.d.ts
-declare function scanPublicFileRoutes(root: string): string[];
+declare function scanPublicFileRoutes(root: string, configuredPublicDir?: string | false): string[];
 //#endregion
 export { scanPublicFileRoutes };

package/dist/utils/public-routes.js

@@ -1,8 +1,10 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { publicFilePathVariants } from "./public-file-path.js";
 import fs from "node:fs";
 //#region src/utils/public-routes.ts
-function scanPublicFileRoutes(root) {
-	const publicDir = path.join(root, "public");
+function scanPublicFileRoutes(root, configuredPublicDir = "public") {
+	if (configuredPublicDir === false || configuredPublicDir === "") return [];
+	const publicDir = path.resolve(root, configuredPublicDir);
 	const routes = [];
 	const visitedDirs = /* @__PURE__ */ new Set();
 	function walk(dir) {
@@ -35,14 +37,13 @@ function scanPublicFileRoutes(root) {
 				if (!stat.isFile()) continue;
 			} else if (!entry.isFile()) continue;
 			const relativePath = path.relative(publicDir, fullPath);
-			routes.push("/" + relativePath);
+			routes.push(...publicFilePathVariants("/" + relativePath));
 		}
 	}
 	if (fs.existsSync(publicDir)) try {
 		walk(publicDir);
 	} catch {}
-	routes.sort();
-	return routes;
+	return [...new Set(routes)].sort();
 }
 //#endregion
 export { scanPublicFileRoutes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vinext",
-  "version": "1.0.0-beta.3",
+  "version": "1.0.0-beta.5",
   "description": "Run Next.js apps on Vite. Drop-in replacement for the next CLI.",
   "license": "MIT",
   "repository": {
@@ -21,6 +21,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "import": "./dist/client/index.js"
+    },
     "./cache": {
       "types": "./dist/cache.d.ts",
       "import": "./dist/cache.js"
@@ -183,8 +187,8 @@
     "am-i-vibing": "^0.5.0",
     "pathslash": "^0.1.0",
     "react-server-dom-webpack": "^19.2.7",
-    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.2",
-    "vite-plus": "0.2.2"
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.6",
+    "vite-plus": "0.2.6"
   },
   "peerDependencies": {
     "@mdx-js/rollup": "^3.0.0",