vinext 0.1.1 → 0.1.3

package/dist/server/normalize-path.d.ts

@@ -1,12 +1,4 @@
 //#region src/server/normalize-path.d.ts
-/**
- * Re-encode path delimiter characters that were decoded by decodeURIComponent.
- * After decoding a URL segment, characters like / # ? \ need to be re-encoded
- * so they don't change the path structure.
- *
- * Ported from Next.js: packages/next/src/shared/lib/router/utils/escape-path-delimiters.ts
- * https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/router/utils/escape-path-delimiters.ts
- */
 declare function escapePathDelimiters(segment: string, escapeEncoded?: boolean): string;
 /**
  * Decode a URL pathname segment-by-segment, preserving encoded path delimiters.

package/dist/server/normalize-path.js

@@ -7,8 +7,10 @@
 * Ported from Next.js: packages/next/src/shared/lib/router/utils/escape-path-delimiters.ts
 * https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/router/utils/escape-path-delimiters.ts
 */
+const PATH_DELIMITERS_RE = /([/#?])/gi;
+const PATH_DELIMITERS_ENCODED_RE = /([/#?]|%(2f|23|3f|5c))/gi;
 function escapePathDelimiters(segment, escapeEncoded) {
-	return segment.replace(new RegExp(`([/#?]${escapeEncoded ? "|%(2f|23|3f|5c)" : ""})`, "gi"), (char) => encodeURIComponent(char));
+	return segment.replace(escapeEncoded ? PATH_DELIMITERS_ENCODED_RE : PATH_DELIMITERS_RE, (char) => encodeURIComponent(char));
 }
 /**
 * Decode a URL pathname segment-by-segment, preserving encoded path delimiters.

package/dist/server/otel-tracer-extension.d.ts

@@ -0,0 +1,45 @@
+//#region src/server/otel-tracer-extension.d.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
+ */
+/**
+ * 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).
+ */
+declare function extendTracerProviderForCacheComponents(): void;
+//#endregion
+export { extendTracerProviderForCacheComponents };

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

@@ -1,3 +1,4 @@
+import { NextI18nConfig } from "../config/next-config.js";
 import { Route } from "../routing/pages-router.js";
 import { ExecutionContextLike } from "../shims/request-context.js";
 import { PagesReqResRequest, PagesReqResResponse, PagesRequestQuery } from "./pages-node-compat.js";
@@ -12,8 +13,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 +22,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 = {
   /**
@@ -60,6 +72,11 @@ type HandlePagesApiRouteOptions = {
   reportRequestError?: (error: Error, routePattern: string) => void | Promise<void>;
   request: Request;
   url: string;
+  nextConfig?: {
+    basePath?: string;
+    i18n?: NextI18nConfig | null;
+    trailingSlash?: boolean;
+  };
 };
 declare function handlePagesApiRoute(options: HandlePagesApiRouteOptions): Promise<Response>;
 //#endregion

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

@@ -2,7 +2,8 @@ import "./server-globals.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
 import { NextRequest } from "../shims/server.js";
 import { internalServerErrorResponse } from "./http-error-responses.js";
-import { mergeRouteParamsIntoQuery, parseQueryString } from "../utils/query.js";
+import { cloneRequestWithUrl } from "./request-pipeline.js";
+import { mergeRouteParamsIntoQuery, parseQueryString, urlQueryToSearchParams } from "../utils/query.js";
 import { PagesBodyParseError } from "./pages-media-type.js";
 import { isEdgeApiRuntime } from "./edge-api-runtime.js";
 import { resolveBodyParserConfig } from "./pages-body-parser-config.js";
@@ -14,6 +15,12 @@ function resolveModuleRuntime(module) {
 function buildPagesApiQuery(url, params) {
 	return mergeRouteParamsIntoQuery(parseQueryString(url), params);
 }
+function createEdgeApiRequest(request, url, params) {
+	const resolvedUrl = new URL(request.url);
+	resolvedUrl.search = urlQueryToSearchParams(buildPagesApiQuery(url, params)).toString();
+	const resolvedUrlString = resolvedUrl.toString();
+	return resolvedUrlString === request.url ? request : cloneRequestWithUrl(request, resolvedUrlString);
+}
 function isEdgeApiRouteModule(module) {
 	return typeof module.default === "function" && isEdgeApiRuntime(resolveModuleRuntime(module));
 }
@@ -29,7 +36,11 @@ async function _handlePagesApiRoute(options) {
 	const { route, params } = options.match;
 	try {
 		if (isEdgeApiRouteModule(route.module)) {
-			const nextRequest = new NextRequest(options.request);
+			const nextRequest = new NextRequest(createEdgeApiRequest(options.request, options.url, params), options.nextConfig ? { nextConfig: {
+				basePath: options.nextConfig.basePath,
+				i18n: options.nextConfig.i18n ?? void 0,
+				trailingSlash: options.nextConfig.trailingSlash
+			} } : void 0);
 			const response = await route.module.default(nextRequest);
 			if (response instanceof Response) return response;
 			throw new Error("Edge API route did not return a Response");
@@ -43,8 +54,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, _deploymentId?: string): string | undefined;
 type CollectAssetTagsOptions = {
   /**
    * SSR manifest mapping module file paths to their associated asset list.
@@ -46,6 +49,15 @@ 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;
+  deploymentId?: string;
 };
 /**
  * Build the HTML `<link>` and `<script>` tag string for the SSR response.

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

@@ -1,4 +1,6 @@
+import { appendDeploymentIdQuery } from "../utils/deployment-id.js";
 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 +35,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 = "", _deploymentId) {
 	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 +71,19 @@ 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) => {
+		const url = assetServingUrlFromBaseAnchored(value, basePath, assetPrefix);
+		return value.endsWith(".js") ? url : appendDeploymentIdQuery(url, options.deploymentId);
+	};
 	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 +112,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.d.ts

@@ -60,6 +60,13 @@ declare function parseNextDataPathname(pathname: string, buildId: string): NextD
  *   { pageProps: {...}, /* optional locale data, redirect markers, etc. *\/ }
  */
 declare function buildNextDataJsonResponse(pageProps: Record<string, unknown>, safeJsonStringify: (value: unknown) => string, init?: ResponseInit): Response;
+/**
+ * Build a `_next/data` JSON response from the full Pages props object returned
+ * through `_app.getInitialProps`. Next.js serializes the same outer props
+ * object that would be passed to `<App />`, so custom app-level props remain
+ * siblings of `pageProps` in the data envelope.
+ */
+declare function buildNextDataPropsJsonResponse(props: Record<string, unknown>, safeJsonStringify: (value: unknown) => string, init?: ResponseInit): Response;
 /**
  * Build the 404 response Next.js returns for an unknown `_next/data` page.
  * Next.js renders this as a normal 404 page, but the body shape that clients
@@ -111,4 +118,4 @@ type NormalizePagesDataRequestResult = {
  */
 declare function normalizePagesDataRequest(request: Request, buildId: string | null): NormalizePagesDataRequestResult;
 //#endregion
-export { buildNextDataJsonResponse, buildNextDataNotFoundResponse, isNextDataPathname, normalizePagesDataRequest, parseNextDataPathname };
+export { buildNextDataJsonResponse, buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, isNextDataPathname, normalizePagesDataRequest, parseNextDataPathname };

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.
@@ -65,7 +66,16 @@ function parseNextDataPathname(pathname, buildId) {
 *   { pageProps: {...}, /* optional locale data, redirect markers, etc. *\/ }
 */
 function buildNextDataJsonResponse(pageProps, safeJsonStringify, init) {
-	const body = safeJsonStringify({ pageProps });
+	return buildNextDataPropsJsonResponse({ pageProps }, safeJsonStringify, init);
+}
+/**
+* Build a `_next/data` JSON response from the full Pages props object returned
+* through `_app.getInitialProps`. Next.js serializes the same outer props
+* object that would be passed to `<App />`, so custom app-level props remain
+* siblings of `pageProps` in the data envelope.
+*/
+function buildNextDataPropsJsonResponse(props, safeJsonStringify, init) {
+	const body = safeJsonStringify(props);
 	return new Response(body, {
 		status: init?.status ?? 200,
 		statusText: init?.statusText,
@@ -87,9 +97,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
 	});
 }
 /**
@@ -138,4 +151,4 @@ function normalizePagesDataRequest(request, buildId) {
 	};
 }
 //#endregion
-export { buildNextDataJsonResponse, buildNextDataNotFoundResponse, isNextDataPathname, normalizePagesDataRequest, parseNextDataPathname };
+export { buildNextDataJsonResponse, buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, isNextDataPathname, normalizePagesDataRequest, parseNextDataPathname };

package/dist/server/pages-get-initial-props.d.ts

@@ -3,6 +3,48 @@ type PagesGetInitialPropsContext = {
   req?: unknown;
   res?: unknown;
   err?: unknown;
+  pathname?: string;
+  query?: Record<string, unknown>;
+  asPath?: string;
+  locale?: string;
+  locales?: string[];
+  defaultLocale?: string;
+} & Record<string, unknown>;
+declare function hasPagesGetInitialProps(component: unknown): boolean;
+declare function isResponseSent(res: unknown): boolean;
+declare function loadPagesGetInitialProps(component: unknown, context: PagesGetInitialPropsContext): Promise<Record<string, unknown> | null>;
+/**
+ * Decision returned by {@link loadDevAppInitialProps}.
+ *
+ * - `skip`: the custom `App` has no `getInitialProps`; the caller renders with
+ *   its existing props unchanged.
+ * - `response-sent`: `_app.getInitialProps` ended the response itself (wrote
+ *   headers / body); the caller must stop and not render.
+ * - `render`: the caller should render with the returned `pageProps` /
+ *   `renderProps`.
+ */
+type DevAppInitialPropsResult = {
+  kind: "skip";
+} | {
+  kind: "response-sent";
+} | {
+  kind: "render";
+  pageProps: Record<string, unknown>;
+  renderProps: Record<string, unknown> & {
+    pageProps: unknown;
+  };
+};
+type DevAppInitialPropsContext = {
+  appComponent: unknown;
+  /**
+   * Builds the `AppTree` element passed to `getInitialProps`. Injected so this
+   * module stays free of React; the dev SSR handler supplies the real
+   * `React.createElement` closure.
+   */
+  appTree: (appTreeProps: Record<string, unknown>) => unknown;
+  component: unknown;
+  req: unknown;
+  res: unknown;
   pathname: string;
   query: Record<string, unknown>;
   asPath: string;
@@ -10,8 +52,16 @@ type PagesGetInitialPropsContext = {
   locales?: string[];
   defaultLocale?: string;
 };
-declare function hasPagesGetInitialProps(component: unknown): boolean;
-declare function isResponseSent(res: unknown): boolean;
-declare function loadPagesGetInitialProps(component: unknown, context: PagesGetInitialPropsContext): Promise<Record<string, unknown> | null>;
+/**
+ * Run the custom `App`'s `getInitialProps` for the dev SSR render path and
+ * return a decision the caller applies.
+ *
+ * This is the dev-server counterpart to the production page-data resolver's
+ * app-initial-props loading. It is invoked lazily — only when a request is
+ * actually going to render (cache miss / on-demand revalidation), never on an
+ * ISR cache HIT/STALE that serves cached HTML verbatim — so userland `App`
+ * data code does not run on the cache hot path.
+ */
+declare function loadDevAppInitialProps(ctx: DevAppInitialPropsContext): Promise<DevAppInitialPropsResult>;
 //#endregion
-export { hasPagesGetInitialProps, isResponseSent, loadPagesGetInitialProps };
+export { DevAppInitialPropsContext, DevAppInitialPropsResult, hasPagesGetInitialProps, isResponseSent, loadDevAppInitialProps, loadPagesGetInitialProps };

package/dist/server/pages-get-initial-props.js

@@ -46,5 +46,47 @@ async function loadPagesGetInitialProps(component, context) {
 	if (!isPropsObject(result)) throw new Error(`"${getDisplayName(component)}.getInitialProps()" should resolve to an object. But found "${describeInitialPropsValue(result)}" instead.`);
 	return result;
 }
+/**
+* Run the custom `App`'s `getInitialProps` for the dev SSR render path and
+* return a decision the caller applies.
+*
+* This is the dev-server counterpart to the production page-data resolver's
+* app-initial-props loading. It is invoked lazily — only when a request is
+* actually going to render (cache miss / on-demand revalidation), never on an
+* ISR cache HIT/STALE that serves cached HTML verbatim — so userland `App`
+* data code does not run on the cache hot path.
+*/
+async function loadDevAppInitialProps(ctx) {
+	if (!hasPagesGetInitialProps(ctx.appComponent)) return { kind: "skip" };
+	const initialProps = await loadPagesGetInitialProps(ctx.appComponent, {
+		AppTree: ctx.appTree,
+		Component: ctx.component,
+		router: {
+			pathname: ctx.pathname,
+			query: ctx.query,
+			asPath: ctx.asPath
+		},
+		ctx: {
+			req: ctx.req,
+			res: ctx.res,
+			pathname: ctx.pathname,
+			query: ctx.query,
+			asPath: ctx.asPath,
+			locale: ctx.locale,
+			locales: ctx.locales,
+			defaultLocale: ctx.defaultLocale
+		}
+	});
+	if (isResponseSent(ctx.res)) return { kind: "response-sent" };
+	const initialPageProps = isPropsObject(initialProps) ? initialProps.pageProps : void 0;
+	return {
+		kind: "render",
+		pageProps: isPropsObject(initialPageProps) ? initialPageProps : {},
+		renderProps: isPropsObject(initialProps) ? {
+			...initialProps,
+			pageProps: initialPageProps
+		} : { pageProps: initialPageProps }
+	};
+}
 //#endregion
-export { hasPagesGetInitialProps, isResponseSent, loadPagesGetInitialProps };
+export { hasPagesGetInitialProps, isResponseSent, loadDevAppInitialProps, loadPagesGetInitialProps };

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

@@ -1,34 +1,26 @@
 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;