vinext 1.0.0-beta.8 → 1.0.0

package/dist/server/http-range.d.ts

@@ -1,5 +1,5 @@
 //#region src/server/http-range.d.ts
-type ByteRange = {
+export type ByteRange = {
   kind: "ignore";
 } | {
   kind: "unsatisfiable";
@@ -12,7 +12,7 @@ type ByteRange = {
  * Parse a single bytes range. Unsupported range units, malformed values, and
  * multipart ranges are ignored, which RFC 9110 permits servers to do.
  */
-declare function parseByteRange(value: string | undefined, size: number): ByteRange;
+export declare function parseByteRange(value: string | undefined, size: number): ByteRange;
 /**
  * If-Range requires strong entity-tag comparison. Date validators are matched
  * at HTTP-date (whole-second) precision because filesystem mtimes are finer,
@@ -20,6 +20,5 @@ declare function parseByteRange(value: string | undefined, size: number): ByteRa
  * Vinext's static ETags are currently weak, so its emitted Last-Modified value
  * is the validator that can enable a range response on a later request.
  */
-declare function ifRangeAllowsRange(value: string | undefined, etag: string, mtimeMs: number): boolean;
-//#endregion
-export { ByteRange, ifRangeAllowsRange, parseByteRange };
+export declare function ifRangeAllowsRange(value: string | undefined, etag: string, mtimeMs: number): boolean;
+//#endregion

package/dist/server/hybrid-route-priority.d.ts

@@ -1,10 +1,10 @@
 //#region src/server/hybrid-route-priority.d.ts
-type HybridRoutePriorityRoute = {
+export type HybridRoutePriorityRoute = {
   isDynamic: boolean;
   pattern: string;
   sourcePath?: string | null;
 };
-declare function validateHybridRouteConflicts(pagesRoutes: readonly HybridRoutePriorityRoute[], appRoutes: readonly HybridRoutePriorityRoute[]): void;
+export declare function validateHybridRouteConflicts(pagesRoutes: readonly HybridRoutePriorityRoute[], appRoutes: readonly HybridRoutePriorityRoute[]): void;
 /**
  * Return whether a matched Pages Router route should own the request instead
  * of a matched App Router route.
@@ -17,6 +17,5 @@ declare function validateHybridRouteConflicts(pagesRoutes: readonly HybridRouteP
  * `routing/utils.ts#compareHybridRoutePatterns` so the server and client
  * always reach the same answer.
  */
-declare function pagesRouteHasPriorityOverAppRoute(pagesRoute: HybridRoutePriorityRoute, appRoute: HybridRoutePriorityRoute | null): boolean;
-//#endregion
-export { HybridRoutePriorityRoute, pagesRouteHasPriorityOverAppRoute, validateHybridRouteConflicts };
+export declare function pagesRouteHasPriorityOverAppRoute(pagesRoute: HybridRoutePriorityRoute, appRoute: HybridRoutePriorityRoute | null): boolean;
+//#endregion

package/dist/server/image-optimization.d.ts

@@ -18,14 +18,14 @@
  * as-is (no transformation) with security headers applied.
  */
 /** The pathname that triggers image optimization (matches Next.js). */
-declare const IMAGE_OPTIMIZATION_PATH = "/_next/image";
+export declare const IMAGE_OPTIMIZATION_PATH = "/_next/image";
 /**
  * Vinext-prefixed alias for the image optimization endpoint. Accepted
  * alongside IMAGE_OPTIMIZATION_PATH so apps that wire image URLs to the
  * vinext-prefixed path continue to work; emit IMAGE_OPTIMIZATION_PATH
  * for any newly generated URLs.
  */
-declare const VINEXT_IMAGE_OPTIMIZATION_PATH = "/_vinext/image";
+export declare const VINEXT_IMAGE_OPTIMIZATION_PATH = "/_vinext/image";
 /**
  * Returns true when `pathname` is either supported image optimization
  * endpoint.
@@ -38,12 +38,12 @@ declare const VINEXT_IMAGE_OPTIMIZATION_PATH = "/_vinext/image";
  * Rejecting the slashed form 404'd every dev-mode next/image request under
  * `trailingSlash: true`.
  */
-declare function isImageOptimizationPath(pathname: string): boolean;
+export declare function isImageOptimizationPath(pathname: string): boolean;
 /**
  * Image security configuration from next.config.js `images` section.
  * Controls SVG handling and security headers for the image endpoint.
  */
-type ImageConfig = {
+export type ImageConfig = {
   /** Allowed device widths. Defaults to Next.js device sizes. */
   deviceSizes?: number[];
   /** Allowed fixed-image widths. Defaults to Next.js image sizes. */
@@ -76,12 +76,12 @@ type ImageConfig = {
  * These are the allowed widths for image optimization when no custom
  * config is provided. Matches Next.js defaults exactly.
  */
-declare const DEFAULT_DEVICE_SIZES: number[];
-declare const DEFAULT_IMAGE_SIZES: number[];
-type ParseImageParamsOptions = {
+export declare const DEFAULT_DEVICE_SIZES: number[];
+export declare const DEFAULT_IMAGE_SIZES: number[];
+export type ParseImageParamsOptions = {
   isDev?: boolean;
 };
-declare function resolveDevImageRedirect(requestUrl: URL, allowedWidths?: number[], allowedQualities?: number[], options?: ParseImageParamsOptions): string | null;
+export declare function resolveDevImageRedirect(requestUrl: URL, allowedWidths?: number[], allowedQualities?: number[], options?: ParseImageParamsOptions): string | null;
 /**
  * Parse and validate image optimization query parameters.
  * Returns null if the request is malformed.
@@ -90,7 +90,7 @@ declare function resolveDevImageRedirect(requestUrl: URL, allowedWidths?: number
  * test/integration/image-optimizer/test/index.test.ts
  * https://github.com/vercel/next.js/blob/canary/test/integration/image-optimizer/test/index.test.ts
  */
-declare function parseImageParams(url: URL, allowedWidths?: number[], allowedQualities?: number[], options?: ParseImageParamsOptions): {
+export declare function parseImageParams(url: URL, allowedWidths?: number[], allowedQualities?: number[], options?: ParseImageParamsOptions): {
   imageUrl: string;
   width: number;
   quality: number;
@@ -99,29 +99,29 @@ declare function parseImageParams(url: URL, allowedWidths?: number[], allowedQua
  * Negotiate the best output format based on the Accept header.
  * Returns an IANA media type.
  */
-declare function negotiateImageFormat(acceptHeader: string | null): string;
+export declare function negotiateImageFormat(acceptHeader: string | null): string;
 /**
  * Standard Cache-Control header for optimized images.
  * Optimized images are immutable because the URL encodes the transform params.
  */
-declare const IMAGE_CACHE_CONTROL = "public, max-age=31536000, immutable";
+export declare const IMAGE_CACHE_CONTROL = "public, max-age=31536000, immutable";
 /**
  * Content-Security-Policy for image optimization responses.
  * Blocks script execution and framing to prevent XSS via SVG or other
  * active content that might be served through the image endpoint.
  * Matches Next.js default: script-src 'none'; frame-src 'none'; sandbox;
  */
-declare const IMAGE_CONTENT_SECURITY_POLICY = "script-src 'none'; frame-src 'none'; sandbox;";
+export declare const IMAGE_CONTENT_SECURITY_POLICY = "script-src 'none'; frame-src 'none'; sandbox;";
 /**
  * Check if a Content-Type header value is a safe image type.
  * Returns false for SVG (unless dangerouslyAllowSVG is true), HTML, or any non-image type.
  */
-declare function isSafeImageContentType(contentType: string | null, dangerouslyAllowSVG?: boolean): boolean;
+export declare function isSafeImageContentType(contentType: string | null, dangerouslyAllowSVG?: boolean): boolean;
 /**
  * Handlers for image optimization I/O operations.
  * Workers provide these callbacks to adapt their specific bindings.
  */
-type ImageHandlers = {
+export type ImageHandlers = {
   /** Fetch the source image from storage (e.g., Cloudflare ASSETS binding). */
   fetchAsset: (path: string, request: Request) => Promise<Response>;
   /** Optional: Transform the image (resize, format, quality). */
@@ -138,14 +138,14 @@ type ImageHandlers = {
  * handlers, optionally transforms it, and returns the response with appropriate
  * cache headers.
  */
-declare function handleImageOptimization(request: Request, handlers: ImageHandlers, allowedWidths?: number[], imageConfig?: ImageConfig): Promise<Response>;
+export declare function handleImageOptimization(request: Request, handlers: ImageHandlers, allowedWidths?: number[], imageConfig?: ImageConfig): Promise<Response>;
 /**
  * A server-side image optimizer: the transform backend that resizes/transcodes
  * a source image. Produced by an adapter factory (e.g. `imagesOptimizer()` from
  * `@vinext/cloudflare/images/images-optimizer`) and registered via
  * {@link setImageOptimizer}.
  */
-type ImageOptimizer = {
+export type ImageOptimizer = {
   /** Transform the source image (resize, format, quality). */
   transformImage: (body: ReadableStream, options: {
     width: number;
@@ -175,9 +175,9 @@ type ImageOptimizer = {
  * don't have to wire `env.IMAGES` into a custom worker entry. This setter
  * remains the internal registration target.
  */
-declare function setImageOptimizer(optimizer: ImageOptimizer | null): void;
+export declare function setImageOptimizer(optimizer: ImageOptimizer | null): void;
 /** Get the active image optimizer, or `null` when none is configured. */
-declare function getImageOptimizer(): ImageOptimizer | null;
+export declare function getImageOptimizer(): ImageOptimizer | null;
 /**
  * Handle an image optimization request using the configured optimizer (if any).
  *
@@ -189,6 +189,5 @@ declare function getImageOptimizer(): ImageOptimizer | null;
  * Node). When no optimizer is registered, the request is served unoptimized
  * (passthrough) with the same security/cache headers.
  */
-declare function handleConfiguredImageOptimization(request: Request, fetchAsset: (path: string, request: Request) => Promise<Response>, allowedWidths?: number[], imageConfig?: ImageConfig): Promise<Response>;
-//#endregion
-export { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, IMAGE_CACHE_CONTROL, IMAGE_CONTENT_SECURITY_POLICY, IMAGE_OPTIMIZATION_PATH, ImageConfig, ImageHandlers, ImageOptimizer, ParseImageParamsOptions, VINEXT_IMAGE_OPTIMIZATION_PATH, getImageOptimizer, handleConfiguredImageOptimization, handleImageOptimization, isImageOptimizationPath, isSafeImageContentType, negotiateImageFormat, parseImageParams, resolveDevImageRedirect, setImageOptimizer };
+export declare function handleConfiguredImageOptimization(request: Request, fetchAsset: (path: string, request: Request) => Promise<Response>, allowedWidths?: number[], imageConfig?: ImageConfig): Promise<Response>;
+//#endregion

package/dist/server/implicit-tags.d.ts

@@ -1,6 +1,5 @@
 //#region src/server/implicit-tags.d.ts
 type AppCacheLeafKind = "page" | "route";
-declare function buildAppPageTags(cleanPathname: string, extraTags: string[], routeSegments: readonly string[]): string[];
-declare function buildPageCacheTags(pathname: string, extraTags: string[], routeSegments: string[], leafKind: AppCacheLeafKind): string[];
-//#endregion
-export { buildAppPageTags, buildPageCacheTags };
+export declare function buildAppPageTags(cleanPathname: string, extraTags: string[], routeSegments: readonly string[]): string[];
+export declare function buildPageCacheTags(pathname: string, extraTags: string[], routeSegments: string[], leafKind: AppCacheLeafKind): string[];
+//#endregion

package/dist/server/instrumentation-runtime.d.ts

@@ -1,31 +1,26 @@
 //#region src/server/instrumentation-runtime.d.ts
 /**
- * Lazy, idempotent instrumentation initialisation.
+ * Idempotent instrumentation initialisation.
  *
- * The generated App Router RSC entry calls this on the first request instead
- * of embedding the bookkeeping directly in codegen. This keeps the entry
- * module thin (it only describes the app shape) while the actual runtime
- * behaviour lives in a normal typed module that can be unit-tested.
- *
- * ## Why lazy?
- *
- * A top-level `await` at module evaluation time blocks the entire V8 isolate
- * startup phase. On Cloudflare Workers that latency is added to every cold
- * start. Moving the `register()` call into the first request handler keeps
- * module evaluation synchronous while still guaranteeing that instrumentation
- * runs before any request is handled.
+ * Generated production entries call this before evaluating user route,
+ * middleware, and boundary modules. Request handlers call it again so
+ * development and split-stage entry points keep the same guarantee. Keeping
+ * the shared-promise bookkeeping here leaves generated entries as wiring and
+ * makes concurrent initialization directly testable.
  *
  * ## Why idempotent?
  *
  * The same handler may be invoked concurrently (e.g. on a warm Worker).
- * A module-level `initialized` flag + a shared promise ensure that
- * `register()` is called exactly once even when multiple requests race.
+ * Process-wide state keyed by the imported instrumentation module, plus a
+ * shared promise, ensures that `register()` is called exactly once even when
+ * multiple requests or bundled runtime copies race. Keying by module avoids
+ * suppressing registration for another app loaded in the same process.
  *
  * ## Next.js semantics
  *
- * Next.js calls `register()` once when the server process starts, before any
- * request handling. Our lazy init preserves that guarantee because the first
- * request cannot proceed past this call until `register()` has resolved.
+ * Next.js calls `register()` once before user server modules are evaluated and
+ * before request handling. Production entries await this helper from a cached
+ * request-time initializer before dynamically importing those user modules.
  *
  * References:
  * - https://nextjs.org/docs/app/building-your-application/optimizing/instrumentation
@@ -43,7 +38,8 @@
  * @param instrumentationModule - The imported `instrumentation.ts` module.
  *   Passed as an argument so the generated entry can import it normally
  *   without this helper needing to know the module path.
+ * @param instrumentationId - Stable source path used to deduplicate the same
+ *   instrumentation file when Vite evaluates it in separate environments.
  */
-declare function ensureInstrumentationRegistered(instrumentationModule: Record<string, unknown>): Promise<void>;
-//#endregion
-export { ensureInstrumentationRegistered };
+export declare function ensureInstrumentationRegistered(instrumentationModule: Record<string, unknown>, instrumentationId?: string): Promise<void>;
+//#endregion

package/dist/server/instrumentation-runtime.js

@@ -1,7 +1,22 @@
 import { extendTracerProviderForCacheComponents } from "./otel-tracer-extension.js";
 //#region src/server/instrumentation-runtime.ts
-let initialized = false;
-let initPromise = null;
+const INSTRUMENTATION_STATE_KEY = Symbol.for("vinext.instrumentation.state");
+function getInstrumentationState(instrumentationModule, instrumentationId) {
+	const globals = globalThis;
+	const states = globals[INSTRUMENTATION_STATE_KEY] ??= {
+		byId: /* @__PURE__ */ new Map(),
+		byModule: /* @__PURE__ */ new WeakMap()
+	};
+	const existing = instrumentationId ? states.byId.get(instrumentationId) : states.byModule.get(instrumentationModule);
+	if (existing) return existing;
+	const state = {
+		initialized: false,
+		initPromise: null
+	};
+	if (instrumentationId) states.byId.set(instrumentationId, state);
+	else states.byModule.set(instrumentationModule, state);
+	return state;
+}
 function isOnRequestErrorHandler(value) {
 	return typeof value === "function";
 }
@@ -18,18 +33,21 @@ function isOnRequestErrorHandler(value) {
 * @param instrumentationModule - The imported `instrumentation.ts` module.
 *   Passed as an argument so the generated entry can import it normally
 *   without this helper needing to know the module path.
+* @param instrumentationId - Stable source path used to deduplicate the same
+*   instrumentation file when Vite evaluates it in separate environments.
 */
-async function ensureInstrumentationRegistered(instrumentationModule) {
+async function ensureInstrumentationRegistered(instrumentationModule, instrumentationId) {
 	if (process.env.VINEXT_PRERENDER === "1") return;
-	if (initialized) return;
-	if (initPromise) return initPromise;
-	initPromise = (async () => {
+	const state = getInstrumentationState(instrumentationModule, instrumentationId);
+	if (state.initialized) return;
+	if (state.initPromise) return state.initPromise;
+	state.initPromise = (async () => {
 		if (typeof instrumentationModule.register === "function") await instrumentationModule.register();
 		extendTracerProviderForCacheComponents();
 		if (isOnRequestErrorHandler(instrumentationModule.onRequestError)) globalThis.__VINEXT_onRequestErrorHandler__ = instrumentationModule.onRequestError;
-		initialized = true;
+		state.initialized = true;
 	})();
-	return initPromise;
+	return state.initPromise;
 }
 //#endregion
 export { ensureInstrumentationRegistered };

package/dist/server/instrumentation.d.ts

@@ -5,7 +5,7 @@ import { ValidFileMatcher } from "../routing/file-matcher.js";
  * `runInstrumentation`. Only `.import()` is used — this avoids requiring
  * callers (including tests) to provide a full `ModuleRunner` instance.
  */
-type ModuleImporter = {
+export type ModuleImporter = {
   import(id: string): Promise<unknown>;
 };
 /**
@@ -14,63 +14,60 @@ type ModuleImporter = {
  * Centralises the `as Record<string, any>` cast so callers don't need
  * per-call oxlint-disable comments.
  */
-declare function importModule(runner: ModuleImporter, id: string): Promise<Record<string, any>>;
+export declare function importModule(runner: ModuleImporter, id: string): Promise<Record<string, any>>;
 /**
  * Find the instrumentation file in the project root.
  */
-declare function findInstrumentationFile(root: string, fileMatcher: ValidFileMatcher): string | null;
+export declare function findInstrumentationFile(root: string, fileMatcher: ValidFileMatcher): string | null;
 /**
  * Find the instrumentation-client file in the project root.
  */
-declare function findInstrumentationClientFile(root: string, fileMatcher: ValidFileMatcher): string | null;
+export declare function findInstrumentationClientFile(root: string, fileMatcher: ValidFileMatcher): string | null;
 /**
  * The onRequestError handler type from Next.js instrumentation.
  *
  * Called when an unhandled error occurs during request handling.
  * Provides the error, the request info, and an error context.
  */
-type OnRequestErrorContext = {
-  /** The route path (e.g., '/blog/[slug]') */
+export type OnRequestErrorContext = {
+  /** The router which handled the request. */
   routerKind: "Pages Router" | "App Router";
-  /** The matched route pattern */
+  /** The matched route pattern. */
   routePath: string;
-  /** The route type */
-  routeType: "render" | "route" | "action" | "middleware";
-  /** HTTP status code that will be sent */
-  revalidateReason?: "on-demand" | "stale" | undefined;
+  /** The request operation which failed. */
+  routeType: "render" | "route" | "action" | "proxy";
+  /** The App Router render phase which failed. */
+  renderSource?: "react-server-components" | "react-server-components-payload" | "server-rendering";
+  /** Why a static route was being regenerated. */
+  revalidateReason: "on-demand" | "stale" | undefined;
 };
-type OnRequestErrorHandler = (error: Error, request: {
+export type OnRequestErrorHandler = (error: unknown, request: Readonly<{
   path: string;
   method: string;
-  headers: Record<string, string>;
-}, context: OnRequestErrorContext) => void | Promise<void>;
+  headers: Record<string, string | string[] | undefined>;
+}>, context: Readonly<OnRequestErrorContext>) => void | Promise<void>;
 /**
  * Get the registered onRequestError handler (if any).
  *
  * Reads from globalThis so it works across Vite environment boundaries.
  */
-declare function getOnRequestErrorHandler(): OnRequestErrorHandler | null;
+export declare function getOnRequestErrorHandler(): OnRequestErrorHandler | null;
 /**
  * Load and execute the instrumentation file via a ModuleRunner.
  *
- * Called once during Pages Router server startup (`configureServer`). It:
+ * Called during Node development startup (`configureServer`). It:
  * 1. Loads the instrumentation module via `runner.import()`.
  * 2. Calls the `register()` function if exported.
  * 3. Stores the `onRequestError()` handler on `globalThis` so it is visible
  *    to all Vite environment module graphs (SSR and the host process share
  *    the same Node.js `globalThis`).
  *
- * **App Router** does not use this function. For App Router, `register()` is
- * emitted as a top-level `await` inside the generated RSC entry module so it
- * runs in the same Worker/environment as request handling.
- *
- * @param runner - A ModuleRunner created via `createDirectRunner()`. Must be
- *   the same long-lived runner used for middleware and SSR so the module graph
- *   is shared. Safe with all Vite plugin combinations, including
- *   `@cloudflare/vite-plugin`, because it never touches the hot channel.
+ * @param runner - The existing RSC runner for App Router, or the long-lived
+ *   direct runner for Pages-only apps. Reusing the request runner preserves
+ *   module state initialized by `register()`.
  * @param instrumentationPath - Absolute path to the instrumentation file
  */
-declare function runInstrumentation(runner: ModuleImporter, instrumentationPath: string): Promise<void>;
+export declare function runInstrumentation(runner: ModuleImporter, instrumentationPath: string): Promise<void>;
 /**
  * Report a request error via the instrumentation handler.
  *
@@ -79,10 +76,9 @@ declare function runInstrumentation(runner: ModuleImporter, instrumentationPath:
  * Reads the handler from globalThis so this function works correctly regardless
  * of which environment it is called from.
  */
-declare function reportRequestError(error: Error, request: {
+export declare function reportRequestError(error: unknown, request: Readonly<{
   path: string;
   method: string;
-  headers: Record<string, string>;
-}, context: OnRequestErrorContext): Promise<void>;
-//#endregion
-export { ModuleImporter, OnRequestErrorContext, OnRequestErrorHandler, findInstrumentationClientFile, findInstrumentationFile, getOnRequestErrorHandler, importModule, reportRequestError, runInstrumentation };
+  headers: Record<string, string | string[] | undefined>;
+}>, context: OnRequestErrorContext): Promise<void>;
+//#endregion

package/dist/server/instrumentation.js

@@ -1,5 +1,7 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { patternToNextFormat } from "../routing/route-validation.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
+import { ensureInstrumentationRegistered } from "./instrumentation-runtime.js";
 import fs from "node:fs";
 //#region src/server/instrumentation.ts
 /**
@@ -18,12 +20,12 @@ import fs from "node:fs";
 *
 * ## App Router
 *
-* For App Router, `register()` is baked directly into the generated RSC entry
-* as a top-level `await` at module evaluation time (see `entries/app-rsc-entry.ts`
-* `generateRscEntry`). This means it runs inside the Worker process (or RSC
-* Vite environment) — the same process that handles requests — before any
-* request is served. `runInstrumentation()` is NOT called from `configureServer`
-* for App Router.
+* Node development eagerly calls `runInstrumentation()` through the same RSC
+* runner used for requests. The generated RSC entry also awaits the shared
+* registration promise before importing user server modules. This preserves
+* react-server conditions, module state, and initialization order.
+* Workers and production initialize through the generated entry in their own
+* runtime, without an extra registration in the Node development host.
 *
 * The `onRequestError` handler is stored on `globalThis` so it is visible across
 * the RSC and SSR Vite environments (separate module graphs, same Node.js process).
@@ -79,31 +81,21 @@ function getOnRequestErrorHandler() {
 /**
 * Load and execute the instrumentation file via a ModuleRunner.
 *
-* Called once during Pages Router server startup (`configureServer`). It:
+* Called during Node development startup (`configureServer`). It:
 * 1. Loads the instrumentation module via `runner.import()`.
 * 2. Calls the `register()` function if exported.
 * 3. Stores the `onRequestError()` handler on `globalThis` so it is visible
 *    to all Vite environment module graphs (SSR and the host process share
 *    the same Node.js `globalThis`).
 *
-* **App Router** does not use this function. For App Router, `register()` is
-* emitted as a top-level `await` inside the generated RSC entry module so it
-* runs in the same Worker/environment as request handling.
-*
-* @param runner - A ModuleRunner created via `createDirectRunner()`. Must be
-*   the same long-lived runner used for middleware and SSR so the module graph
-*   is shared. Safe with all Vite plugin combinations, including
-*   `@cloudflare/vite-plugin`, because it never touches the hot channel.
+* @param runner - The existing RSC runner for App Router, or the long-lived
+*   direct runner for Pages-only apps. Reusing the request runner preserves
+*   module state initialized by `register()`.
 * @param instrumentationPath - Absolute path to the instrumentation file
 */
 async function runInstrumentation(runner, instrumentationPath) {
-	try {
-		const mod = await runner.import(instrumentationPath);
-		if (typeof mod.register === "function") await mod.register();
-		if (typeof mod.onRequestError === "function") globalThis.__VINEXT_onRequestErrorHandler__ = mod.onRequestError;
-	} catch (err) {
-		console.error("[vinext] Failed to load instrumentation:", err instanceof Error ? err.message : String(err));
-	}
+	const mod = await runner.import(instrumentationPath);
+	await ensureInstrumentationRegistered(mod, instrumentationPath);
 }
 /**
 * Report a request error via the instrumentation handler.
@@ -118,7 +110,10 @@ function reportRequestError(error, request, context) {
 	if (!handler) return Promise.resolve();
 	const promise = (async () => {
 		try {
-			await handler(error, request, context);
+			await handler(error, request, {
+				...context,
+				routePath: patternToNextFormat(context.routePath)
+			});
 		} catch (reportErr) {
 			console.error("[vinext] onRequestError handler threw:", reportErr instanceof Error ? reportErr.message : String(reportErr));
 		}

package/dist/server/isr-cache.d.ts

@@ -4,17 +4,9 @@ import { RenderObservation } from "./cache-proof.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 import { CacheControlMetadata, CacheHandlerValue, CachedAppPageValue, CachedPagesValue, IncrementalCacheValue } from "../shims/cache-handler.js";
+import { getRevalidateSecret, isOnDemandRevalidateRequest, isRevalidateSecret } from "./revalidation-request.js";
 //#region src/server/isr-cache.d.ts
-declare function getRevalidateSecret(): string;
-declare function isRevalidateSecret(value: string | null | undefined): boolean;
-/**
- * Authorize an incoming request as an on-demand revalidation trigger. Mirrors
- * Next.js's `checkIsOnDemandRevalidate`: the {@link PRERENDER_REVALIDATE_HEADER}
- * value must *equal* the process revalidate secret. Header presence alone is
- * NOT sufficient — see the security note on {@link PRERENDER_REVALIDATE_HEADER}.
- */
-declare function isOnDemandRevalidateRequest(headerValue: string | string[] | null | undefined): boolean;
-type ISRCacheEntry = {
+export type ISRCacheEntry = {
   value: CacheHandlerValue;
   isStale: boolean;
   /** The entry crossed its hard expire boundary and must not be served. */
@@ -28,32 +20,39 @@ type ISRCacheEntry = {
  * { value, isStale: true, isExpired: true } for entries that must be retained
  * as regeneration input but not served, or null for cache misses.
  */
-declare function isrGet(key: string): Promise<ISRCacheEntry | null>;
+export declare function isrGet(key: string): Promise<ISRCacheEntry | null>;
 /**
  * Assemble cache-control metadata, omitting the dimensions the producing
  * render made no claim about. Shared by every ISR writer so `expire`/`stale`
  * are never invented from `revalidate`.
  */
-declare function isrCacheControl(revalidateSeconds: number | false, claims?: {
+export declare function isrCacheControl(revalidateSeconds: number | false, claims?: {
   expireSeconds?: number;
   staleSeconds?: number;
 }): CacheControlMetadata;
+/**
+ * The route-level `expireTime` only bounds a finite revalidate. Like Next.js,
+ * a `revalidate = false` entry keeps no expire of its own and stays until it
+ * is invalidated; only a cacheLife expire can bound it.
+ * https://github.com/vercel/next.js/blob/v16.2.7/packages/next/src/build/index.ts#L3035-L3058
+ */
+export declare function resolveRouteExpireSeconds(revalidateSeconds: number | false | null, expireSeconds: number | undefined): number | undefined;
 /**
  * Write policy for one ISR entry: the cache metadata the producing render
  * resolved, plus the tags that can invalidate it. Routers differ only in which
  * `cacheControl` dimensions they populate — App pages carry the client-router
  * `stale` bound, Pages Router and route handlers do not.
  */
-type IsrWritePolicy = {
+export type IsrWritePolicy = {
   cacheControl: CacheControlMetadata;
   tags?: string[];
 };
 /**
  * Store a value in the ISR cache under the given write policy.
  */
-declare function isrSet(key: string, data: IncrementalCacheValue | null, policy: IsrWritePolicy): Promise<void>;
-type AppPageCacheSetter = (key: string, data: CachedAppPageValue, policy: IsrWritePolicy) => Promise<void>;
-declare function isrSetPrerenderedAppPage(key: string, data: CachedAppPageValue, metadata: {
+export declare function isrSet(key: string, data: IncrementalCacheValue | null, policy: IsrWritePolicy): Promise<void>;
+export type AppPageCacheSetter = (key: string, data: CachedAppPageValue, policy: IsrWritePolicy) => Promise<void>;
+export declare function isrSetPrerenderedAppPage(key: string, data: CachedAppPageValue, metadata: {
   expireSeconds?: number;
   revalidateSeconds?: number;
   /** Client reuse bound from the prerender's `cacheLife`. */
@@ -68,7 +67,7 @@ declare function isrSetPrerenderedAppPage(key: string, data: CachedAppPageValue,
   tags?: string[];
 }): Promise<void>;
 /** Coalesce same-key synchronous on-demand revalidations. */
-declare function coalesceOnDemandRevalidation<T>(key: string, renderFn: () => Promise<T>): Promise<T>;
+export declare function coalesceOnDemandRevalidation<T>(key: string, renderFn: () => Promise<T>): Promise<T>;
 /**
  * Trigger a background regeneration for a cache key.
  *
@@ -81,26 +80,28 @@ declare function coalesceOnDemandRevalidation<T>(key: string, renderFn: () => Pr
  *
  * When `errorContext` is provided and the render function fails, the error
  * is reported via `reportRequestError` (instrumentation hook) with
- * `revalidateReason: "stale"`.
+ * `revalidateReason: "stale"`, unless `shouldReport` suppresses an error that
+ * an inner render boundary already reported.
  */
-declare function triggerBackgroundRegeneration(key: string, renderFn: () => Promise<void>, errorContext?: {
+export declare function triggerBackgroundRegeneration(key: string, renderFn: () => Promise<void>, errorContext?: {
   routerKind: OnRequestErrorContext["routerKind"];
   routePath: string;
   routeType: OnRequestErrorContext["routeType"];
+  shouldReport?: (error: unknown) => boolean;
 }): void;
 /**
  * Build a CachedPagesValue for the Pages Router ISR cache.
  */
-declare function buildPagesCacheValue(html: string, pageData: object, status?: number): CachedPagesValue;
+export declare function buildPagesCacheValue(html: string, pageData: object, status?: number): CachedPagesValue;
 /**
  * Build a CachedAppPageValue for the App Router ISR cache.
  */
-declare function buildAppPageCacheValue(html: string, rscData?: ArrayBuffer, status?: number, renderObservation?: RenderObservation, headers?: CachedAppPageValue["headers"]): CachedAppPageValue;
+export declare function buildAppPageCacheValue(html: string, rscData?: ArrayBuffer, status?: number, renderObservation?: RenderObservation, headers?: CachedAppPageValue["headers"]): CachedAppPageValue;
 /**
  * Compute an ISR cache key for a given router type and pathname.
  * Long pathnames are hashed to stay within KV key-length limits (512 bytes).
  */
-declare function isrCacheKey(router: string, pathname: string, buildId?: string): string;
+export declare function isrCacheKey(router: string, pathname: string, buildId?: string): string;
 /**
  * Compute an App Router ISR key for one cache artifact.
  *
@@ -108,8 +109,8 @@ declare function isrCacheKey(router: string, pathname: string, buildId?: string)
  * The suffix mirrors Next.js's separate on-disk app artifacts while keeping the
  * Cloudflare KV key under its 512-byte limit for long pathnames.
  */
-declare function appIsrCacheKey(pathname: string, suffix: string, buildId?: string | undefined): string;
-declare function appIsrHtmlKey(pathname: string): string;
+export declare function appIsrCacheKey(pathname: string, suffix: string, buildId?: string | undefined): string;
+export declare function appIsrHtmlKey(pathname: string): string;
 /**
  * Build the ISR cache key for an RSC payload.
  *
@@ -121,7 +122,7 @@ declare function appIsrHtmlKey(pathname: string): string;
  * become unreachable after deployment. This is acceptable because ISR entries
  * have TTLs and will be regenerated on the next request.
  */
-declare function appIsrRscKey(pathname: string, mountedSlotsHeader?: string | null, renderMode?: AppRscRenderMode, interceptionContext?: string | null, interceptionId?: string | null): string;
-declare function appIsrRouteKey(pathname: string): string;
+export declare function appIsrRscKey(pathname: string, mountedSlotsHeader?: string | null, renderMode?: AppRscRenderMode, interceptionContext?: string | null, interceptionId?: string | null): string;
+export declare function appIsrRouteKey(pathname: string): string;
 //#endregion
-export { AppPageCacheSetter, ISRCacheEntry, IsrWritePolicy, PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER, appIsrCacheKey, appIsrHtmlKey, appIsrRouteKey, appIsrRscKey, buildAppPageCacheValue, buildPagesCacheValue, coalesceOnDemandRevalidation, getRevalidateSecret, isOnDemandRevalidateRequest, isRevalidateSecret, isrCacheControl, isrCacheKey, isrGet, isrSet, isrSetPrerenderedAppPage, normalizeMountedSlotsHeader, triggerBackgroundRegeneration };
+export { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER, getRevalidateSecret, isOnDemandRevalidateRequest, isRevalidateSecret, normalizeMountedSlotsHeader };