vinext 0.1.0 → 0.1.2

package/dist/server/otel-tracer-extension.js

@@ -0,0 +1,89 @@
+import { workUnitAsyncStorage } from "../shims/internal/work-unit-async-storage.js";
+//#region src/server/otel-tracer-extension.ts
+/**
+* OpenTelemetry tracer provider extension for Cache Components.
+*
+* When `cacheComponents: true` is enabled in next.config, component renders
+* go through multiple phases (warmup → resume). During these phases, the
+* `workUnitAsyncStorage` carries a prerender or cache store. Without this
+* extension, calls to `tracer.startSpan()` / `tracer.startActiveSpan()` from
+* inside user RSC code would inherit that prerender context, causing:
+*
+*  1. Spans to reuse the same trace ID across requests (the frozen prerender
+*     context bleeds into the runtime resume render).
+*  2. Spans not being created at all during fallback resume (the work unit
+*     context gates span creation in some OTel SDK implementations).
+*
+* The fix mirrors Next.js's `instrumentation-node-extensions.ts`:
+*  - Wrap `tracer.startSpan` to exit `workUnitAsyncStorage` before creating
+*    the span, ensuring a clean context for span ID generation.
+*  - Wrap `tracer.startActiveSpan` similarly and re-enter the work unit store
+*    for the callback, so that the callback runs with the correct request
+*    context restored.
+*
+* This extension is intentionally a no-op when:
+*  - `@opentelemetry/api` is not installed (graceful degradation).
+*  - No OTel tracer provider has been registered (provider is the noop provider).
+*  - `workUnitAsyncStorage` has no active store (non-render contexts).
+*
+* References:
+*  - packages/next/src/server/lib/router-utils/instrumentation-node-extensions.ts
+*  - https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-utils/instrumentation-node-extensions.ts
+*/
+const extendedProviders = /* @__PURE__ */ new WeakSet();
+const USE_CACHE_FUNCTION_SYMBOL = Symbol.for("vinext.useCacheFunction");
+function isUseCacheFn(fn) {
+	return typeof fn === "function" && fn[USE_CACHE_FUNCTION_SYMBOL] === true;
+}
+/**
+* Extend the registered OTel tracer provider so that `startSpan` and
+* `startActiveSpan` exit the `workUnitAsyncStorage` context before creating
+* spans. This prevents the prerender/cache work unit store from leaking into
+* span ID generation during Cache Component fallback resumes.
+*
+* Safe to call multiple times — subsequent calls are no-ops once the provider
+* has been wrapped.
+*
+* Must only be called in Node.js environments (not Edge runtime).
+*/
+function extendTracerProviderForCacheComponents() {
+	let api;
+	try {
+		const req = globalThis.require;
+		if (typeof req === "function") api = req("@opentelemetry/api");
+	} catch {
+		return;
+	}
+	if (!api) return;
+	const provider = api.trace.getTracerProvider();
+	if (!provider || typeof provider.getTracer !== "function") return;
+	if (extendedProviders.has(provider)) return;
+	extendedProviders.add(provider);
+	const originalGetTracer = provider.getTracer.bind(provider);
+	const wrappedTracers = /* @__PURE__ */ new WeakSet();
+	provider.getTracer = (...args) => {
+		const tracer = originalGetTracer(...args);
+		if (!tracer || wrappedTracers.has(tracer)) return tracer;
+		const originalStartSpan = tracer.startSpan;
+		if (typeof originalStartSpan === "function") tracer.startSpan = (...startSpanArgs) => workUnitAsyncStorage.exit(() => originalStartSpan.apply(tracer, startSpanArgs));
+		const originalStartActiveSpan = tracer.startActiveSpan;
+		if (typeof originalStartActiveSpan === "function") tracer.startActiveSpan = (...startActiveSpanArgs) => {
+			const workUnitStore = workUnitAsyncStorage.getStore();
+			if (!workUnitStore) return originalStartActiveSpan.apply(tracer, startActiveSpanArgs);
+			let fnIdx = 0;
+			if (startActiveSpanArgs.length === 2 && typeof startActiveSpanArgs[1] === "function") fnIdx = 1;
+			else if (startActiveSpanArgs.length === 3 && typeof startActiveSpanArgs[2] === "function") fnIdx = 2;
+			else if (startActiveSpanArgs.length > 3 && typeof startActiveSpanArgs[3] === "function") fnIdx = 3;
+			if (fnIdx > 0) {
+				const originalFn = startActiveSpanArgs[fnIdx];
+				if (isUseCacheFn(originalFn)) console.error("A Cache Function (`use cache`) was passed to startActiveSpan which means it will receive a Span argument with a possibly random ID on every invocation leading to cache misses. Provide a wrapping function around the Cache Function that does not forward the Span argument to avoid this issue.");
+				startActiveSpanArgs[fnIdx] = (...cbArgs) => workUnitAsyncStorage.run(workUnitStore, originalFn, ...cbArgs);
+			}
+			return workUnitAsyncStorage.exit(() => originalStartActiveSpan.apply(tracer, startActiveSpanArgs));
+		};
+		wrappedTracers.add(tracer);
+		return tracer;
+	};
+}
+//#endregion
+export { extendTracerProviderForCacheComponents };

package/dist/server/pages-api-route.d.ts

@@ -12,8 +12,7 @@ type PagesApiRouteConfig = {
    * `bodyParser: false` is critical for webhook handlers (Stripe, GitHub,
    * Slack, etc.) that need to read the raw bytes to verify an HMAC
    * signature. With it set, `req.body` is left undefined and the raw stream
-   * is exposed on `req.body` as a Web `ReadableStream<Uint8Array>` so user
-   * code can consume it.
+   * remains available through the Node-readable request object.
    *
    * @see https://nextjs.org/docs/pages/building-your-application/routing/api-routes#custom-config
    */
@@ -22,9 +21,21 @@ type PagesApiRouteConfig = {
       sizeLimit?: string | number;
     };
     responseLimit?: boolean | string | number;
+    /**
+     * `externalResolver: true` declares that the response is sent by an
+     * external resolver (e.g. express/connect proxy middleware) that may
+     * complete after the handler's promise settles. Next.js uses it to
+     * suppress the "API resolved without sending a response" dev warning;
+     * vinext additionally uses it to suppress the auto-`end()` safety net,
+     * which would otherwise resolve an empty response before the external
+     * resolver writes.
+     *
+     * @see https://nextjs.org/docs/pages/building-your-application/routing/api-routes#custom-config
+     */
+    externalResolver?: boolean;
   };
 };
-type PagesNodeApiRouteHandler = (req: PagesReqResRequest, res: PagesReqResResponse) => void | Promise<void>;
+type PagesNodeApiRouteHandler = (req: PagesReqResRequest, res: PagesReqResResponse) => unknown;
 type PagesEdgeApiRouteHandler = (request: Request) => Response | Promise<Response>;
 type PagesApiRouteModule = {
   /**

package/dist/server/pages-api-route.js

@@ -43,8 +43,13 @@ async function _handlePagesApiRoute(options) {
 			request: options.request,
 			url: options.url
 		});
+		let resWasPiped = false;
+		res.once("pipe", () => {
+			resWasPiped = true;
+		});
+		const externalResolver = route.module.config?.api?.externalResolver || false;
 		await route.module.default(req, res);
-		res.end();
+		if (!externalResolver && !resWasPiped && !res.headersSent) res.end();
 		return await responsePromise;
 	} catch (error) {
 		if (error instanceof PagesBodyParseError) return new Response(error.message, {

package/dist/server/pages-asset-tags.d.ts

@@ -23,11 +23,14 @@ declare function resolveSsrManifest(manifest: Record<string, string[]> | null |
  */
 declare function getManifestFilesForModule(manifest: Record<string, string[]> | null | undefined, moduleId: string | null | undefined): string[] | null;
 /**
- * Find the first `.js` file in the manifest for `moduleId` and return its
- * URL-path form (with a leading `/`). Used to resolve the hydration URL for
- * the matched page or the `_app` module.
+ * Find the first `.js` file in the manifest for `moduleId` and return the URL it
+ * is actually SERVED from. Used to resolve the client-navigation / hydration URL
+ * for the matched page or the `_app` module (it is `import()`ed on the client),
+ * so it must point at the served location: `assetPrefix` replaces `basePath` for
+ * asset URLs. SSR-manifest values are base-anchored; re-anchor under any
+ * configured `assetPrefix` (default `""` keeps the legacy `"/" + file`).
  */
-declare function resolveClientModuleUrl(manifest: Record<string, string[]> | null | undefined, moduleId: string | null | undefined): string | undefined;
+declare function resolveClientModuleUrl(manifest: Record<string, string[]> | null | undefined, moduleId: string | null | undefined, basePath?: string, assetPrefix?: string): string | undefined;
 type CollectAssetTagsOptions = {
   /**
    * SSR manifest mapping module file paths to their associated asset list.
@@ -46,6 +49,14 @@ type CollectAssetTagsOptions = {
    * default.
    */
   disableOptimizedLoading: boolean;
+  /**
+   * Configured `basePath` / `assetPrefix`. SSR-manifest values are base-anchored
+   * (needed for the lazy-chunk membership test), but the EMITTED href must point
+   * where the asset is actually served — `assetPrefix` replaces `basePath` for
+   * asset URLs. Default `""` (both unset) keeps the legacy `"/" + value` href.
+   */
+  basePath?: string;
+  assetPrefix?: string;
 };
 /**
  * Build the HTML `<link>` and `<script>` tag string for the SSR response.

package/dist/server/pages-asset-tags.js

@@ -1,4 +1,5 @@
 import { createNonceAttribute } from "./html.js";
+import { assetServingUrlFromBaseAnchored } from "../utils/manifest-paths.js";
 //#region src/server/pages-asset-tags.ts
 /**
 * Pages Router SSR asset-tag helpers.
@@ -33,18 +34,20 @@ function getManifestFilesForModule(manifest, moduleId) {
 	return null;
 }
 /**
-* Find the first `.js` file in the manifest for `moduleId` and return its
-* URL-path form (with a leading `/`). Used to resolve the hydration URL for
-* the matched page or the `_app` module.
+* Find the first `.js` file in the manifest for `moduleId` and return the URL it
+* is actually SERVED from. Used to resolve the client-navigation / hydration URL
+* for the matched page or the `_app` module (it is `import()`ed on the client),
+* so it must point at the served location: `assetPrefix` replaces `basePath` for
+* asset URLs. SSR-manifest values are base-anchored; re-anchor under any
+* configured `assetPrefix` (default `""` keeps the legacy `"/" + file`).
 */
-function resolveClientModuleUrl(manifest, moduleId) {
+function resolveClientModuleUrl(manifest, moduleId, basePath = "", assetPrefix = "") {
 	const files = getManifestFilesForModule(resolveSsrManifest(manifest), moduleId);
 	if (!files) return void 0;
 	for (let i = 0; i < files.length; i++) {
-		let file = files[i];
+		const file = files[i];
 		if (!file || !file.endsWith(".js")) continue;
-		if (file.charAt(0) !== "/") file = "/" + file;
-		return file;
+		return assetServingUrlFromBaseAnchored(file, basePath, assetPrefix);
 	}
 }
 /**
@@ -67,13 +70,16 @@ function collectAssetTags(options) {
 	const seen = /* @__PURE__ */ new Set();
 	const nonceAttr = createNonceAttribute(options.scriptNonce);
 	const deferAttr = options.disableOptimizedLoading ? "" : " defer";
+	const basePath = options.basePath ?? "";
+	const assetPrefix = options.assetPrefix ?? "";
+	const href = (value) => assetServingUrlFromBaseAnchored(value, basePath, assetPrefix);
 	const lazyChunks = typeof globalThis !== "undefined" && globalThis.__VINEXT_LAZY_CHUNKS__ || null;
 	const lazySet = lazyChunks && lazyChunks.length > 0 ? new Set(lazyChunks) : null;
 	if (typeof globalThis !== "undefined" && globalThis.__VINEXT_CLIENT_ENTRY__) {
 		const entry = globalThis.__VINEXT_CLIENT_ENTRY__;
 		seen.add(entry);
-		tags.push("<link rel=\"modulepreload\"" + nonceAttr + " href=\"/" + entry + "\" />");
-		tags.push("<script type=\"module\"" + deferAttr + nonceAttr + " src=\"/" + entry + "\" crossorigin><\/script>");
+		tags.push("<link rel=\"modulepreload\"" + nonceAttr + " href=\"" + href(entry) + "\" />");
+		tags.push("<script type=\"module\"" + deferAttr + nonceAttr + " src=\"" + href(entry) + "\" crossorigin><\/script>");
 	}
 	if (m) {
 		const allFiles = [];
@@ -102,11 +108,11 @@ function collectAssetTags(options) {
 			if (tf.charAt(0) === "/") tf = tf.slice(1);
 			if (seen.has(tf)) continue;
 			seen.add(tf);
-			if (tf.endsWith(".css")) tags.push("<link rel=\"stylesheet\"" + nonceAttr + " href=\"/" + tf + "\" />");
+			if (tf.endsWith(".css")) tags.push("<link rel=\"stylesheet\"" + nonceAttr + " href=\"" + href(tf) + "\" />");
 			else if (tf.endsWith(".js")) {
 				if (lazySet && lazySet.has(tf)) continue;
-				tags.push("<link rel=\"modulepreload\"" + nonceAttr + " href=\"/" + tf + "\" />");
-				tags.push("<script type=\"module\"" + deferAttr + nonceAttr + " src=\"/" + tf + "\" crossorigin><\/script>");
+				tags.push("<link rel=\"modulepreload\"" + nonceAttr + " href=\"" + href(tf) + "\" />");
+				tags.push("<script type=\"module\"" + deferAttr + nonceAttr + " src=\"" + href(tf) + "\" crossorigin><\/script>");
 			}
 		}
 	}

package/dist/server/pages-data-route.js

@@ -1,3 +1,4 @@
+import { NEXTJS_DEPLOYMENT_ID_HEADER } from "./headers.js";
 //#region src/server/pages-data-route.ts
 /**
 * Helpers for the Pages Router `/_next/data/{buildId}/{...page}.json` endpoint.
@@ -87,9 +88,12 @@ function buildNextDataJsonResponse(pageProps, safeJsonStringify, init) {
 * before checking the status code.
 */
 function buildNextDataNotFoundResponse() {
+	const headers = { "Content-Type": "application/json" };
+	const deploymentId = process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID;
+	if (deploymentId) headers[NEXTJS_DEPLOYMENT_ID_HEADER] = deploymentId;
 	return new Response("{}", {
 		status: 404,
-		headers: { "Content-Type": "application/json" }
+		headers
 	});
 }
 /**

package/dist/server/pages-node-compat.d.ts

@@ -1,38 +1,32 @@
 import { PagesBodyParseError } from "./pages-media-type.js";
+import { RevalidateOptions } from "./pages-revalidate.js";
+import { Readable, Writable } from "node:stream";
 
 //#region src/server/pages-node-compat.d.ts
 type PagesRequestQuery = Record<string, string | string[]>;
-type PagesReqResRequest = {
+type PagesReqResRequest = Readable & {
   method: string;
   url: string;
   headers: Record<string, string>;
   query: PagesRequestQuery;
   body: unknown;
   cookies: Record<string, string>;
-  /**
-   * Async-iterator hook so handlers can `for await (const chunk of req)` —
-   * matching Node's `IncomingMessage` contract. Critical for the
-   * `bodyParser: false` opt-out (webhook signature verification etc.) where
-   * `req.body` is left undefined and user code is expected to drain the raw
-   * stream off `req` itself.
-   */
-  [Symbol.asyncIterator]: () => AsyncIterator<Uint8Array>;
 };
 type PagesReqResHeaders = {
   [key: string]: string | number | boolean | string[];
 };
-type PagesReqResResponse = {
+type PagesReqResResponse = Writable & {
   statusCode: number;
   readonly headersSent: boolean;
   writeHead: (code: number, headers?: PagesReqResHeaders) => PagesReqResResponse;
   setHeader: (name: string, value: string | number | boolean | string[]) => PagesReqResResponse;
   getHeader: (name: string) => string | number | boolean | string[] | undefined;
-  end: (data?: BodyInit | null) => void;
   status: (code: number) => PagesReqResResponse;
   json: (data: unknown) => void;
   send: (data: unknown) => void;
   redirect: (statusOrUrl: number | string, url?: string) => void;
   getHeaders: () => PagesReqResHeaders;
+  revalidate: (urlPath: string, opts?: RevalidateOptions) => Promise<void>;
 };
 type CreatePagesReqResOptions = {
   body: unknown;

package/dist/server/pages-node-compat.js

@@ -2,7 +2,9 @@ import { parseCookies } from "../config/config-matchers.js";
 import { readStreamAsTextWithLimit } from "../utils/text-stream.js";
 import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-media-type.js";
 import { DEFAULT_PAGES_API_BODY_SIZE_LIMIT } from "./pages-body-parser-config.js";
+import { performOnDemandRevalidate } from "./pages-revalidate.js";
 import { decode } from "node:querystring";
+import { Readable, Writable } from "node:stream";
 //#region src/server/pages-node-compat.ts
 const MAX_PAGES_API_BODY_SIZE = DEFAULT_PAGES_API_BODY_SIZE_LIMIT;
 async function readPagesRequestBodyWithLimit(request, maxBytes) {
@@ -40,137 +42,192 @@ async function parsePagesApiBody(request, maxBytes = MAX_PAGES_API_BODY_SIZE) {
 	if (mediaType === "application/x-www-form-urlencoded") return decode(rawBody);
 	return rawBody;
 }
+async function* requestBodyChunks(request) {
+	if (!request.body || request.bodyUsed) return;
+	const reader = request.body.getReader();
+	try {
+		for (;;) {
+			const { value, done } = await reader.read();
+			if (done) return;
+			yield Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+		}
+	} finally {
+		try {
+			await reader.cancel();
+		} catch {}
+		reader.releaseLock();
+	}
+}
+function createRequestReadable(request) {
+	return Readable.from(requestBodyChunks(request), { objectMode: false });
+}
+var PagesResponseStream = class extends Writable {
+	resolveResponse;
+	rejectResponse;
+	requestHeaders;
+	resStatusCode = 200;
+	resHeaders = {};
+	setCookieHeaders = [];
+	resolved = false;
+	controller = null;
+	bufferedChunks = [];
+	streamEnded = false;
+	constructor(resolveResponse, rejectResponse, requestHeaders) {
+		super();
+		this.resolveResponse = resolveResponse;
+		this.rejectResponse = rejectResponse;
+		this.requestHeaders = requestHeaders;
+		this.once("error", (err) => {
+			if (!this.resolved) {
+				this.resolved = true;
+				this.rejectResponse(err);
+			}
+		});
+	}
+	get statusCode() {
+		return this.resStatusCode;
+	}
+	set statusCode(code) {
+		this.resStatusCode = code;
+	}
+	get headersSent() {
+		return this.writableEnded || this.resolved;
+	}
+	writeHead(code, headers) {
+		this.resStatusCode = code;
+		if (headers) for (const [key, value] of Object.entries(headers)) this.setHeaderValue(key, value, { replaceSetCookie: false });
+		return this;
+	}
+	setHeader(name, value) {
+		this.setHeaderValue(name, value, { replaceSetCookie: true });
+		return this;
+	}
+	getHeader(name) {
+		if (name.toLowerCase() === "set-cookie") return this.setCookieHeaders.length > 0 ? this.setCookieHeaders : void 0;
+		return this.resHeaders[name.toLowerCase()];
+	}
+	status(code) {
+		this.resStatusCode = code;
+		return this;
+	}
+	json(data) {
+		this.resHeaders["content-type"] = "application/json";
+		this.end(JSON.stringify(data));
+	}
+	send(data) {
+		if (Buffer.isBuffer(data)) {
+			if (!this.resHeaders["content-type"]) this.resHeaders["content-type"] = "application/octet-stream";
+			this.resHeaders["content-length"] = String(data.length);
+			this.end(data);
+			return;
+		}
+		if (typeof data === "object" && data !== null) {
+			this.resHeaders["content-type"] = "application/json";
+			this.end(JSON.stringify(data));
+			return;
+		}
+		if (!this.resHeaders["content-type"]) this.resHeaders["content-type"] = "text/plain";
+		this.end(String(data));
+	}
+	redirect(statusOrUrl, url) {
+		if (typeof statusOrUrl === "string") this.writeHead(307, { Location: statusOrUrl });
+		else this.writeHead(statusOrUrl, { Location: url ?? "" });
+		this.end();
+	}
+	getHeaders() {
+		const headers = { ...this.resHeaders };
+		if (this.setCookieHeaders.length > 0) headers["set-cookie"] = this.setCookieHeaders;
+		return headers;
+	}
+	async revalidate(urlPath, opts) {
+		await performOnDemandRevalidate(this.requestHeaders, urlPath, opts);
+	}
+	_write(chunk, encoding, callback) {
+		const buffer = typeof chunk === "string" ? Buffer.from(chunk, encoding) : Buffer.from(chunk);
+		if (this.controller && !this.streamEnded) try {
+			this.controller.enqueue(buffer);
+		} catch {}
+		else this.bufferedChunks.push(buffer);
+		this.resolveOnce();
+		callback();
+	}
+	_final(callback) {
+		this.streamEnded = true;
+		if (this.controller) try {
+			this.controller.close();
+		} catch {}
+		this.resolveOnce();
+		callback();
+	}
+	_destroy(error, callback) {
+		this.streamEnded = true;
+		if (!this.resolved) if (error) {
+			this.resolved = true;
+			this.rejectResponse(error);
+		} else this.resolveOnce();
+		if (this.controller) try {
+			if (error) this.controller.error(error);
+			else this.controller.close();
+		} catch {}
+		callback(error);
+	}
+	setHeaderValue(name, value, options) {
+		if (name.toLowerCase() === "set-cookie") {
+			if (options.replaceSetCookie) this.setCookieHeaders.length = 0;
+			if (Array.isArray(value)) this.setCookieHeaders.push(...value.map(String));
+			else this.setCookieHeaders.push(String(value));
+			return;
+		}
+		this.resHeaders[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+	}
+	resolveOnce() {
+		if (this.resolved) return;
+		this.resolved = true;
+		const headers = new Headers();
+		for (const [key, value] of Object.entries(this.resHeaders)) headers.set(key, String(value));
+		for (const cookie of this.setCookieHeaders) headers.append("set-cookie", cookie);
+		const stream = new ReadableStream({
+			start: (controller) => {
+				this.controller = controller;
+				for (const buffer of this.bufferedChunks) try {
+					controller.enqueue(buffer);
+				} catch {}
+				this.bufferedChunks.length = 0;
+				if (this.streamEnded) try {
+					controller.close();
+				} catch {}
+			},
+			cancel: (reason) => {
+				this.bufferedChunks.length = 0;
+				this.destroy(reason instanceof Error ? reason : /* @__PURE__ */ new Error("Response body cancelled"));
+			}
+		});
+		this.resolveResponse(new Response(stream, {
+			status: this.resStatusCode,
+			headers
+		}));
+	}
+};
 function createPagesReqRes(options) {
 	const headersObj = {};
 	for (const [key, value] of options.request.headers) headersObj[key.toLowerCase()] = value;
-	const requestBody = options.request.body;
-	const reqAsyncIterator = () => {
-		if (!requestBody) return { next() {
-			return Promise.resolve({
-				value: void 0,
-				done: true
-			});
-		} };
-		const reader = requestBody.getReader();
-		return {
-			async next() {
-				const { value, done } = await reader.read();
-				if (done) return {
-					value: void 0,
-					done: true
-				};
-				return {
-					value,
-					done: false
-				};
-			},
-			async return() {
-				try {
-					await reader.cancel();
-				} catch {}
-				return {
-					value: void 0,
-					done: true
-				};
-			}
-		};
-	};
-	const req = {
+	const req = Object.assign(createRequestReadable(options.request), {
 		method: options.request.method,
 		url: options.url,
 		headers: headersObj,
 		query: options.query,
 		body: options.body,
-		cookies: parseCookies(options.request.headers.get("cookie")),
-		[Symbol.asyncIterator]: reqAsyncIterator
-	};
-	let resStatusCode = 200;
-	const resHeaders = {};
-	const setCookieHeaders = [];
-	let resBody = null;
-	let ended = false;
+		cookies: parseCookies(options.request.headers.get("cookie"))
+	});
 	let resolveResponse;
-	const responsePromise = new Promise((resolve) => {
+	let rejectResponse;
+	const responsePromise = new Promise((resolve, reject) => {
 		resolveResponse = resolve;
+		rejectResponse = reject;
 	});
-	const res = {
-		get statusCode() {
-			return resStatusCode;
-		},
-		set statusCode(code) {
-			resStatusCode = code;
-		},
-		get headersSent() {
-			return ended;
-		},
-		writeHead(code, headers) {
-			resStatusCode = code;
-			if (headers) for (const [key, value] of Object.entries(headers)) if (key.toLowerCase() === "set-cookie") if (Array.isArray(value)) setCookieHeaders.push(...value.map(String));
-			else setCookieHeaders.push(String(value));
-			else resHeaders[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
-			return res;
-		},
-		setHeader(name, value) {
-			if (name.toLowerCase() === "set-cookie") {
-				setCookieHeaders.length = 0;
-				if (Array.isArray(value)) setCookieHeaders.push(...value.map(String));
-				else setCookieHeaders.push(String(value));
-			} else resHeaders[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
-			return res;
-		},
-		getHeader(name) {
-			if (name.toLowerCase() === "set-cookie") return setCookieHeaders.length > 0 ? setCookieHeaders : void 0;
-			return resHeaders[name.toLowerCase()];
-		},
-		end(data) {
-			if (ended) return;
-			ended = true;
-			if (data !== void 0 && data !== null) resBody = data;
-			const headers = new Headers();
-			for (const [key, value] of Object.entries(resHeaders)) headers.set(key, String(value));
-			for (const cookie of setCookieHeaders) headers.append("set-cookie", cookie);
-			resolveResponse(new Response(resBody, {
-				status: resStatusCode,
-				headers
-			}));
-		},
-		status(code) {
-			resStatusCode = code;
-			return res;
-		},
-		json(data) {
-			resHeaders["content-type"] = "application/json";
-			res.end(JSON.stringify(data));
-		},
-		send(data) {
-			if (Buffer.isBuffer(data)) {
-				if (!resHeaders["content-type"]) resHeaders["content-type"] = "application/octet-stream";
-				resHeaders["content-length"] = String(data.length);
-				res.end(new Uint8Array(data));
-				return;
-			}
-			if (typeof data === "object" && data !== null) {
-				resHeaders["content-type"] = "application/json";
-				res.end(JSON.stringify(data));
-				return;
-			}
-			if (!resHeaders["content-type"]) resHeaders["content-type"] = "text/plain";
-			res.end(String(data));
-		},
-		redirect(statusOrUrl, url) {
-			if (typeof statusOrUrl === "string") res.writeHead(307, { Location: statusOrUrl });
-			else res.writeHead(statusOrUrl, { Location: url ?? "" });
-			res.end();
-		},
-		getHeaders() {
-			const headers = { ...resHeaders };
-			if (setCookieHeaders.length > 0) headers["set-cookie"] = setCookieHeaders;
-			return headers;
-		}
-	};
 	return {
 		req,
-		res,
+		res: new PagesResponseStream(resolveResponse, rejectResponse, options.request.headers),
 		responsePromise
 	};
 }