vinext 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/shims/server.d.ts

@@ -9,28 +9,36 @@
  * This is a pragmatic subset — we implement the most commonly used APIs
  * rather than bug-for-bug parity with Next.js internals.
  */
+/** @deprecated Import ImageResponse from `next/og` instead. */
+declare function ImageResponse(): never;
+type RequestInit = globalThis.RequestInit & {
+  nextConfig?: {
+    basePath?: string;
+    i18n?: {
+      locales: readonly string[];
+      defaultLocale: string;
+      domains?: ReadonlyArray<{
+        domain: string;
+        defaultLocale: string;
+        locales?: readonly string[];
+        http?: true;
+      }>;
+    } | null;
+    trailingSlash?: boolean;
+  };
+  signal?: AbortSignal;
+  duplex?: "half";
+};
 declare class NextRequest extends Request {
   private _nextUrl;
   private _url;
   private _cookies;
-  constructor(input: URL | RequestInfo, init?: RequestInit & {
-    nextConfig?: {
-      basePath?: string;
-      i18n?: {
-        locales: string[];
-        defaultLocale: string;
-        domains?: Array<{
-          domain: string;
-          defaultLocale: string;
-          locales?: string[];
-        }>;
-      };
-      trailingSlash?: boolean;
-    };
-  });
+  constructor(input: URL | RequestInfo, init?: RequestInit);
   get nextUrl(): NextURL;
   get url(): string;
   get cookies(): RequestCookies;
+  get page(): void;
+  get ua(): void;
   /**
    * Client IP address. Prefers Cloudflare's trusted CF-Connecting-IP header
    * over the spoofable X-Forwarded-For. Returns undefined if unavailable.
@@ -65,12 +73,16 @@ declare class NextResponse<_Body = unknown> extends Response {
   /**
    * Create a redirect response.
    */
-  static redirect(url: string | URL | NextURL, init?: number | ResponseInit): NextResponse;
+  static redirect(url: string | URL | {
+    toString(): string;
+  }, init?: number | ResponseInit): NextResponse;
   /**
    * Create a rewrite response (middleware pattern).
    * Sets the x-middleware-rewrite header.
    */
-  static rewrite(destination: string | URL | NextURL, init?: MiddlewareResponseInit): NextResponse;
+  static rewrite(destination: string | URL | {
+    toString(): string;
+  }, init?: MiddlewareResponseInit): NextResponse;
   /**
    * Continue to the next handler (middleware pattern).
    * Sets the x-middleware-next header.
@@ -176,6 +188,7 @@ declare class NextURL {
   get locales(): string[] | undefined;
   clone(): NextURL;
   toString(): string;
+  toJSON(): string;
   /**
    * The build ID of the Next.js application.
    * Set from `generateBuildId` in next.config.js, or a random UUID if not configured.
@@ -202,7 +215,7 @@ declare class RequestCookies {
   toString(): string;
   private _serialize;
   private _syncHeader;
-  [Symbol.iterator](): IterableIterator<[string, CookieEntry]>;
+  [Symbol.iterator](): MapIterator<[string, CookieEntry]>;
 }
 declare function sealRequestHeaders(headers: Headers): Headers;
 declare function sealRequestCookies(cookies: RequestCookies): RequestCookies;
@@ -217,15 +230,16 @@ declare class ResponseCookies {
   }]): this;
   get(...args: [name: string] | [options: {
     name: string;
-  }]): CookieEntry | undefined;
+  }]): ResponseCookieEntry | undefined;
   has(name: string): boolean;
   getAll(...args: [name: string] | [options: {
     name: string;
-  }] | []): CookieEntry[];
+  }] | []): ResponseCookieEntry[];
   delete(...args: [name: string] | [options: Omit<CookieOptions & {
     name: string;
   }, "maxAge" | "expires">]): this;
-  [Symbol.iterator](): IterableIterator<[string, CookieEntry]>;
+  [Symbol.iterator](): MapIterator<[string, ResponseCookieEntry]>;
+  toString(): string;
   /** Delete all Set-Cookie headers and re-append from the internal map. */
   private _syncHeaders;
 }
@@ -233,11 +247,14 @@ type CookieOptions = {
   path?: string;
   domain?: string;
   maxAge?: number;
-  expires?: Date;
+  expires?: Date | number;
   httpOnly?: boolean;
   secure?: boolean;
-  sameSite?: "Strict" | "Lax" | "None";
+  sameSite?: true | false | "strict" | "lax" | "none";
+  partitioned?: boolean;
+  priority?: "low" | "medium" | "high";
 };
+type ResponseCookieEntry = CookieEntry & CookieOptions;
 type MiddlewareResponseInit = {
   request?: {
     headers?: Headers;
@@ -253,8 +270,16 @@ declare class NextFetchEvent {
   sourcePage: string;
   private _waitUntilPromises;
   constructor(params: {
+    request?: Request;
     page: string;
+    context?: {
+      waitUntil(promise: Promise<unknown>): void;
+    };
   });
+  private _externalWaitUntil?;
+  get request(): void;
+  respondWith(): void;
+  passThroughOnException(): void;
   waitUntil(promise: Promise<unknown>): void;
   get waitUntilPromises(): Promise<unknown>[];
   /** Drain all waitUntil promises. Returns a single promise that settles when all are done. */
@@ -300,8 +325,7 @@ type UserAgent = {
  *
  * Uses the platform's `waitUntil` (via the per-request ExecutionContext) when
  * available so the task survives past the response on Cloudflare Workers.
- * Falls back to a fire-and-forget microtask on runtimes without an execution
- * context (e.g. Node.js dev server).
+ * Node.js dev drains callbacks from its response finish/close lifecycle.
  *
  * Throws when called inside a cached scope — request-specific
  * side-effects must not leak into cached results.
@@ -320,4 +344,4 @@ declare function connection(): Promise<void>;
  */
 declare const URLPattern: typeof globalThis.URLPattern;
 //#endregion
-export { MiddlewareResponseInit, NextFetchEvent, NextMiddleware, NextMiddlewareResult, NextRequest, NextResponse, NextURL, NextURLConfig, RequestCookies, ResponseCookies, URLPattern, UserAgent, after, connection, sealRequestCookies, sealRequestHeaders, userAgent, userAgentFromString };
+export { ImageResponse, MiddlewareResponseInit, NextFetchEvent, NextMiddleware, NextMiddlewareResult, NextRequest, NextResponse, NextURL, NextURLConfig, RequestCookies, RequestInit, ResponseCookies, URLPattern, UserAgent, after, connection, sealRequestCookies, sealRequestHeaders, userAgent, userAgentFromString };

package/dist/shims/server.js

@@ -1,9 +1,10 @@
+import { bindRequestContextSnapshot, getRequestContext, isInsideUnifiedScope, queueAfterCallback } from "./unified-request-context.js";
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { getRequestExecutionContext } from "./request-context.js";
 import { MIDDLEWARE_SET_COOKIE_HEADER } from "../utils/protocol-headers.js";
 import { MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_REWRITE_HEADER } from "../server/headers.js";
 import { encodeMiddlewareRequestHeaders } from "../utils/middleware-request-headers.js";
-import { serializeSetCookie, validateCookieName } from "./internal/cookie-serialize.js";
+import { validateCookieAttributeValue, validateCookieName } from "./internal/cookie-serialize.js";
 import { parseEdgeRequestCookieHeader } from "../utils/parse-cookie.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
 //#region src/shims/server.ts
@@ -17,6 +18,10 @@ import { assertSafeNavigationUrl } from "./url-safety.js";
 * This is a pragmatic subset — we implement the most commonly used APIs
 * rather than bug-for-bug parity with Next.js internals.
 */
+/** @deprecated Import ImageResponse from `next/og` instead. */
+function ImageResponse() {
+	throw new Error("ImageResponse has moved from next/server to next/og");
+}
 const _USE_CACHE_ALS_KEY = Symbol.for("vinext.cacheRuntime.contextAls");
 const _UNSTABLE_CACHE_ALS_KEY = Symbol.for("vinext.unstableCache.als");
 const _g = globalThis;
@@ -60,10 +65,18 @@ var NextRequest = class extends Request {
 			});
 		} else super(input, requestInit);
 		const url = typeof input === "string" ? new URL(input, "http://localhost") : input instanceof URL ? input : new URL(input.url, "http://localhost");
+		const i18n = _nextConfig?.i18n ? {
+			locales: [..._nextConfig.i18n.locales],
+			defaultLocale: _nextConfig.i18n.defaultLocale,
+			domains: _nextConfig.i18n.domains?.map((domain) => ({
+				...domain,
+				locales: domain.locales ? [...domain.locales] : void 0
+			}))
+		} : void 0;
 		const urlConfig = _nextConfig ? {
 			basePath: _nextConfig.basePath,
 			nextConfig: {
-				i18n: _nextConfig.i18n,
+				i18n,
 				trailingSlash: _nextConfig.trailingSlash
 			}
 		} : void 0;
@@ -80,6 +93,12 @@ var NextRequest = class extends Request {
 	get cookies() {
 		return this._cookies;
 	}
+	get page() {
+		throw new Error("NextRequest.page has been removed; use URLPattern instead");
+	}
+	get ua() {
+		throw new Error("NextRequest.ua has been removed; use userAgent() instead");
+	}
 	/**
 	* Client IP address. Prefers Cloudflare's trusted CF-Connecting-IP header
 	* over the spoofable X-Forwarded-For. Returns undefined if unavailable.
@@ -140,12 +159,8 @@ var NextResponse = class NextResponse extends Response {
 	* Create a JSON response.
 	*/
 	static json(body, init) {
-		const headers = new Headers(init?.headers);
-		if (!headers.has("content-type")) headers.set("content-type", "application/json");
-		return new NextResponse(JSON.stringify(body), {
-			...init,
-			headers
-		});
+		const response = Response.json(body, init);
+		return new NextResponse(response.body, response);
 	}
 	/**
 	* Create a redirect response.
@@ -399,7 +414,7 @@ var NextURL = class NextURL {
 		};
 		if (this._trailingSlash) nextConfig.trailingSlash = true;
 		const config = {
-			basePath: this._basePath,
+			basePath: this._configBasePath,
 			nextConfig: Object.keys(nextConfig).length > 0 ? nextConfig : void 0
 		};
 		return new NextURL(this.href, void 0, config);
@@ -407,6 +422,9 @@ var NextURL = class NextURL {
 	toString() {
 		return this.href;
 	}
+	toJSON() {
+		return this.href;
+	}
 	/**
 	* The build ID of the Next.js application.
 	* Set from `generateBuildId` in next.config.js, or a random UUID if not configured.
@@ -489,7 +507,7 @@ var RequestCookies = class {
 		else this._headers.set("cookie", this._serialize());
 	}
 	[Symbol.iterator]() {
-		return this.getAll().map((c) => [c.name, c])[Symbol.iterator]();
+		return new Map(this.getAll().map((cookie) => [cookie.name, cookie])).entries();
 	}
 };
 var ReadonlyRequestCookiesError = class ReadonlyRequestCookiesError extends Error {
@@ -533,74 +551,54 @@ var ResponseCookies = class {
 	_parsed = /* @__PURE__ */ new Map();
 	constructor(headers) {
 		this._headers = headers;
-		for (const header of headers.getSetCookie()) {
-			const eq = header.indexOf("=");
-			if (eq === -1) continue;
-			const cookieName = header.slice(0, eq);
-			const semi = header.indexOf(";", eq);
-			const raw = header.slice(eq + 1, semi === -1 ? void 0 : semi);
-			let value;
-			try {
-				value = decodeURIComponent(raw);
-			} catch {
-				value = raw;
-			}
-			this._parsed.set(cookieName, {
-				serialized: header,
-				entry: {
-					name: cookieName,
-					value
-				}
-			});
+		const setCookie = headers.getSetCookie?.() ?? headers.get("set-cookie") ?? [];
+		const cookieStrings = Array.isArray(setCookie) ? setCookie : splitSetCookieString(setCookie);
+		for (const header of cookieStrings) {
+			const entry = parseSetCookieHeader(header);
+			if (entry) this._parsed.set(entry.name, entry);
 		}
 	}
 	set(...args) {
 		const [name, value, opts] = parseCookieSetArgs(args);
 		validateCookieName(name);
-		const serialized = serializeSetCookie(name, value, opts);
-		this._parsed.set(name, {
-			serialized,
-			entry: {
-				name,
-				value
-			}
-		});
+		const entry = normalizeResponseCookie(name, value, opts);
+		validateResponseCookieAttributes(entry);
+		this._parsed.set(name, entry);
 		this._syncHeaders();
 		return this;
 	}
 	get(...args) {
 		const key = typeof args[0] === "string" ? args[0] : args[0].name;
-		return this._parsed.get(key)?.entry;
+		return this._parsed.get(key);
 	}
 	has(name) {
 		return this._parsed.has(name);
 	}
 	getAll(...args) {
-		const all = [...this._parsed.values()].map((v) => v.entry);
+		const all = [...this._parsed.values()];
 		if (args.length === 0) return all;
 		const key = typeof args[0] === "string" ? args[0] : args[0].name;
 		return all.filter((c) => c.name === key);
 	}
 	delete(...args) {
-		const [name, opts] = typeof args[0] === "string" ? [args[0], void 0] : [args[0].name, args[0]];
+		const [name, options] = typeof args[0] === "string" ? [args[0], void 0] : [args[0].name, args[0]];
 		return this.set({
+			...options,
 			name,
 			value: "",
-			expires: /* @__PURE__ */ new Date(0),
-			path: opts?.path,
-			domain: opts?.domain,
-			httpOnly: opts?.httpOnly,
-			secure: opts?.secure,
-			sameSite: opts?.sameSite
+			expires: /* @__PURE__ */ new Date(0)
 		});
 	}
 	[Symbol.iterator]() {
-		return [...this._parsed.values()].map((v) => [v.entry.name, v.entry])[Symbol.iterator]();
+		return new Map([...this._parsed.values()].map((entry) => [entry.name, entry])).entries();
+	}
+	toString() {
+		return [...this._parsed.values()].map(stringifyResponseCookie).join("; ");
 	}
 	/** Delete all Set-Cookie headers and re-append from the internal map. */
 	_syncHeaders() {
 		this._headers.delete("Set-Cookie");
-		for (const { serialized } of this._parsed.values()) this._headers.append("Set-Cookie", serialized);
+		for (const entry of this._parsed.values()) this._headers.append("Set-Cookie", stringifyResponseCookie(entry));
 	}
 };
 var MiddlewareResponseCookies = class extends ResponseCookies {
@@ -628,6 +626,115 @@ var MiddlewareResponseCookies = class extends ResponseCookies {
 		this._responseHeaders.set(MIDDLEWARE_SET_COOKIE_HEADER, cookies.join(","));
 	}
 };
+function normalizeResponseCookie(name, value, options) {
+	const cookie = {
+		name,
+		value,
+		...options
+	};
+	if (typeof cookie.expires === "number") cookie.expires = new Date(cookie.expires);
+	if (cookie.maxAge) cookie.expires = new Date(Date.now() + cookie.maxAge * 1e3);
+	if (cookie.path == null) cookie.path = "/";
+	return cookie;
+}
+function parseSetCookieHeader(header) {
+	if (!header) return void 0;
+	const [[name, value], ...attributes] = parseResponseCookiePairs(header);
+	const { domain, expires, httponly, maxage, path, samesite, secure, partitioned, priority } = Object.fromEntries(attributes.map(([key, attributeValue]) => [key.toLowerCase().replaceAll("-", ""), attributeValue]));
+	return compactResponseCookie({
+		name,
+		value: decodeURIComponent(value),
+		domain,
+		...expires && { expires: new Date(expires) },
+		...httponly && { httpOnly: true },
+		...typeof maxage === "string" && { maxAge: Number(maxage) },
+		path,
+		...samesite && { sameSite: parseResponseCookieSameSite(samesite) },
+		...secure && { secure: true },
+		...priority && { priority: parseResponseCookiePriority(priority) },
+		...partitioned && { partitioned: true }
+	});
+}
+function parseResponseCookiePairs(cookie) {
+	const map = /* @__PURE__ */ new Map();
+	for (const pair of cookie.split(/; */)) {
+		if (!pair) continue;
+		const splitAt = pair.indexOf("=");
+		if (splitAt === -1) {
+			map.set(pair, "true");
+			continue;
+		}
+		const key = pair.slice(0, splitAt);
+		const value = pair.slice(splitAt + 1);
+		try {
+			map.set(key, decodeURIComponent(value ?? "true"));
+		} catch {}
+	}
+	return map;
+}
+function compactResponseCookie(cookie) {
+	const compact = {};
+	for (const key in cookie) if (cookie[key]) compact[key] = cookie[key];
+	return compact;
+}
+function parseResponseCookieSameSite(value) {
+	const sameSite = value.toLowerCase();
+	return sameSite === "strict" || sameSite === "lax" || sameSite === "none" ? sameSite : void 0;
+}
+function parseResponseCookiePriority(value) {
+	const priority = value.toLowerCase();
+	return priority === "low" || priority === "medium" || priority === "high" ? priority : void 0;
+}
+function validateResponseCookieAttributes(cookie) {
+	if (cookie.path) validateCookieAttributeValue(cookie.path, "Path");
+	if (cookie.domain) validateCookieAttributeValue(cookie.domain, "Domain");
+}
+function stringifyResponseCookie(cookie) {
+	const attributes = [
+		cookie.path && `Path=${cookie.path}`,
+		(cookie.expires || cookie.expires === 0) && `Expires=${(typeof cookie.expires === "number" ? new Date(cookie.expires) : cookie.expires).toUTCString()}`,
+		typeof cookie.maxAge === "number" && `Max-Age=${cookie.maxAge}`,
+		cookie.domain && `Domain=${cookie.domain}`,
+		cookie.secure && "Secure",
+		cookie.httpOnly && "HttpOnly",
+		cookie.sameSite && `SameSite=${cookie.sameSite}`,
+		cookie.partitioned && "Partitioned",
+		cookie.priority && `Priority=${cookie.priority}`
+	].filter(Boolean);
+	const stringified = `${cookie.name}=${encodeURIComponent(cookie.value ?? "")}`;
+	return attributes.length === 0 ? stringified : `${stringified}; ${attributes.join("; ")}`;
+}
+function splitSetCookieString(value) {
+	const cookies = [];
+	let position = 0;
+	let start = 0;
+	const skipWhitespace = () => {
+		while (position < value.length && /\s/.test(value.charAt(position))) position++;
+		return position < value.length;
+	};
+	while (position < value.length) {
+		start = position;
+		let separatorFound = false;
+		while (skipWhitespace()) {
+			if (value.charAt(position) !== ",") {
+				position++;
+				continue;
+			}
+			const lastComma = position++;
+			skipWhitespace();
+			const nextStart = position;
+			while (position < value.length && !"=;,".includes(value.charAt(position))) position++;
+			if (position < value.length && value.charAt(position) === "=") {
+				separatorFound = true;
+				position = nextStart;
+				cookies.push(value.substring(start, lastComma));
+				start = position;
+			} else position = lastComma + 1;
+		}
+		if (!separatorFound || position >= value.length) cookies.push(value.substring(start));
+	}
+	return cookies;
+}
 /**
 * Parse the overloaded arguments for ResponseCookies.set():
 *   - (name, value, options?) — positional form
@@ -655,8 +762,21 @@ var NextFetchEvent = class {
 	_waitUntilPromises = [];
 	constructor(params) {
 		this.sourcePage = params.page;
+		if (params.context) this._externalWaitUntil = params.context.waitUntil.bind(params.context);
+	}
+	_externalWaitUntil;
+	get request() {
+		throw new Error(`The middleware signature for ${this.sourcePage} no longer exposes event.request`);
+	}
+	respondWith() {
+		throw new Error(`The middleware signature for ${this.sourcePage} no longer uses respondWith()`);
 	}
+	passThroughOnException() {}
 	waitUntil(promise) {
+		if (this._externalWaitUntil) {
+			this._externalWaitUntil(promise);
+			return;
+		}
 		this._waitUntilPromises.push(promise);
 	}
 	get waitUntilPromises() {
@@ -691,18 +811,36 @@ function userAgent({ headers }) {
 *
 * Uses the platform's `waitUntil` (via the per-request ExecutionContext) when
 * available so the task survives past the response on Cloudflare Workers.
-* Falls back to a fire-and-forget microtask on runtimes without an execution
-* context (e.g. Node.js dev server).
+* Node.js dev drains callbacks from its response finish/close lifecycle.
 *
 * Throws when called inside a cached scope — request-specific
 * side-effects must not leak into cached results.
 */
 function after(task) {
 	_throwIfInsideCacheScope("after()");
-	const guarded = (typeof task === "function" ? Promise.resolve().then(task) : task).catch((err) => {
-		console.error("[vinext] after() task failed:", err);
-	});
-	getRequestExecutionContext()?.waitUntil(guarded);
+	const requestContext = isInsideUnifiedScope() ? getRequestContext() : null;
+	if (!requestContext) {
+		const executionContext = getRequestExecutionContext();
+		if (executionContext) {
+			if (typeof task !== "function" && (task == null || typeof task.then !== "function")) throw new TypeError("`after()`: Argument must be a promise or a function");
+			const promise = typeof task === "function" ? Promise.resolve().then(task) : task;
+			const guarded = Promise.resolve(promise).catch((error) => {
+				console.error("[vinext] after() task failed:", error);
+			});
+			executionContext.waitUntil(guarded);
+			return;
+		}
+		throw new Error("`after()` was called outside a request scope");
+	}
+	if (typeof task !== "function") {
+		if (task == null || typeof task.then !== "function") throw new TypeError("`after()`: Argument must be a promise or a function");
+		const guarded = Promise.resolve(task).catch((error) => {
+			console.error("[vinext] after() task failed:", error);
+		});
+		getRequestExecutionContext()?.waitUntil(guarded);
+		return;
+	}
+	queueAfterCallback(requestContext, bindRequestContextSnapshot(requestContext, task));
 }
 /**
 * connection() — signals that the response requires a live connection
@@ -727,4 +865,4 @@ const URLPattern = globalThis.URLPattern ?? (() => {
 	throw new Error("URLPattern is not available in this runtime. Install the `urlpattern-polyfill` package or upgrade to Node 20+.");
 });
 //#endregion
-export { NextFetchEvent, NextRequest, NextResponse, NextURL, RequestCookies, ResponseCookies, URLPattern, after, connection, sealRequestCookies, sealRequestHeaders, userAgent, userAgentFromString };
+export { ImageResponse, NextFetchEvent, NextRequest, NextResponse, NextURL, RequestCookies, ResponseCookies, URLPattern, after, connection, sealRequestCookies, sealRequestHeaders, userAgent, userAgentFromString };

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

@@ -1,5 +1,5 @@
-import { RootParamsState } from "./root-params.js";
 import { CacheState } from "./cache-request-state.js";
+import { RootParamsState } from "./root-params.js";
 import { ExecutionContextLike } from "./request-context.js";
 import { FetchCacheState } from "./fetch-cache.js";
 import { VinextHeadersShimState } from "./headers.js";
@@ -18,13 +18,32 @@ import { NavigationState } from "./navigation-state.js";
  */
 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>;
+  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;
+  completion: Promise<void> | null;
+  resolveCompletion: (() => void) | null;
+};
 /**
  * Create a fresh `UnifiedRequestContext` with defaults for all fields.
  * Pass partial overrides for the fields you need to pre-populate.
  */
 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;
+/** Bind a callback to every AsyncLocalStorage context active at registration. */
+declare function bindRequestContextSnapshot<T>(ctx: UnifiedRequestContext, callback: () => T): () => T;
+/**
+ * Release function-form `after()` work once the response body has closed.
+ * 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. */
+declare function closeAfterResponseWithBody(response: Response, ctx: UnifiedRequestContext): Response;
 /**
  * Run `fn` within a unified request context scope.
  * All shim modules will read/write their state from `ctx` for the
@@ -65,4 +84,4 @@ declare function getRequestContext(): UnifiedRequestContext;
  */
 declare function isInsideUnifiedScope(): boolean;
 //#endregion
-export { UnifiedRequestContext, createRequestContext, getRequestContext, isInsideUnifiedScope, runWithRequestContext, runWithUnifiedStateMutation };
+export { AfterRequestContext, UnifiedRequestContext, bindRequestContextSnapshot, closeAfterResponse, closeAfterResponseWithBody, createRequestContext, getRequestContext, isInsideUnifiedScope, queueAfterCallback, runWithRequestContext, runWithUnifiedStateMutation };

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

@@ -16,6 +16,8 @@ function createRequestContext(opts) {
 	return {
 		headersContext: null,
 		actionRevalidationKind: 0,
+		pendingRevalidatedTags: /* @__PURE__ */ new Set(),
+		pendingRevalidations: /* @__PURE__ */ new Set(),
 		dynamicUsageDetected: false,
 		renderRequestApiUsage: /* @__PURE__ */ new Set(),
 		connectionProbe: null,
@@ -41,6 +43,13 @@ function createRequestContext(opts) {
 		currentFetchDedupeEntries: /* @__PURE__ */ new Map(),
 		executionContext: _getInheritedExecutionContext(),
 		requestCache: /* @__PURE__ */ new WeakMap(),
+		afterContext: {
+			callbacks: [],
+			responseClosed: false,
+			pendingCallbacks: 0,
+			completion: null,
+			resolveCompletion: null
+		},
 		ssrContext: null,
 		ssrHeadChildren: [],
 		documentInitialHead: [],
@@ -48,6 +57,80 @@ function createRequestContext(opts) {
 		...opts
 	};
 }
+function ensureAfterCompletion(ctx) {
+	const state = ctx.afterContext;
+	if (state.resolveCompletion && state.completion) return;
+	let resolveCompletion;
+	const completion = new Promise((resolve) => {
+		resolveCompletion = resolve;
+	});
+	state.completion = completion;
+	state.resolveCompletion = resolveCompletion;
+	ctx.executionContext?.waitUntil(completion);
+}
+function finishAfterCallbacksIfIdle(ctx) {
+	const state = ctx.afterContext;
+	if (!state.responseClosed || state.pendingCallbacks !== 0 || state.callbacks.length !== 0 || !state.resolveCompletion) return;
+	const resolveCompletion = state.resolveCompletion;
+	state.resolveCompletion = null;
+	resolveCompletion();
+}
+function startAfterCallback(ctx, callback) {
+	const state = ctx.afterContext;
+	ensureAfterCompletion(ctx);
+	state.pendingCallbacks += 1;
+	Promise.resolve().then(callback).catch((error) => {
+		console.error("[vinext] after() task failed:", error);
+	}).finally(() => {
+		state.pendingCallbacks -= 1;
+		finishAfterCallbacksIfIdle(ctx);
+	});
+}
+/** Queue a callback until response close, or start it immediately once closed. */
+function queueAfterCallback(ctx, callback) {
+	ensureAfterCompletion(ctx);
+	if (ctx.afterContext.responseClosed) startAfterCallback(ctx, callback);
+	else ctx.afterContext.callbacks.push(callback);
+}
+/** Bind a callback to every AsyncLocalStorage context active at registration. */
+function bindRequestContextSnapshot(ctx, callback) {
+	const constructor = _als.constructor;
+	try {
+		const runInSnapshot = constructor.snapshot?.();
+		if (runInSnapshot) return () => runInSnapshot(callback);
+	} catch {}
+	return () => _als.run(ctx, callback);
+}
+/**
+* Release function-form `after()` work once the response body has closed.
+* All queued callbacks start together, matching Next.js' unbounded PromiseQueue.
+*/
+async function closeAfterResponse(ctx) {
+	const state = ctx.afterContext;
+	if (!state.responseClosed) {
+		state.responseClosed = true;
+		const callbacks = state.callbacks.splice(0);
+		for (const callback of callbacks) startAfterCallback(ctx, callback);
+		finishAfterCallbacksIfIdle(ctx);
+	}
+	return state.completion ?? Promise.resolve();
+}
+/** Wrap a response so deferred callbacks start on stream completion or cancellation. */
+function closeAfterResponseWithBody(response, ctx) {
+	if (!response.body) {
+		queueMicrotask(() => void closeAfterResponse(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, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	});
+	wrapped.__vinextStreamedHtmlResponse = response.__vinextStreamedHtmlResponse;
+	return wrapped;
+}
 function runWithRequestContext(ctx, fn) {
 	return _als.run(ctx, fn);
 }
@@ -84,4 +167,4 @@ function isInsideUnifiedScope() {
 	return _als.getStore() != null;
 }
 //#endregion
-export { createRequestContext, getRequestContext, isInsideUnifiedScope, runWithRequestContext, runWithUnifiedStateMutation };
+export { bindRequestContextSnapshot, closeAfterResponse, closeAfterResponseWithBody, createRequestContext, getRequestContext, isInsideUnifiedScope, queueAfterCallback, runWithRequestContext, runWithUnifiedStateMutation };