@qzsy/vinext 0.1.7

package/dist/shims/navigation.react-server.d.ts

@@ -0,0 +1,14 @@
+import { ReadonlyURLSearchParams } from "./readonly-url-search-params.js";
+import { GLOBAL_ACCESSORS_KEY, NavigationContext, SegmentMap, ServerInsertedHTMLContext, _registerStateAccessors, clearServerInsertedHTML, flushServerInsertedHTML, getLayoutSegmentContext, getNavigationContext, renderServerInsertedHTML, setNavigationContext } from "./navigation-context-state.js";
+import { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE, RedirectType, forbidden, getAccessFallbackHTTPStatus, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, unauthorized, unstable_rethrow } from "./navigation-errors.js";
+//#region src/shims/navigation.react-server.d.ts
+declare function usePathname(): never;
+declare function useSearchParams(): never;
+declare function useParams(): never;
+declare function useRouter(): never;
+declare function useSelectedLayoutSegment(): never;
+declare function useSelectedLayoutSegments(): never;
+declare function useServerInsertedHTML(): never;
+declare function unstable_isUnrecognizedActionError(): boolean;
+//#endregion
+export { BailoutToCSRError, DynamicServerError, GLOBAL_ACCESSORS_KEY, HTTP_ERROR_FALLBACK_ERROR_CODE, type NavigationContext, ReadonlyURLSearchParams, RedirectType, type SegmentMap, ServerInsertedHTMLContext, _registerStateAccessors, clearServerInsertedHTML, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getLayoutSegmentContext, getNavigationContext, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, renderServerInsertedHTML, setNavigationContext, unauthorized, unstable_isUnrecognizedActionError, unstable_rethrow, useParams, usePathname, useRouter, useSearchParams, useSelectedLayoutSegment, useSelectedLayoutSegments, useServerInsertedHTML };

package/dist/shims/navigation.react-server.js

@@ -0,0 +1,32 @@
+import { GLOBAL_ACCESSORS_KEY, ServerInsertedHTMLContext, _registerStateAccessors, clearServerInsertedHTML, flushServerInsertedHTML, getLayoutSegmentContext, getNavigationContext, renderServerInsertedHTML, setNavigationContext } from "./navigation-context-state.js";
+import { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE, RedirectType, forbidden, getAccessFallbackHTTPStatus, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, unauthorized, unstable_rethrow } from "./navigation-errors.js";
+import "./navigation-server.js";
+import { throwClientHookError } from "./client-hook-error.js";
+import { ReadonlyURLSearchParams } from "./readonly-url-search-params.js";
+//#region src/shims/navigation.react-server.ts
+function usePathname() {
+	throwClientHookError("usePathname()");
+}
+function useSearchParams() {
+	throwClientHookError("useSearchParams()");
+}
+function useParams() {
+	throwClientHookError("useParams()");
+}
+function useRouter() {
+	throwClientHookError("useRouter()");
+}
+function useSelectedLayoutSegment() {
+	throwClientHookError("useSelectedLayoutSegment()");
+}
+function useSelectedLayoutSegments() {
+	throwClientHookError("useSelectedLayoutSegments()");
+}
+function useServerInsertedHTML() {
+	throwClientHookError("useServerInsertedHTML()");
+}
+function unstable_isUnrecognizedActionError() {
+	throw new Error("`unstable_isUnrecognizedActionError` can only be used on the client.");
+}
+//#endregion
+export { BailoutToCSRError, DynamicServerError, GLOBAL_ACCESSORS_KEY, HTTP_ERROR_FALLBACK_ERROR_CODE, ReadonlyURLSearchParams, RedirectType, ServerInsertedHTMLContext, _registerStateAccessors, clearServerInsertedHTML, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getLayoutSegmentContext, getNavigationContext, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, renderServerInsertedHTML, setNavigationContext, unauthorized, unstable_isUnrecognizedActionError, unstable_rethrow, useParams, usePathname, useRouter, useSearchParams, useSelectedLayoutSegment, useSelectedLayoutSegments, useServerInsertedHTML };

package/dist/shims/offline.d.ts

@@ -0,0 +1,4 @@
+//#region src/shims/offline.d.ts
+declare function useOffline(): boolean;
+//#endregion
+export { useOffline };

package/dist/shims/offline.js

@@ -0,0 +1,15 @@
+"use client";
+//#region src/shims/offline.ts
+/**
+* next/offline shim
+*
+* Stub for the experimental `useOffline()` hook added in Next.js
+* (vercel/next.js#92012). Returns `false` (online) unconditionally.
+* Full offline retry behavior (navigation retry, prefetch pause/resume,
+* OfflineProvider) will be implemented once the feature stabilizes upstream.
+*/
+function useOffline() {
+	return false;
+}
+//#endregion
+export { useOffline };

package/dist/shims/og.d.ts

@@ -0,0 +1,17 @@
+import { ReactElement } from "react";
+import { ImageResponseOptions, ImageResponseOptions as ImageResponseOptions$1 } from "@vercel/og";
+
+//#region src/shims/og.d.ts
+/**
+ * next/og shim.
+ *
+ * The vinext:og-inline-fetch-assets Vite plugin patches @vercel/og's runtime
+ * asset fetches so this wrapper can delegate image generation while preserving
+ * Next.js's public ImageResponse headers and option merging semantics.
+ */
+declare class ImageResponse extends Response {
+  static displayName: string;
+  constructor(element: ReactElement, options?: ImageResponseOptions$1);
+}
+//#endregion
+export { ImageResponse, type ImageResponseOptions };

package/dist/shims/og.js

@@ -0,0 +1,48 @@
+//#region src/shims/og.tsx
+const CACHE_HEADERS = {
+	noCache: "no-cache, no-store",
+	revalidate: "public, max-age=0, must-revalidate"
+};
+/**
+* next/og shim.
+*
+* The vinext:og-inline-fetch-assets Vite plugin patches @vercel/og's runtime
+* asset fetches so this wrapper can delegate image generation while preserving
+* Next.js's public ImageResponse headers and option merging semantics.
+*/
+var ImageResponse = class extends Response {
+	static displayName = "ImageResponse";
+	constructor(element, options) {
+		const readable = new ReadableStream({ async start(controller) {
+			const { ImageResponse: VercelImageResponse } = await import("@vercel/og");
+			const imageResponse = new VercelImageResponse(element, options);
+			if (!imageResponse.body) {
+				controller.close();
+				return;
+			}
+			const reader = imageResponse.body.getReader();
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) {
+					controller.close();
+					return;
+				}
+				controller.enqueue(value);
+			}
+		} });
+		const headers = new Headers({
+			"content-type": "image/png",
+			"cache-control": process.env.NODE_ENV === "development" ? CACHE_HEADERS.noCache : CACHE_HEADERS.revalidate
+		});
+		if (options?.headers) new Headers(options.headers).forEach((value, key) => {
+			headers.set(key, value);
+		});
+		super(readable, {
+			headers,
+			status: options?.status,
+			statusText: options?.statusText
+		});
+	}
+};
+//#endregion
+export { ImageResponse };

package/dist/shims/pages-router-runtime.d.ts

@@ -0,0 +1,12 @@
+//#region src/shims/pages-router-runtime.d.ts
+type PagesRouterPopStateHandler = (event: PopStateEvent) => void;
+declare function setPagesRouterPopStateHandler(handler: PagesRouterPopStateHandler): void;
+/**
+ * Register the function that stamps Next.js-shaped state onto the initial
+ * document entry (called once at install time). Router.ts registers this so
+ * the runtime module stays free of router internals.
+ */
+declare function setStampInitialHistoryState(fn: () => void): void;
+declare function installPagesRouterRuntime(): void;
+//#endregion
+export { installPagesRouterRuntime, setPagesRouterPopStateHandler, setStampInitialHistoryState };

package/dist/shims/pages-router-runtime.js

@@ -0,0 +1,24 @@
+//#region src/shims/pages-router-runtime.ts
+let pagesRouterPopStateHandler;
+let stampInitialHistoryStateFn;
+let pagesRouterRuntimeInstalled = false;
+function setPagesRouterPopStateHandler(handler) {
+	pagesRouterPopStateHandler = handler;
+}
+/**
+* Register the function that stamps Next.js-shaped state onto the initial
+* document entry (called once at install time). Router.ts registers this so
+* the runtime module stays free of router internals.
+*/
+function setStampInitialHistoryState(fn) {
+	stampInitialHistoryStateFn = fn;
+}
+function installPagesRouterRuntime() {
+	if (typeof window === "undefined" || pagesRouterRuntimeInstalled) return;
+	if (!pagesRouterPopStateHandler) throw new Error("[vinext] Pages Router runtime installed before next/router was initialized");
+	pagesRouterRuntimeInstalled = true;
+	stampInitialHistoryStateFn?.();
+	window.addEventListener("popstate", pagesRouterPopStateHandler);
+}
+//#endregion
+export { installPagesRouterRuntime, setPagesRouterPopStateHandler, setStampInitialHistoryState };

package/dist/shims/ppr-fallback-shell.d.ts

@@ -0,0 +1,33 @@
+//#region src/shims/ppr-fallback-shell.d.ts
+type PprFallbackShellState = {
+  abortController: AbortController;
+  reactAbortController: AbortController;
+  cacheEpoch: number;
+  cacheReadyResolvers: Array<() => void>;
+  fallbackParamNames: ReadonlySet<string>;
+  hasDynamicBoundary: boolean;
+  isFinalRenderStarted: boolean;
+  isAbortScheduled: boolean;
+  pendingAbortCleanup: (() => void) | null;
+  pendingCacheReadyCleanup: (() => void) | null;
+  pendingCacheTasks: number;
+  phase: "warmup" | "final";
+  routePattern: string;
+};
+type CreatePprFallbackShellStateOptions = {
+  fallbackParamNames: readonly string[];
+  routePattern: string;
+};
+declare function createPprFallbackShellState(options: CreatePprFallbackShellStateOptions): PprFallbackShellState;
+declare function runWithPprFallbackShellState<T>(state: PprFallbackShellState, fn: () => T): T;
+declare function getPprFallbackShellState(): PprFallbackShellState | null;
+declare function trackPprFallbackShellCacheTask<T>(fn: () => Promise<T>, cacheVariant: string): Promise<T>;
+declare function createPprFallbackShellSuspensePromiseForState<T>(state: PprFallbackShellState, expression: string): Promise<T>;
+declare function markPprFallbackShellDynamicBoundary(): void;
+declare function createPprFallbackShellSuspensePromise<T>(expression: string): Promise<T> | null;
+declare function waitForPprFallbackShellCacheReady(state: PprFallbackShellState): Promise<void>;
+declare function preparePprFallbackShellFinalRender(state: PprFallbackShellState): void;
+declare function beginPprFallbackShellFinalRender(state: PprFallbackShellState): void;
+declare function isPprFallbackShellAbortError(error: unknown): boolean;
+//#endregion
+export { PprFallbackShellState, beginPprFallbackShellFinalRender, createPprFallbackShellState, createPprFallbackShellSuspensePromise, createPprFallbackShellSuspensePromiseForState, getPprFallbackShellState, isPprFallbackShellAbortError, markPprFallbackShellDynamicBoundary, preparePprFallbackShellFinalRender, runWithPprFallbackShellState, trackPprFallbackShellCacheTask, waitForPprFallbackShellCacheReady };

package/dist/shims/ppr-fallback-shell.js

@@ -0,0 +1,170 @@
+import { getOrCreateAls } from "./internal/als-registry.js";
+import { makeHangingPromise } from "./internal/make-hanging-promise.js";
+//#region src/shims/ppr-fallback-shell.ts
+const pprFallbackShellAls = getOrCreateAls("vinext.pprFallbackShell.als");
+const pprFallbackShellCacheTaskStackAls = getOrCreateAls("vinext.pprFallbackShell.cacheTaskStack.als");
+function noop() {}
+function scheduleAfterTask(callback) {
+	let firstTimer = setTimeout(() => {
+		firstTimer = null;
+		secondTimer = setTimeout(() => {
+			secondTimer = null;
+			callback();
+		}, 0);
+	}, 0);
+	let secondTimer = null;
+	return () => {
+		if (firstTimer !== null) {
+			clearTimeout(firstTimer);
+			firstTimer = null;
+		}
+		if (secondTimer !== null) {
+			clearTimeout(secondTimer);
+			secondTimer = null;
+		}
+	};
+}
+function resolveCacheReadyIfSettled(state) {
+	if (state.pendingCacheTasks !== 0) return;
+	const resolvers = state.cacheReadyResolvers.splice(0);
+	for (const resolve of resolvers) resolve();
+}
+function cancelPendingCacheReady(state) {
+	if (state.pendingCacheReadyCleanup === null) return;
+	state.pendingCacheReadyCleanup();
+	state.pendingCacheReadyCleanup = null;
+}
+function scheduleCacheReadyIfSettled(state) {
+	if (state.pendingCacheTasks !== 0 || state.pendingCacheReadyCleanup !== null) return;
+	state.pendingCacheReadyCleanup = scheduleAfterTask(() => {
+		state.pendingCacheReadyCleanup = null;
+		resolveCacheReadyIfSettled(state);
+		if (state.phase === "final") scheduleAbortIfReady(state);
+	});
+}
+function scheduleAbortIfReady(state) {
+	if (state.phase !== "final" || !state.isFinalRenderStarted || !state.hasDynamicBoundary || state.pendingCacheTasks > 0 || state.pendingCacheReadyCleanup !== null || state.isAbortScheduled) return;
+	state.isAbortScheduled = true;
+	state.pendingAbortCleanup = scheduleAfterTask(() => {
+		state.pendingAbortCleanup = null;
+		state.isAbortScheduled = false;
+		if (state.phase === "final" && state.hasDynamicBoundary && state.pendingCacheTasks === 0 && state.pendingCacheReadyCleanup === null && !state.reactAbortController.signal.aborted) {
+			state.reactAbortController.abort();
+			state.abortController.abort();
+		}
+	});
+}
+function completeCacheTask(state, task) {
+	if (!task.isPending) return;
+	task.isPending = false;
+	if (task.epoch !== state.cacheEpoch) return;
+	state.pendingCacheTasks--;
+	scheduleCacheReadyIfSettled(state);
+}
+function ignoreCacheTask(state, task) {
+	if (!task.isPending || task.isIgnored) return;
+	task.isIgnored = true;
+	completeCacheTask(state, task);
+}
+function createPprFallbackShellState(options) {
+	const abortController = new AbortController();
+	return {
+		abortController,
+		reactAbortController: abortController,
+		cacheEpoch: 0,
+		cacheReadyResolvers: [],
+		fallbackParamNames: new Set(options.fallbackParamNames),
+		hasDynamicBoundary: false,
+		isFinalRenderStarted: false,
+		isAbortScheduled: false,
+		pendingAbortCleanup: null,
+		pendingCacheReadyCleanup: null,
+		pendingCacheTasks: 0,
+		phase: "warmup",
+		routePattern: options.routePattern
+	};
+}
+function runWithPprFallbackShellState(state, fn) {
+	return pprFallbackShellAls.run(state, fn);
+}
+function getPprFallbackShellState() {
+	return pprFallbackShellAls.getStore() ?? null;
+}
+function trackPprFallbackShellCacheTask(fn, cacheVariant) {
+	const state = getPprFallbackShellState();
+	if (state === null || cacheVariant === "private") return fn();
+	cancelPendingCacheReady(state);
+	state.pendingCacheTasks++;
+	const task = {
+		epoch: state.cacheEpoch,
+		isIgnored: false,
+		isPending: true
+	};
+	const parentStack = pprFallbackShellCacheTaskStackAls.getStore() ?? [];
+	let promise;
+	try {
+		promise = pprFallbackShellCacheTaskStackAls.run([...parentStack, task], fn);
+	} catch (error) {
+		completeCacheTask(state, task);
+		return Promise.reject(error);
+	}
+	return promise.finally(() => {
+		if (!task.isIgnored) completeCacheTask(state, task);
+	});
+}
+function createPprFallbackShellSuspensePromiseForState(state, expression) {
+	markPprFallbackShellDynamicBoundaryForState(state);
+	if (state.phase === "final") scheduleAbortIfReady(state);
+	const promise = makeHangingPromise(state.abortController.signal, state.routePattern, expression);
+	promise.catch(noop);
+	return promise;
+}
+function markPprFallbackShellDynamicBoundaryForState(state) {
+	state.hasDynamicBoundary = true;
+	for (const task of pprFallbackShellCacheTaskStackAls.getStore() ?? []) ignoreCacheTask(state, task);
+	scheduleCacheReadyIfSettled(state);
+}
+function markPprFallbackShellDynamicBoundary() {
+	const state = getPprFallbackShellState();
+	if (state === null || state.fallbackParamNames.size === 0) return;
+	markPprFallbackShellDynamicBoundaryForState(state);
+}
+function createPprFallbackShellSuspensePromise(expression) {
+	const state = getPprFallbackShellState();
+	if (state === null) return null;
+	return createPprFallbackShellSuspensePromiseForState(state, expression);
+}
+function waitForPprFallbackShellCacheReady(state) {
+	if (state.phase !== "warmup") return Promise.resolve();
+	return new Promise((resolve) => {
+		state.cacheReadyResolvers.push(resolve);
+		scheduleCacheReadyIfSettled(state);
+	});
+}
+function preparePprFallbackShellFinalRender(state) {
+	cancelPendingCacheReady(state);
+	if (state.pendingAbortCleanup !== null) {
+		state.pendingAbortCleanup();
+		state.pendingAbortCleanup = null;
+	}
+	state.abortController = new AbortController();
+	state.reactAbortController = new AbortController();
+	state.cacheEpoch++;
+	state.cacheReadyResolvers.length = 0;
+	state.hasDynamicBoundary = false;
+	state.isFinalRenderStarted = false;
+	state.isAbortScheduled = false;
+	state.pendingCacheTasks = 0;
+	state.phase = "final";
+}
+function beginPprFallbackShellFinalRender(state) {
+	if (state.phase !== "final") return;
+	state.isFinalRenderStarted = true;
+	scheduleAbortIfReady(state);
+}
+function isPprFallbackShellAbortError(error) {
+	if (typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError") return true;
+	return error instanceof Error && error.name === "HangingPromiseRejectionError";
+}
+//#endregion
+export { beginPprFallbackShellFinalRender, createPprFallbackShellState, createPprFallbackShellSuspensePromise, createPprFallbackShellSuspensePromiseForState, getPprFallbackShellState, isPprFallbackShellAbortError, markPprFallbackShellDynamicBoundary, preparePprFallbackShellFinalRender, runWithPprFallbackShellState, trackPprFallbackShellCacheTask, waitForPprFallbackShellCacheReady };

package/dist/shims/readonly-url-search-params.d.ts

@@ -0,0 +1,13 @@
+//#region src/shims/readonly-url-search-params.d.ts
+/**
+ * Read-only URLSearchParams wrapper matching Next.js runtime behavior.
+ * Mutation methods remain present for instanceof/API compatibility but throw.
+ */
+declare class ReadonlyURLSearchParams extends URLSearchParams {
+  append(_name: string, _value: string): never;
+  delete(_name: string, _value?: string): never;
+  set(_name: string, _value: string): never;
+  sort(): never;
+}
+//#endregion
+export { ReadonlyURLSearchParams };

package/dist/shims/readonly-url-search-params.js

@@ -0,0 +1,26 @@
+//#region src/shims/readonly-url-search-params.ts
+var ReadonlyURLSearchParamsError = class extends Error {
+	constructor() {
+		super("Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams");
+	}
+};
+/**
+* Read-only URLSearchParams wrapper matching Next.js runtime behavior.
+* Mutation methods remain present for instanceof/API compatibility but throw.
+*/
+var ReadonlyURLSearchParams = class extends URLSearchParams {
+	append(_name, _value) {
+		throw new ReadonlyURLSearchParamsError();
+	}
+	delete(_name, _value) {
+		throw new ReadonlyURLSearchParamsError();
+	}
+	set(_name, _value) {
+		throw new ReadonlyURLSearchParamsError();
+	}
+	sort() {
+		throw new ReadonlyURLSearchParamsError();
+	}
+};
+//#endregion
+export { ReadonlyURLSearchParams };

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

@@ -0,0 +1,58 @@
+//#region src/shims/request-context.d.ts
+/**
+ * Request ExecutionContext — AsyncLocalStorage-backed accessor.
+ *
+ * Makes the Cloudflare Workers `ExecutionContext` (which provides
+ * `waitUntil`) available to any code on the call stack during a request
+ * without requiring it to be threaded through every function signature.
+ *
+ * Usage:
+ *
+ *   // In the worker entry, wrap the handler:
+ *   import { runWithExecutionContext } from "vinext/shims/request-context";
+ *   export default {
+ *     fetch(request, env, ctx) {
+ *       return runWithExecutionContext(ctx, () => handler.fetch(request, env, ctx));
+ *     }
+ *   };
+ *
+ *   // Anywhere downstream:
+ *   import { getRequestExecutionContext } from "vinext/shims/request-context";
+ *   const ctx = getRequestExecutionContext(); // null on Node.js dev
+ *   ctx?.waitUntil(somePromise);
+ */
+/**
+ * Minimal structural ExecutionContext interface, kept free of any host-runtime
+ * dependency.
+ */
+type ExecutionContextLike = {
+  waitUntil(promise: Promise<unknown>): void;
+  passThroughOnException?(): void;
+  /**
+   * Optional host-provided cache handle that some runtimes expose on the
+   * execution context. Typed as `unknown` to keep this module runtime-agnostic;
+   * CDN cache adapters that know the concrete shape narrow it themselves.
+   */
+  cache?: unknown;
+};
+/**
+ * Run `fn` with the given `ExecutionContext` available via
+ * `getRequestExecutionContext()` for the duration of the call (including
+ * all async continuations, such as RSC streaming).
+ *
+ * Call this at the top of your Worker's `fetch` handler, wrapping the
+ * delegation to vinext so the context propagates through the entire
+ * request pipeline.
+ */
+declare function runWithExecutionContext<T>(ctx: ExecutionContextLike, fn: () => Promise<T>): Promise<T>;
+declare function runWithExecutionContext<T>(ctx: ExecutionContextLike, fn: () => T | Promise<T>): T | Promise<T>;
+/**
+ * Get the `ExecutionContext` for the current request, or `null` when called
+ * outside a `runWithExecutionContext()` scope (e.g. on Node.js dev server).
+ *
+ * Use `ctx?.waitUntil(promise)` to schedule background work that must
+ * complete before the Worker isolate is torn down.
+ */
+declare function getRequestExecutionContext(): ExecutionContextLike | null;
+//#endregion
+export { ExecutionContextLike, getRequestExecutionContext, runWithExecutionContext };

package/dist/shims/request-context.js

@@ -0,0 +1,45 @@
+import { getOrCreateAls } from "./internal/als-registry.js";
+import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
+//#region src/shims/request-context.ts
+/**
+* Request ExecutionContext — AsyncLocalStorage-backed accessor.
+*
+* Makes the Cloudflare Workers `ExecutionContext` (which provides
+* `waitUntil`) available to any code on the call stack during a request
+* without requiring it to be threaded through every function signature.
+*
+* Usage:
+*
+*   // In the worker entry, wrap the handler:
+*   import { runWithExecutionContext } from "vinext/shims/request-context";
+*   export default {
+*     fetch(request, env, ctx) {
+*       return runWithExecutionContext(ctx, () => handler.fetch(request, env, ctx));
+*     }
+*   };
+*
+*   // Anywhere downstream:
+*   import { getRequestExecutionContext } from "vinext/shims/request-context";
+*   const ctx = getRequestExecutionContext(); // null on Node.js dev
+*   ctx?.waitUntil(somePromise);
+*/
+const _als = getOrCreateAls("vinext.requestContext.als");
+function runWithExecutionContext(ctx, fn) {
+	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((uCtx) => {
+		uCtx.executionContext = ctx;
+	}, fn);
+	return _als.run(ctx, fn);
+}
+/**
+* Get the `ExecutionContext` for the current request, or `null` when called
+* outside a `runWithExecutionContext()` scope (e.g. on Node.js dev server).
+*
+* Use `ctx?.waitUntil(promise)` to schedule background work that must
+* complete before the Worker isolate is torn down.
+*/
+function getRequestExecutionContext() {
+	if (isInsideUnifiedScope()) return getRequestContext().executionContext;
+	return _als.getStore() ?? null;
+}
+//#endregion
+export { getRequestExecutionContext, runWithExecutionContext };

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

@@ -0,0 +1,12 @@
+import { CacheLifeConfig, CacheState } from "./cache-request-state.js";
+import { ExecutionContextLike } from "./request-context.js";
+import { NavigationContext } from "./navigation-context-state.js";
+import { RootParamsState } from "./root-params.js";
+import { FetchCacheState } from "./fetch-cache.js";
+import { HeadersAccessPhase, HeadersContext, VinextHeadersShimState } from "./headers.js";
+import { RouterState, SSRContext } from "./router-state.js";
+import { PrivateCacheState } from "./cache-runtime.js";
+import { HeadState } from "./head-state.js";
+import { I18nState } from "./i18n-state.js";
+import { NavigationState } from "./navigation-state.js";
+export type { CacheLifeConfig, CacheState, ExecutionContextLike, FetchCacheState, HeadState, HeadersAccessPhase, HeadersContext, I18nState, NavigationContext, NavigationState, PrivateCacheState, RootParamsState, RouterState, SSRContext, VinextHeadersShimState };

package/dist/shims/request-state-types.js

@@ -0,0 +1 @@
+export {};

package/dist/shims/root-params.d.ts

@@ -0,0 +1,12 @@
+//#region src/shims/root-params.d.ts
+type RootParams = Record<string, string | string[] | undefined>;
+type RootParamsState = {
+  rootParams: RootParams | null;
+};
+declare function pickRootParams(params: RootParams, rootParamNames: readonly string[] | null | undefined): RootParams;
+declare function setRootParams(params: RootParams | null): void;
+declare function getRootParam(name: string): Promise<string | string[] | undefined>;
+declare function runWithRootParamsScope<T>(params: RootParams, fn: () => Promise<T>): Promise<T>;
+declare function runWithRootParamsScope<T>(params: RootParams, fn: () => T | Promise<T>): T | Promise<T>;
+//#endregion
+export { RootParams, RootParamsState, getRootParam, pickRootParams, runWithRootParamsScope, setRootParams };

package/dist/shims/root-params.js

@@ -0,0 +1,30 @@
+import { getOrCreateAls } from "./internal/als-registry.js";
+import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
+//#region src/shims/root-params.ts
+const _FALLBACK_KEY = Symbol.for("vinext.rootParams.fallback");
+const _g = globalThis;
+const _als = getOrCreateAls("vinext.rootParams.als");
+const _fallbackState = _g[_FALLBACK_KEY] ??= { rootParams: null };
+function getState() {
+	if (isInsideUnifiedScope()) return getRequestContext();
+	return _als.getStore() ?? _fallbackState;
+}
+function pickRootParams(params, rootParamNames) {
+	const picked = {};
+	for (const name of rootParamNames ?? []) picked[name] = params[name];
+	return picked;
+}
+function setRootParams(params) {
+	getState().rootParams = params;
+}
+function getRootParam(name) {
+	return Promise.resolve(getState().rootParams?.[name]);
+}
+function runWithRootParamsScope(params, fn) {
+	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((ctx) => {
+		ctx.rootParams = params;
+	}, fn);
+	else return _als.run({ rootParams: params }, fn);
+}
+//#endregion
+export { getRootParam, pickRootParams, runWithRootParamsScope, setRootParams };

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

@@ -0,0 +1,32 @@
+//#region src/shims/router-state.d.ts
+/**
+ * Server-only Pages Router state backed by AsyncLocalStorage.
+ *
+ * Provides request-scoped isolation for SSR context (pathname, query,
+ * locale) so concurrent requests on Workers don't share state.
+ *
+ * This module is server-only — it imports node:async_hooks and must NOT
+ * be bundled for the browser.
+ */
+type SSRContext = {
+  pathname: string;
+  query: Record<string, string | string[]>;
+  asPath: string;
+  navigationIsReady?: boolean;
+  locale?: string;
+  locales?: string[];
+  defaultLocale?: string;
+  isFallback?: boolean;
+};
+type RouterState = {
+  ssrContext: SSRContext | null;
+};
+/**
+ * Run a function within a router state ALS scope.
+ * Ensures per-request isolation for Pages Router SSR context
+ * on concurrent runtimes.
+ */
+declare function runWithRouterState<T>(fn: () => Promise<T>): Promise<T>;
+declare function runWithRouterState<T>(fn: () => T | Promise<T>): T | Promise<T>;
+//#endregion
+export { RouterState, SSRContext, runWithRouterState };

package/dist/shims/router-state.js

@@ -0,0 +1,39 @@
+import { getOrCreateAls } from "./internal/als-registry.js";
+import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
+import { _registerRouterStateAccessors } from "./router.js";
+import { registerRoutePatternForWarningAccessor } from "./internal/route-pattern-for-warning.js";
+//#region src/shims/router-state.ts
+/**
+* Server-only Pages Router state backed by AsyncLocalStorage.
+*
+* Provides request-scoped isolation for SSR context (pathname, query,
+* locale) so concurrent requests on Workers don't share state.
+*
+* This module is server-only — it imports node:async_hooks and must NOT
+* be bundled for the browser.
+*/
+const _FALLBACK_KEY = Symbol.for("vinext.router.fallback");
+const _g = globalThis;
+const _als = getOrCreateAls("vinext.router.als");
+const _fallbackState = _g[_FALLBACK_KEY] ??= { ssrContext: null };
+function _getState() {
+	if (isInsideUnifiedScope()) return getRequestContext();
+	return _als.getStore() ?? _fallbackState;
+}
+function runWithRouterState(fn) {
+	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((uCtx) => {
+		uCtx.ssrContext = null;
+	}, fn);
+	return _als.run({ ssrContext: null }, fn);
+}
+_registerRouterStateAccessors({
+	getSSRContext() {
+		return _getState().ssrContext;
+	},
+	setSSRContext(ctx) {
+		_getState().ssrContext = ctx;
+	}
+});
+registerRoutePatternForWarningAccessor(() => _getState().ssrContext?.pathname ?? null);
+//#endregion
+export { runWithRouterState };