vinext 1.0.0 → 1.0.1

package/dist/shims/internal/cache-context-accessor.js

@@ -0,0 +1,15 @@
+//#region src/shims/internal/cache-context-accessor.ts
+let getCacheContext = null;
+function _registerCacheContextAccessor(fn) {
+	getCacheContext = fn;
+}
+function getRegisteredCacheContext() {
+	return getCacheContext?.() ?? null;
+}
+/** Record a root-param dependency on the active public `"use cache"` scope. */
+function _recordUseCacheRootParamRead(name) {
+	const context = getRegisteredCacheContext();
+	if (context && context.variant !== "private") context.readRootParamNames?.add(name);
+}
+//#endregion
+export { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext };

package/dist/shims/internal/headers-state.d.ts

@@ -0,0 +1,74 @@
+import { RenderRequestApiKind } from "../../server/cache-proof.js";
+import { HeadersContext } from "../headers.js";
+//#region src/shims/internal/headers-state.d.ts
+export type HeadersAccessPhase = "render" | "action" | "route-handler";
+/**
+ * Whether the current render has used a dynamic API. Unlike
+ * `dynamicUsageDetected`, nothing clears it, and one object is shared by every
+ * child scope of the request, so usage inside isolated scopes (such as the
+ * layout probe) stays visible to later readers.
+ */
+export type RenderDynamicLatch = {
+  dynamic: boolean;
+  listeners: Set<() => void>;
+};
+export declare function createRenderDynamicLatch(): RenderDynamicLatch;
+export type VinextHeadersShimState = {
+  headersContext: HeadersContext | null;
+  dynamicUsageDetected: boolean;
+  renderDynamicLatch: RenderDynamicLatch;
+  renderRequestApiUsage: Set<RenderRequestApiKind>;
+  connectionProbe: ConnectionProbeState | null;
+  /** Error recorded by throwIfInsideCacheScope for dev diagnostics, persists even if caught by user code. */
+  invalidDynamicUsageError: unknown;
+  pendingSetCookies: string[];
+  draftModeCookieHeader: string | null;
+  phase: HeadersAccessPhase;
+};
+export type ConnectionProbeState = {
+  active: boolean;
+  dynamicUsageTarget: VinextHeadersShimState;
+  interrupted: boolean;
+  interrupt: () => void;
+  pending: Promise<never>;
+};
+export type ConnectionProbeResult<T> = {
+  completed: true;
+  result: T;
+} | {
+  completed: false;
+};
+export declare const headersShimAls: import("node:async_hooks").AsyncLocalStorage<VinextHeadersShimState>;
+export declare function getHeadersShimState(): VinextHeadersShimState;
+/**
+ * Dynamic usage flag — set when a component calls connection(), cookies(),
+ * headers(), or noStore() during rendering. When true, ISR caching is
+ * bypassed and the response gets Cache-Control: no-store.
+ */
+/**
+ * Mark the current render as requiring dynamic (uncached) rendering.
+ * Called by connection(), cookies(), headers(), and noStore().
+ */
+export declare function markDynamicUsage(): void;
+/** Whether the current render has used a dynamic API at any point so far. */
+export declare function isRenderDynamicLatched(): boolean;
+/**
+ * Call `listener` once when the current render first uses a dynamic API.
+ * Returns an unsubscribe function. The listener never runs if the render is
+ * already latched; check `isRenderDynamicLatched()` first.
+ */
+export declare function onRenderDynamicLatched(listener: () => void): () => void;
+export declare function markRenderRequestApiUsage(kind: RenderRequestApiKind): void;
+export declare function throwIfStaticGenerationAccessError(): void;
+/** Whether work is executing inside a cache boundary that owns its reuse. */
+export declare function isInsideAnyCacheScope(): boolean;
+/**
+ * Throw if the current execution is inside a "use cache" or unstable_cache()
+ * scope. Called by dynamic request APIs (headers, cookies, connection) to
+ * prevent request-specific data from being frozen into cached results.
+ *
+ * @param apiName - The name of the API being called (e.g. "connection()")
+ */
+export declare function throwIfInsideCacheScope(apiName: string): void;
+export declare function getHeadersAccessPhase(): HeadersAccessPhase;
+//#endregion

package/dist/shims/internal/headers-state.js

@@ -0,0 +1,157 @@
+import { getOrCreateAls } from "./als-registry.js";
+import { ensureRenderDynamicLatch, getRequestContext, isInsideUnifiedScope } from "../unified-request-context.js";
+//#region src/shims/internal/headers-state.ts
+function createRenderDynamicLatch() {
+	return {
+		dynamic: false,
+		listeners: /* @__PURE__ */ new Set()
+	};
+}
+const _FALLBACK_KEY = Symbol.for("vinext.nextHeadersShim.fallback");
+const _g = globalThis;
+const headersShimAls = getOrCreateAls("vinext.nextHeadersShim.als");
+const _fallbackState = _g[_FALLBACK_KEY] ??= {
+	headersContext: null,
+	dynamicUsageDetected: false,
+	renderDynamicLatch: createRenderDynamicLatch(),
+	renderRequestApiUsage: /* @__PURE__ */ new Set(),
+	connectionProbe: null,
+	invalidDynamicUsageError: null,
+	pendingSetCookies: [],
+	draftModeCookieHeader: null,
+	phase: "render"
+};
+function getHeadersShimState() {
+	if (isInsideUnifiedScope()) return getRequestContext();
+	return headersShimAls.getStore() ?? _fallbackState;
+}
+/**
+* Dynamic usage flag — set when a component calls connection(), cookies(),
+* headers(), or noStore() during rendering. When true, ISR caching is
+* bypassed and the response gets Cache-Control: no-store.
+*/
+/**
+* Mark the current render as requiring dynamic (uncached) rendering.
+* Called by connection(), cookies(), headers(), and noStore().
+*/
+function markDynamicUsage() {
+	const state = getHeadersShimState();
+	if (state.headersContext?.forceStatic) return;
+	state.dynamicUsageDetected = true;
+	const latches = [ensureRenderDynamicLatch(state)];
+	forEachConnectionProbeTarget(state, (target) => {
+		target.dynamicUsageDetected = true;
+		latches.push(ensureRenderDynamicLatch(target));
+	});
+	for (const latch of latches) latchRenderDynamic(latch);
+}
+function latchRenderDynamic(latch) {
+	if (latch.dynamic) return;
+	latch.dynamic = true;
+	const listeners = [...latch.listeners];
+	latch.listeners.clear();
+	for (const listener of listeners) try {
+		listener();
+	} catch (error) {
+		console.error(error);
+	}
+}
+/** Whether the current render has used a dynamic API at any point so far. */
+function isRenderDynamicLatched() {
+	return ensureRenderDynamicLatch(getHeadersShimState()).dynamic;
+}
+/**
+* Call `listener` once when the current render first uses a dynamic API.
+* Returns an unsubscribe function. The listener never runs if the render is
+* already latched; check `isRenderDynamicLatched()` first.
+*/
+function onRenderDynamicLatched(listener) {
+	const latch = ensureRenderDynamicLatch(getHeadersShimState());
+	if (latch.dynamic) return () => {};
+	latch.listeners.add(listener);
+	return () => {
+		latch.listeners.delete(listener);
+	};
+}
+function forEachConnectionProbeTarget(state, visit) {
+	let target = state.connectionProbe?.dynamicUsageTarget ?? null;
+	const seen = /* @__PURE__ */ new Set([state]);
+	while (target && !seen.has(target)) {
+		seen.add(target);
+		visit(target);
+		target = target.connectionProbe?.dynamicUsageTarget ?? null;
+	}
+}
+function propagateInvalidDynamicUsageError(state, error) {
+	forEachConnectionProbeTarget(state, (target) => {
+		if (target.invalidDynamicUsageError == null) target.invalidDynamicUsageError = error;
+	});
+}
+function markRenderRequestApiUsage(kind) {
+	getHeadersShimState().renderRequestApiUsage.add(kind);
+}
+function throwIfStaticGenerationAccessError() {
+	const accessError = getHeadersShimState().headersContext?.accessError;
+	if (accessError) throw accessError;
+}
+/** Symbol used by cache-runtime.ts to store the "use cache" ALS on globalThis */
+const _USE_CACHE_ALS_KEY = Symbol.for("vinext.cacheRuntime.contextAls");
+/** Symbol used by cache.ts to store the unstable_cache ALS on globalThis */
+const _UNSTABLE_CACHE_ALS_KEY = Symbol.for("vinext.unstableCache.als");
+function _getGlobalCacheScopeStore(key) {
+	const value = Reflect.get(globalThis, key);
+	if (!value || typeof value !== "object") return null;
+	const getStore = Reflect.get(value, "getStore");
+	if (typeof getStore !== "function") return null;
+	return getStore.call(value);
+}
+function _getUseCacheGuardContext() {
+	const store = _getGlobalCacheScopeStore(_USE_CACHE_ALS_KEY);
+	if (!store || typeof store !== "object") return null;
+	return store;
+}
+function _isInsidePublicUseCache() {
+	const ctx = _getUseCacheGuardContext();
+	return ctx !== null && ctx.variant !== "private";
+}
+function _isInsideUnstableCache() {
+	return _getGlobalCacheScopeStore(_UNSTABLE_CACHE_ALS_KEY) === true;
+}
+/** Whether work is executing inside a cache boundary that owns its reuse. */
+function isInsideAnyCacheScope() {
+	return _getUseCacheGuardContext() !== null || _isInsideUnstableCache();
+}
+/**
+* Throw if the current execution is inside a "use cache" or unstable_cache()
+* scope. Called by dynamic request APIs (headers, cookies, connection) to
+* prevent request-specific data from being frozen into cached results.
+*
+* @param apiName - The name of the API being called (e.g. "connection()")
+*/
+function throwIfInsideCacheScope(apiName) {
+	if (_isInsidePublicUseCache()) {
+		const error = /* @__PURE__ */ new Error(`\`${apiName}\` cannot be called inside "use cache". If you need this data inside a cached function, call \`${apiName}\` outside and pass the required data as an argument.`);
+		try {
+			const cacheCtx = _getUseCacheGuardContext();
+			if (cacheCtx) cacheCtx.invalidDynamicUsageError = error;
+			const ctx = getRequestContext();
+			if (ctx) ctx.invalidDynamicUsageError = error;
+			propagateInvalidDynamicUsageError(getHeadersShimState(), error);
+		} catch {}
+		throw error;
+	}
+	if (_isInsideUnstableCache()) {
+		const error = /* @__PURE__ */ new Error(`\`${apiName}\` cannot be called inside a function cached with \`unstable_cache()\`. If you need this data inside a cached function, call \`${apiName}\` outside and pass the required data as an argument.`);
+		try {
+			const ctx = getRequestContext();
+			if (ctx) ctx.invalidDynamicUsageError = error;
+			propagateInvalidDynamicUsageError(getHeadersShimState(), error);
+		} catch {}
+		throw error;
+	}
+}
+function getHeadersAccessPhase() {
+	return getHeadersShimState().phase;
+}
+//#endregion
+export { createRenderDynamicLatch, getHeadersAccessPhase, getHeadersShimState, headersShimAls, isInsideAnyCacheScope, isRenderDynamicLatched, markDynamicUsage, markRenderRequestApiUsage, onRenderDynamicLatched, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };

package/dist/shims/navigation.js

@@ -17,12 +17,12 @@ import { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE,
 import { clearAppNavigationFailureTarget, stageAppNavigationFailureTarget } from "../client/app-nav-failure-handler.js";
 import { beginAppRouterScrollIntent, clearAppRouterScrollIntent, consumeAppRouterScrollIntent, getPendingAppRouterScrollIntent, isLatestAppRouterScrollIntent } from "./app-router-scroll-state.js";
 import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createRscRequestHeaders, createRscRequestUrl, stripRscCacheBustingSearchParam, stripRscSuffix } from "../server/app-rsc-cache-busting.js";
-import { getNavigationRuntime, hasAppNavigationRuntime } from "../client/navigation-runtime.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
+import { getNavigationRuntime, hasAppNavigationRuntime } from "../client/navigation-runtime.js";
 import { UnrecognizedActionError, unstable_isUnrecognizedActionError } from "./unrecognized-action-error.js";
 import { PUBLIC_INITIAL_BFCACHE_ID } from "../server/app-bfcache-id.js";
-import { createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, isAppOwnedHistoryState } from "../server/app-history-state.js";
 import { resolveManifestNavigationInterceptionContext } from "../server/app-browser-interception-context.js";
+import { createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, isAppOwnedHistoryState } from "../server/app-history-state.js";
 import { hasPendingAppRouterPageRedirect } from "../server/app-browser-mpa-navigation.js";
 import { extractRscCompletionMetadata } from "../server/rsc-completion-metadata.js";
 import { navigationPlanner } from "../server/navigation-planner.js";

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

@@ -4,7 +4,8 @@ import "./navigation.js";
 import { CacheLifeConfig, CacheState } from "./cache-request-state.js";
 import { RootParamsState } from "./root-params.js";
 import { FetchCacheState } from "./fetch-cache.js";
-import { HeadersAccessPhase, HeadersContext, VinextHeadersShimState } from "./headers.js";
+import { HeadersAccessPhase, VinextHeadersShimState } from "./internal/headers-state.js";
+import { HeadersContext } from "./headers.js";
 import { RouterState, SSRContext } from "./router-state.js";
 import { PrivateCacheState } from "./cache-runtime.js";
 import { HeadState } from "./head-state.js";

package/dist/shims/root-params.js

@@ -1,6 +1,6 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
 import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
-import { _recordUseCacheRootParamRead } from "./cache-request-state.js";
+import { _recordUseCacheRootParamRead } from "./internal/cache-context-accessor.js";
 //#region src/shims/root-params.ts
 function createRootParamsUsageError(message) {
 	return new Error(message);

package/dist/shims/server.js

@@ -48,15 +48,65 @@ function _throwIfInsideCacheScope(apiName) {
 		throw error;
 	}
 }
+/**
+* Workers can hand a GET/HEAD a non-null body (e.g. a GET sent with
+* Content-Length). Next.js nulls GET/HEAD bodies before user code runs, so a
+* NextRequest never carries one either.
+*/
+function hasGetOrHeadBody(request) {
+	return (request.method === "GET" || request.method === "HEAD") && request.body !== null;
+}
+/**
+* The Request constructor rejects such a body when it reads a Request init as
+* a dictionary, as it does for the route handler's tracking Proxy, so rebuild
+* the init without it. Every other standard field, plus workerd's `cf` and
+* `fetcher`, is copied so a framed GET builds the same Request as an unframed
+* one. (`duplex` only applies to a body.)
+*/
+function requestInitFromRequest(request) {
+	if (!hasGetOrHeadBody(request)) return request;
+	const cf = Reflect.get(request, "cf");
+	const fetcher = Reflect.get(request, "fetcher");
+	return {
+		method: request.method,
+		headers: request.headers,
+		body: null,
+		cache: request.cache,
+		credentials: request.credentials,
+		integrity: request.integrity,
+		keepalive: request.keepalive,
+		mode: request.mode,
+		redirect: request.redirect,
+		referrer: request.referrer,
+		referrerPolicy: request.referrerPolicy,
+		signal: request.signal,
+		...cf !== void 0 ? { cf } : {},
+		...fetcher !== void 0 ? { fetcher } : {}
+	};
+}
+/**
+* A Request input passes its body on unless the init replaces it, so drop a
+* GET/HEAD input's body when the init keeps the input's method and body. This
+* covers the requests vinext hands to middleware, route handlers and edge API
+* routes.
+*/
+function initWithoutInputBody(input, init) {
+	if (init instanceof Request || init.method !== void 0 || init.body !== void 0 || !hasGetOrHeadBody(input)) return init;
+	return {
+		...init,
+		body: null
+	};
+}
 var NextRequest = class extends Request {
 	_nextUrl;
 	_url;
 	_cookies;
 	constructor(input, init) {
 		validateURL(typeof input !== "string" && "url" in input ? input.url : String(input));
-		const { nextConfig: _nextConfig, ...requestInit } = init ?? {};
+		const { nextConfig: _nextConfig, ...plainInit } = init ?? {};
+		const requestInit = init instanceof Request ? requestInitFromRequest(init) : plainInit;
 		if (input instanceof Request) {
-			super(input, requestInit);
+			super(input, initWithoutInputBody(input, requestInit));
 			const cfDescriptor = Reflect.getOwnPropertyDescriptor(input, "cf");
 			if (cfDescriptor) Object.defineProperty(this, "cf", cfDescriptor);
 			else {

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

@@ -2,7 +2,7 @@ import { ExecutionContextLike } from "./request-context.js";
 import { CacheState } from "./cache-request-state.js";
 import { RootParamsState } from "./root-params.js";
 import { FetchCacheState } from "./fetch-cache.js";
-import { VinextHeadersShimState } from "./headers.js";
+import { VinextHeadersShimState } from "./internal/headers-state.js";
 import { RouterState } from "./router-state.js";
 import { markFullyBufferedBody, preserveFullyBufferedBodyMetadata } from "../server/fully-buffered-response.js";
 import { PrivateCacheState } from "./cache-runtime.js";

package/dist/utils/encode-cache-tag.d.ts

@@ -25,5 +25,6 @@
  * (introduced in vercel/next.js#93601).
  */
 export declare function encodeCacheTag(tag: string): string;
+/** Validate raw public tag types and lengths before header encoding. */
 export declare function encodeCacheTags(tags: readonly string[]): string[];
 //#endregion

package/dist/utils/encode-cache-tag.js

@@ -26,11 +26,21 @@
 */
 const OUT_OF_CLASS_CHAR = /[^\t\x20-\x7e]/;
 const OUT_OF_CLASS_RUN = /[^\t\x20-\x7e]+/g;
+const MAX_TAG_LENGTH = 256;
 function encodeCacheTag(tag) {
 	return OUT_OF_CLASS_CHAR.test(tag) ? tag.replace(OUT_OF_CLASS_RUN, (run) => encodeURIComponent(run)) : tag;
 }
+/** Validate raw public tag types and lengths before header encoding. */
 function encodeCacheTags(tags) {
-	return tags.map(encodeCacheTag);
+	const encoded = [];
+	for (const tag of tags) {
+		if (typeof tag !== "string" || tag.length > MAX_TAG_LENGTH) {
+			console.warn(`[vinext] Cache tags must be strings of at most ${MAX_TAG_LENGTH} characters; invalid tag ignored.`);
+			continue;
+		}
+		encoded.push(encodeCacheTag(tag));
+	}
+	return encoded;
 }
 //#endregion
 export { encodeCacheTag, encodeCacheTags };

package/dist/utils/vite-cli-invocation.js

@@ -1,5 +1,6 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { findViteConfigPath } from "./project.js";
+import fs from "node:fs";
 //#region src/utils/vite-cli-invocation.ts
 let buildClaimed = false;
 const valued = new Set("--config -c --mode -m --logLevel -l --filter -f --configLoader --port --outDir --target --assetsDir --assetsInlineLimit".split(" "));
@@ -72,9 +73,15 @@ function findViteRoot(command, args) {
 		shouldPreflight: preflight
 	};
 }
+function isViteEntry(entry) {
+	return entry.endsWith("/vite/bin/vite.js") || entry.endsWith("/vite/node/cli.js") || entry.endsWith("/dist/vite/node/cli.js");
+}
 function commandArguments(argv) {
 	const entry = toSlash(argv[1] ?? "");
-	const vite = entry.endsWith("/vite/bin/vite.js") || entry.endsWith("/vite/node/cli.js") || entry.endsWith("/dist/vite/node/cli.js");
+	let vite = isViteEntry(entry);
+	if (!vite && entry && path.basename(entry) !== "vp") try {
+		vite = isViteEntry(toSlash(fs.realpathSync.native(entry)));
+	} catch {}
 	let args = argv.slice(2);
 	if (!vite) {
 		if (path.basename(entry) !== "vp") return void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vinext",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Run Next.js apps on Vite. Drop-in replacement for the next CLI.",
   "homepage": "https://vinext.dev/",
   "license": "MIT",
@@ -90,6 +90,10 @@
       "types": "./dist/server/pages-router-entry.d.ts",
       "import": "./dist/server/pages-router-entry.js"
     },
+    "./internal/client/vinext-next-data": {
+      "types": "./dist/client/vinext-next-data.d.ts",
+      "import": "./dist/client/vinext-next-data.js"
+    },
     "./internal/server/headers": {
       "types": "./dist/server/headers.d.ts",
       "import": "./dist/server/headers.js"
@@ -222,7 +226,7 @@
     "magic-string": "^0.30.21",
     "vite-plugin-commonjs": "^0.10.4",
     "web-vitals": "^4.2.4",
-    "@vinext/types": "^1.0.0"
+    "@vinext/types": "^1.0.1"
   },
   "devDependencies": {
     "@types/node": "^25.9.2",

package/dist/server/metadata-route-cache-policy.d.ts

@@ -1,5 +0,0 @@
-//#region src/server/metadata-route-cache-policy.d.ts
-export declare function isMetadataResponseCacheable(response: {
-  headers: Headers;
-}): boolean;
-//#endregion

package/dist/server/metadata-route-cache-policy.js

@@ -1,6 +0,0 @@
-//#region src/server/metadata-route-cache-policy.ts
-function isMetadataResponseCacheable(response) {
-	return !(response.headers.get("cache-control")?.toLowerCase() ?? "").split(",").map((directive) => directive.trim().split("=", 1)[0]).some((directive) => directive === "no-cache" || directive === "no-store");
-}
-//#endregion
-export { isMetadataResponseCacheable };