vinext 1.4.0 → 1.4.1

package/dist/shims/request-state-types.d.ts

@@ -1,3 +1,4 @@
+import { CacheLifeConfig } from "../utils/cache-life-profiles.js";
 import { NavigationContext } from "./navigation-context-state.js";
 import "./navigation.js";
 import { ExecutionContextLike } from "./request-context.js";
@@ -6,7 +7,7 @@ import { FetchCacheState } from "./fetch-cache-state.js";
 import "./fetch-cache.js";
 import { HeadersAccessPhase, VinextHeadersShimState } from "./internal/headers-state.js";
 import { HeadersContext } from "./headers.js";
-import { CacheLifeConfig, CacheState } from "./cache-request-state.js";
+import { CacheState } from "./cache-request-state.js";
 import { RouterState, SSRContext } from "./router-state.js";
 import { PrivateCacheState } from "./cache-runtime.js";
 import { HeadState } from "./head-state.js";

package/dist/shims/slot.d.ts

@@ -40,6 +40,7 @@ type MergeElementsOptions = {
   clearAbsentSlots?: boolean;
   preserveAbsentSlots?: boolean;
   preserveElementIds?: readonly string[];
+  preserveElementSeedIds?: readonly string[];
   preservePreviousSlotIds?: readonly string[];
 };
 export declare function updateBfcacheSlotEntryOrder(previousOrder: readonly string[], activeStateKey: string, maxEntries?: number): string[];
@@ -67,9 +68,12 @@ export declare function BfcacheSegmentBoundary({ children, id, stateKey }: {
  * the parent's layout router, above the child's boundaries, so a page left for a
  * sibling with its own layout keeps its state when navigating back.
  */
-export declare function BfcacheChildrenBoundary({ children, id }: {
+export declare function BfcacheChildrenBoundary({ children, id, stateKey }: {
   children: React$1.ReactNode;
-  id: string;
+  /** The child element whose identity keys the entries. */
+  id?: string;
+  /** A fixed key, for a segment level with no element of its own. */
+  stateKey?: string;
 }): React$1.JSX.Element;
 export declare function getNonCacheComponentsSegmentKey(id: string, activeStateKey: string): string | undefined;
 export declare function resolveBfcacheSegmentStateKey(id: string, identityMap: Readonly<Record<string, string>>, bfcacheIdMap: Readonly<Record<string, string>> | null): string | undefined;

package/dist/shims/slot.js

@@ -213,21 +213,22 @@ function BfcacheSegmentBoundary({ children, id, stateKey }) {
 * the parent's layout router, above the child's boundaries, so a page left for a
 * sibling with its own layout keeps its state when navigating back.
 */
-function BfcacheChildrenBoundary({ children, id }) {
+function BfcacheChildrenBoundary({ children, id, stateKey }) {
 	if (!BfcacheIdMapContext || !BfcacheSegmentIdContext || !isCacheComponentsEnabled()) return /* @__PURE__ */ jsx(Fragment$1, { children });
 	return /* @__PURE__ */ jsx(BfcacheChildrenActivityBoundary, {
 		id,
 		IdMapContext: BfcacheIdMapContext,
 		SegmentContext: BfcacheSegmentIdContext,
+		stateKey,
 		children
 	});
 }
-function BfcacheChildrenActivityBoundary({ children, id, IdMapContext, SegmentContext }) {
+function BfcacheChildrenActivityBoundary({ children, id, IdMapContext, SegmentContext, stateKey }) {
 	const elements = React$1.useContext(ElementsContext);
 	const identityMap = React$1.useContext(BfcacheIdentityMapContext);
 	const bfcacheIdMap = React$1.useContext(IdMapContext);
 	const segmentId = React$1.useContext(SegmentContext);
-	const activeStateKey = resolveBfcacheSegmentStateKey(id, identityMap, bfcacheIdMap);
+	const activeStateKey = stateKey ?? (id === void 0 ? void 0 : resolveBfcacheSegmentStateKey(id, identityMap, bfcacheIdMap));
 	if (segmentId === null || activeStateKey === void 0) return /* @__PURE__ */ jsx(Fragment$1, { children });
 	return /* @__PURE__ */ jsx(BfcacheActivitySlotBoundary, {
 		activeStateKey,
@@ -272,6 +273,7 @@ function mergeElements(prev, next, options = {}) {
 	const clearAbsentSlots = typeof options === "boolean" ? options : options.clearAbsentSlots ?? false;
 	const preserveAbsentSlots = typeof options === "boolean" ? !options : options.preserveAbsentSlots ?? true;
 	const preserveElementIds = typeof options === "boolean" ? [] : options.preserveElementIds ?? [];
+	const preserveElementSeedIds = typeof options === "boolean" ? [] : options.preserveElementSeedIds ?? [];
 	const preservePreviousSlotIds = typeof options === "boolean" ? [] : options.preservePreviousSlotIds ?? [];
 	const merged = { ...next };
 	const preservedIdentityIds = /* @__PURE__ */ new Set();
@@ -282,6 +284,11 @@ function mergeElements(prev, next, options = {}) {
 			preservedIdentityIds.add(id);
 		}
 	}
+	for (const id of preserveElementSeedIds) {
+		if (preservedIdentityIds.has(id) || !Object.hasOwn(prev, id)) continue;
+		const value = prev[id];
+		if (value !== void 0) merged[id] = value;
+	}
 	const slotKeys = new Set([...Object.keys(prev), ...Object.keys(next)].filter((key) => AppElementsWire.isSlotId(key) && !isNestedBfcacheSlotSegmentId(key)));
 	if (clearAbsentSlots) {
 		for (const key of slotKeys) if (!Object.hasOwn(next, key)) delete merged[key];

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

@@ -30,6 +30,12 @@ export type UnifiedRequestContext = {
   requestCache: WeakMap<(...args: any[]) => any, unknown>;
   /** Shared lifecycle state for work deferred until the response closes. */
   afterContext: AfterRequestContext;
+  /**
+   * Draft-mode state of the headers context this request last cleared. The
+   * render can outlive its headers context (cleared once the response body
+   * closes), and so do after() callbacks; cache bypasses keep reading this.
+   */
+  draftModeAtHeadersClear: boolean;
 } & VinextHeadersShimState & I18nState & NavigationState & CacheState & PrivateCacheState & FetchCacheState & RouterState & HeadState & RootParamsState;
 export type AfterRequestContext = {
   callbacks: Array<() => unknown>;

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

@@ -53,6 +53,7 @@ function createRequestContext(opts) {
 		executionContext: _getInheritedExecutionContext(),
 		requestSignal: null,
 		requestCache: /* @__PURE__ */ new WeakMap(),
+		draftModeAtHeadersClear: false,
 		afterContext: {
 			callbacks: [],
 			responseClosed: false,

package/dist/utils/cache-life-profiles.d.ts

@@ -0,0 +1,33 @@
+//#region src/utils/cache-life-profiles.d.ts
+export type CacheLifeConfig = {
+  stale?: number;
+  revalidate?: number;
+  expire?: number;
+};
+/** Next.js's built-in profiles (`defaultConfig.cacheLife` in config-shared.ts). */
+export declare const BUILT_IN_CACHE_LIFE_PROFILES: Readonly<Record<string, Readonly<CacheLifeConfig>>>;
+/**
+ * Merge next.config `cacheLife` profiles over the built-ins, as Next.js does
+ * in `assignDefaultsAndValidate` (server/config.ts): a user profile replaces
+ * the built-in of the same name whole, and only `default` gets its missing
+ * fields filled: `stale` from `staleTimes.static`, `revalidate` from the
+ * built-in, `expire` from `expireTime`. That includes the built-in `default`,
+ * whose `stale` is unset in Next.js's defaults too. The other profiles keep
+ * their gaps, which the "use cache" store resolves from `default`.
+ *
+ * Next.js only schema-checks these profiles (fields must be numbers) and
+ * warns; `revalidate > expire` is checked for `cacheLife({...})` calls, not
+ * for config profiles.
+ */
+export declare function resolveCacheLifeProfiles(userProfiles: unknown, defaults: {
+  expireTime: number;
+  staticStaleTime: number;
+}, warn: (message: string) => void): Record<string, CacheLifeConfig>;
+/** Serialize resolved profiles for the `__VINEXT_CACHE_LIFE_PROFILES` define. */
+export declare function serializeCacheLifeProfiles(profiles: Record<string, CacheLifeConfig>): string;
+/**
+ * Read the `__VINEXT_CACHE_LIFE_PROFILES` define. When absent, the profiles a
+ * next.config without `cacheLife` resolves to.
+ */
+export declare function parseCacheLifeProfiles(serialized: string | undefined): Record<string, CacheLifeConfig>;
+//#endregion

package/dist/utils/cache-life-profiles.js

@@ -0,0 +1,111 @@
+import { isUnknownRecord } from "./record.js";
+//#region src/utils/cache-life-profiles.ts
+/** Next.js's built-in profiles (`defaultConfig.cacheLife` in config-shared.ts). */
+const BUILT_IN_CACHE_LIFE_PROFILES = {
+	default: {
+		revalidate: 900,
+		expire: 4294967294
+	},
+	seconds: {
+		stale: 30,
+		revalidate: 1,
+		expire: 60
+	},
+	minutes: {
+		stale: 300,
+		revalidate: 60,
+		expire: 3600
+	},
+	hours: {
+		stale: 300,
+		revalidate: 3600,
+		expire: 86400
+	},
+	days: {
+		stale: 300,
+		revalidate: 86400,
+		expire: 604800
+	},
+	weeks: {
+		stale: 300,
+		revalidate: 604800,
+		expire: 2592e3
+	},
+	max: {
+		stale: 300,
+		revalidate: 2592e3,
+		expire: 31536e3
+	}
+};
+const CACHE_LIFE_FIELDS = [
+	"stale",
+	"revalidate",
+	"expire"
+];
+function copyBuiltInProfiles() {
+	const profiles = {};
+	for (const [name, profile] of Object.entries(BUILT_IN_CACHE_LIFE_PROFILES)) profiles[name] = { ...profile };
+	return profiles;
+}
+/**
+* Merge next.config `cacheLife` profiles over the built-ins, as Next.js does
+* in `assignDefaultsAndValidate` (server/config.ts): a user profile replaces
+* the built-in of the same name whole, and only `default` gets its missing
+* fields filled: `stale` from `staleTimes.static`, `revalidate` from the
+* built-in, `expire` from `expireTime`. That includes the built-in `default`,
+* whose `stale` is unset in Next.js's defaults too. The other profiles keep
+* their gaps, which the "use cache" store resolves from `default`.
+*
+* Next.js only schema-checks these profiles (fields must be numbers) and
+* warns; `revalidate > expire` is checked for `cacheLife({...})` calls, not
+* for config profiles.
+*/
+function resolveCacheLifeProfiles(userProfiles, defaults, warn) {
+	const profiles = copyBuiltInProfiles();
+	for (const [name, rawProfile] of Object.entries(isUnknownRecord(userProfiles) ? userProfiles : {})) {
+		if (!isUnknownRecord(rawProfile)) {
+			warn(`[vinext] Invalid next.config option \`cacheLife.${name}\`: expected an object.`);
+			continue;
+		}
+		const profile = {};
+		for (const field of CACHE_LIFE_FIELDS) {
+			const value = rawProfile[field];
+			if (value === void 0) continue;
+			if (typeof value !== "number" || Number.isNaN(value)) {
+				warn(`[vinext] Invalid next.config option \`cacheLife.${name}.${field}\`: expected a number of seconds.`);
+				continue;
+			}
+			profile[field] = value;
+		}
+		profiles[name] = profile;
+	}
+	const defaultProfile = profiles.default;
+	defaultProfile.stale ??= defaults.staticStaleTime;
+	defaultProfile.revalidate ??= BUILT_IN_CACHE_LIFE_PROFILES.default.revalidate;
+	defaultProfile.expire ??= defaults.expireTime;
+	return profiles;
+}
+function encodeNonFiniteNumber(_key, value) {
+	return value === Infinity || value === -Infinity ? String(value) : value;
+}
+function decodeNonFiniteNumber(_key, value) {
+	return value === "Infinity" || value === "-Infinity" ? Number(value) : value;
+}
+/** Serialize resolved profiles for the `__VINEXT_CACHE_LIFE_PROFILES` define. */
+function serializeCacheLifeProfiles(profiles) {
+	return JSON.stringify(profiles, encodeNonFiniteNumber);
+}
+/**
+* Read the `__VINEXT_CACHE_LIFE_PROFILES` define. When absent, the profiles a
+* next.config without `cacheLife` resolves to.
+*/
+function parseCacheLifeProfiles(serialized) {
+	if (!serialized) {
+		const profiles = copyBuiltInProfiles();
+		profiles.default.stale = 300;
+		return profiles;
+	}
+	return JSON.parse(serialized, decodeNonFiniteNumber);
+}
+//#endregion
+export { BUILT_IN_CACHE_LIFE_PROFILES, parseCacheLifeProfiles, resolveCacheLifeProfiles, serializeCacheLifeProfiles };

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

@@ -7,7 +7,17 @@ type MiddlewareHeaderSource = Headers | Record<string, MiddlewareHeaderValue>;
  * under their literal protocol-header names on both the request and response.
  */
 export declare function getUnconsumedMiddlewareRequestHeaders(source: MiddlewareHeaderSource): Map<string, string>;
-/** Whether middleware changed the headers seen by downstream application code. */
+/**
+ * `baseHeaders` with only Next.js's generic merge of ordinary middleware
+ * response headers applied, without the request-header protocol.
+ */
+export declare function applyMiddlewareResponseHeadersToRequest(baseHeaders: Headers, middlewareHeaders: MiddlewareHeaderSource): Headers;
+/**
+ * Whether middleware changed the headers seen by downstream application code
+ * through its request-header protocol. Ordinary response headers are copied to
+ * the request as well, but like a client's own headers they do not opt a
+ * render out of the shared response stage.
+ */
 export declare function hasMiddlewareRequestHeaderOverrides(source: MiddlewareHeaderSource | null): boolean;
 export declare function encodeMiddlewareRequestHeaders(targetHeaders: Headers, requestHeaders: Headers): void;
 /**
@@ -16,8 +26,9 @@ export declare function encodeMiddlewareRequestHeaders(targetHeaders: Headers, r
  * 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.
+ * override. Any unconsumed `x-middleware-request-*` values and every other
+ * truthy middleware response header are subsequently copied to the request
+ * under their literal names, replacing values the client sent.
  */
 export declare function buildRequestHeadersFromMiddlewareResponse(baseHeaders: Headers, middlewareHeaders: MiddlewareHeaderSource): Headers | null;
 export declare function shouldKeepMiddlewareHeader(key: string): boolean;

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

@@ -34,7 +34,52 @@ function getUnconsumedMiddlewareRequestHeaders(source) {
 	for (const [key, value] of getForwardedRequestHeaders(source)) if (value && !overriddenHeaders?.has(key)) unconsumedHeaders.set(`${MIDDLEWARE_REQUEST_HEADER_PREFIX}${key}`, value);
 	return unconsumedHeaders;
 }
-/** Whether middleware changed the headers seen by downstream application code. */
+const UNMERGED_MIDDLEWARE_RESPONSE_HEADERS = /* @__PURE__ */ new Set([
+	"accept-encoding",
+	"connection",
+	"content-encoding",
+	"content-length",
+	"expect",
+	"keep-alive",
+	"keepalive",
+	"transfer-encoding"
+]);
+/**
+* Return the truthy ordinary middleware response headers. Next.js's generic
+* middleware-header merge writes each of them to the request too, so a value
+* middleware sets replaces one the client sent under the same name. The
+* `x-middleware-*` namespace carries vinext's middleware protocol and is
+* handled separately.
+*/
+function getMergedMiddlewareResponseHeaders(source) {
+	const mergedHeaders = new Headers();
+	const entries = source instanceof Headers ? source : Object.entries(source).flatMap(([key, value]) => Array.isArray(value) ? value.map((item) => [key, item]) : [[key, value]]);
+	for (const [key, value] of entries) {
+		const lowerKey = key.toLowerCase();
+		if (value && !lowerKey.startsWith("x-middleware-") && !UNMERGED_MIDDLEWARE_RESPONSE_HEADERS.has(lowerKey)) mergedHeaders.append(lowerKey, value);
+	}
+	return mergedHeaders;
+}
+function applyMergedMiddlewareHeaders(targetHeaders, unconsumedHeaders, mergedHeaders) {
+	for (const [key, value] of unconsumedHeaders) targetHeaders.set(key, value);
+	for (const key of new Set(mergedHeaders.keys())) targetHeaders.delete(key);
+	for (const [key, value] of mergedHeaders) targetHeaders.append(key, value);
+}
+/**
+* `baseHeaders` with only Next.js's generic merge of ordinary middleware
+* response headers applied, without the request-header protocol.
+*/
+function applyMiddlewareResponseHeadersToRequest(baseHeaders, middlewareHeaders) {
+	const nextHeaders = new Headers(baseHeaders);
+	applyMergedMiddlewareHeaders(nextHeaders, /* @__PURE__ */ new Map(), getMergedMiddlewareResponseHeaders(middlewareHeaders));
+	return nextHeaders;
+}
+/**
+* Whether middleware changed the headers seen by downstream application code
+* through its request-header protocol. Ordinary response headers are copied to
+* the request as well, but like a client's own headers they do not opt a
+* render out of the shared response stage.
+*/
 function hasMiddlewareRequestHeaderOverrides(source) {
 	if (!source) return false;
 	return Boolean(getMiddlewareHeaderValue(source, "x-middleware-override-headers")) || getUnconsumedMiddlewareRequestHeaders(source).size > 0;
@@ -50,17 +95,19 @@ function encodeMiddlewareRequestHeaders(targetHeaders, requestHeaders) {
 * 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.
+* override. Any unconsumed `x-middleware-request-*` values and every other
+* truthy middleware response header are subsequently copied to the request
+* under their literal names, replacing values the client sent.
 */
 function buildRequestHeadersFromMiddlewareResponse(baseHeaders, middlewareHeaders) {
 	const forwardedHeaders = getForwardedRequestHeaders(middlewareHeaders);
 	const unconsumedHeaders = getUnconsumedMiddlewareRequestHeaders(middlewareHeaders);
+	const mergedHeaders = getMergedMiddlewareResponseHeaders(middlewareHeaders);
 	const rawOverrideHeader = getMiddlewareHeaderValue(middlewareHeaders, MIDDLEWARE_OVERRIDE_HEADERS);
 	if (!rawOverrideHeader) {
-		if (unconsumedHeaders.size === 0) return null;
+		if (unconsumedHeaders.size === 0 && mergedHeaders.keys().next().done) return null;
 		const nextHeaders = new Headers(baseHeaders);
-		for (const [key, value] of unconsumedHeaders) nextHeaders.set(key, value);
+		applyMergedMiddlewareHeaders(nextHeaders, unconsumedHeaders, mergedHeaders);
 		return nextHeaders;
 	}
 	const overrideHeaderNames = parseOverrideHeaderNames(rawOverrideHeader);
@@ -69,11 +116,11 @@ function buildRequestHeadersFromMiddlewareResponse(baseHeaders, middlewareHeader
 		const value = forwardedHeaders.get(key);
 		if (value !== void 0) nextHeaders.set(key, value);
 	}
-	for (const [key, value] of unconsumedHeaders) nextHeaders.set(key, value);
+	applyMergedMiddlewareHeaders(nextHeaders, unconsumedHeaders, mergedHeaders);
 	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, getUnconsumedMiddlewareRequestHeaders, hasMiddlewareRequestHeaderOverrides, shouldKeepMiddlewareHeader };
+export { applyMiddlewareResponseHeadersToRequest, buildRequestHeadersFromMiddlewareResponse, encodeMiddlewareRequestHeaders, getUnconsumedMiddlewareRequestHeaders, hasMiddlewareRequestHeaderOverrides, shouldKeepMiddlewareHeader };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vinext",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "Run Next.js apps on Vite. Drop-in replacement for the next CLI.",
   "homepage": "https://vinext.dev/",
   "license": "MIT",