@qzsy/vinext 0.1.7

package/dist/client/app-nav-failure-handler.d.ts

@@ -0,0 +1,8 @@
+//#region src/client/app-nav-failure-handler.d.ts
+declare function stageAppNavigationFailureTarget(href: string): void;
+declare function getAppNavigationFailureTarget(href: string): URL | null;
+declare function clearAppNavigationFailureTarget(target?: string | URL): void;
+declare function handleAppNavigationFailure(error: unknown): boolean;
+declare function installAppNavigationFailureListeners(): () => void;
+//#endregion
+export { clearAppNavigationFailureTarget, getAppNavigationFailureTarget, handleAppNavigationFailure, installAppNavigationFailureListeners, stageAppNavigationFailureTarget };

package/dist/client/app-nav-failure-handler.js

@@ -0,0 +1,44 @@
+import { installWindowNext } from "./window-next.js";
+//#region src/client/app-nav-failure-handler.ts
+function getPendingUrl() {
+	if (typeof window === "undefined") return null;
+	return window.next?.__pendingUrl ?? null;
+}
+function stageAppNavigationFailureTarget(href) {
+	if (!process.env.__NEXT_APP_NAV_FAIL_HANDLING || typeof window === "undefined") return;
+	installWindowNext({ __pendingUrl: new URL(href, window.location.href) });
+}
+function getAppNavigationFailureTarget(href) {
+	const pendingUrl = getPendingUrl();
+	if (pendingUrl === null || typeof window === "undefined") return null;
+	return pendingUrl.href === new URL(href, window.location.href).href ? pendingUrl : null;
+}
+function clearAppNavigationFailureTarget(target) {
+	if (typeof window === "undefined" || window.next?.__pendingUrl === void 0) return;
+	if (target instanceof URL) {
+		if (window.next.__pendingUrl !== target) return;
+	} else if (target !== void 0 && window.next.__pendingUrl.href !== new URL(target, window.location.href).href) return;
+	delete window.next.__pendingUrl;
+}
+function handleAppNavigationFailure(error) {
+	if (!process.env.__NEXT_APP_NAV_FAIL_HANDLING || typeof window === "undefined") return false;
+	const pendingUrl = getPendingUrl();
+	if (pendingUrl === null || pendingUrl.href === window.location.href) return false;
+	console.error("Error occurred during navigation, falling back to hard navigation", error);
+	window.location.assign(pendingUrl.href);
+	return true;
+}
+function installAppNavigationFailureListeners() {
+	if (!process.env.__NEXT_APP_NAV_FAIL_HANDLING || typeof window === "undefined") return () => {};
+	const listener = (event) => {
+		handleAppNavigationFailure("reason" in event ? event.reason : event.error);
+	};
+	window.addEventListener("error", listener);
+	window.addEventListener("unhandledrejection", listener);
+	return () => {
+		window.removeEventListener("error", listener);
+		window.removeEventListener("unhandledrejection", listener);
+	};
+}
+//#endregion
+export { clearAppNavigationFailureTarget, getAppNavigationFailureTarget, handleAppNavigationFailure, installAppNavigationFailureListeners, stageAppNavigationFailureTarget };

package/dist/client/empty-module.d.ts

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

package/dist/client/empty-module.js

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

package/dist/client/instrumentation-client-inject.d.ts

@@ -0,0 +1,33 @@
+//#region src/client/instrumentation-client-inject.d.ts
+/** Absolute path to the vinext empty-module fallback for composed client instrumentation. */
+declare const INSTRUMENTATION_CLIENT_EMPTY_MODULE: string;
+/**
+ * Generate a virtual ESM module that implements the Next.js
+ * `instrumentationClientInject` contract for client bootstrap.
+ *
+ * Resolution follows two paths depending on whether injects are configured:
+ *
+ * **Empty injects (`injects.length === 0`):** Returns `export {}` and the
+ * plugin does not serve a virtual module. The `resolve.alias` for
+ * `private-next-instrumentation-client` resolves directly to the user's
+ * `instrumentation-client` file (or {@link INSTRUMENTATION_CLIENT_EMPTY_MODULE} when absent),
+ * so the user's `onRouterTransitionStart` is used as-is with no composition.
+ *
+ * **Non-empty injects:** The plugin serves this generated module via
+ * `resolveId`/`load`. It side-effect-imports each inject in config order, then
+ * the user's file last, and exports a single composed `onRouterTransitionStart`
+ * that fans out to every module's hook.
+ *
+ * **Specifier resolution:** Next.js webpack loader resolves every inject against
+ * the project root at build time (`this.resolve(rootContext, spec)`) and emits
+ * `require(resolvedPath)`. Vinext pre-resolves `./` and `../` in the plugin
+ * `config()` hook; bare specifiers rely on Vite resolution at bundle time.
+ *
+ * @param injects - Module specifiers from `nextConfig.instrumentationClientInject`
+ * @param userPath - Absolute path to the user's `instrumentation-client` file,
+ *                   or `null` when the file doesn't exist
+ * @param emptyModulePath - Absolute path to the empty-module fallback
+ */
+declare function generateInstrumentationClientInjectModule(injects: readonly string[], userPath: string | null, emptyModulePath?: string): string;
+//#endregion
+export { INSTRUMENTATION_CLIENT_EMPTY_MODULE, generateInstrumentationClientInjectModule };

package/dist/client/instrumentation-client-inject.js

@@ -0,0 +1,55 @@
+import fs from "node:fs";
+import path from "node:path";
+//#region src/client/instrumentation-client-inject.ts
+/** Resolve empty-module next to this file (.js in dist, .ts in source). */
+function resolveInstrumentationClientEmptyModule(dir) {
+	const jsPath = path.join(dir, "empty-module.js");
+	if (fs.existsSync(jsPath)) return jsPath;
+	return path.join(dir, "empty-module.ts");
+}
+/** Absolute path to the vinext empty-module fallback for composed client instrumentation. */
+const INSTRUMENTATION_CLIENT_EMPTY_MODULE = resolveInstrumentationClientEmptyModule(import.meta.dirname);
+/**
+* Generate a virtual ESM module that implements the Next.js
+* `instrumentationClientInject` contract for client bootstrap.
+*
+* Resolution follows two paths depending on whether injects are configured:
+*
+* **Empty injects (`injects.length === 0`):** Returns `export {}` and the
+* plugin does not serve a virtual module. The `resolve.alias` for
+* `private-next-instrumentation-client` resolves directly to the user's
+* `instrumentation-client` file (or {@link INSTRUMENTATION_CLIENT_EMPTY_MODULE} when absent),
+* so the user's `onRouterTransitionStart` is used as-is with no composition.
+*
+* **Non-empty injects:** The plugin serves this generated module via
+* `resolveId`/`load`. It side-effect-imports each inject in config order, then
+* the user's file last, and exports a single composed `onRouterTransitionStart`
+* that fans out to every module's hook.
+*
+* **Specifier resolution:** Next.js webpack loader resolves every inject against
+* the project root at build time (`this.resolve(rootContext, spec)`) and emits
+* `require(resolvedPath)`. Vinext pre-resolves `./` and `../` in the plugin
+* `config()` hook; bare specifiers rely on Vite resolution at bundle time.
+*
+* @param injects - Module specifiers from `nextConfig.instrumentationClientInject`
+* @param userPath - Absolute path to the user's `instrumentation-client` file,
+*                   or `null` when the file doesn't exist
+* @param emptyModulePath - Absolute path to the empty-module fallback
+*/
+function generateInstrumentationClientInjectModule(injects, userPath, emptyModulePath = INSTRUMENTATION_CLIENT_EMPTY_MODULE) {
+	if (injects.length === 0) return "export {};";
+	const lines = [];
+	for (let i = 0; i < injects.length; i++) lines.push(`import * as __vinj_${i} from ${JSON.stringify(injects[i])};`);
+	const userSlot = injects.length;
+	lines.push(`import * as __vinj_${userSlot} from ${JSON.stringify(userPath ?? emptyModulePath)};`);
+	const hookCalls = [];
+	for (let i = 0; i <= userSlot; i++) hookCalls.push(`  if (typeof __vinj_${i}.onRouterTransitionStart === "function") {`, `    __vinj_${i}.onRouterTransitionStart(url, type);`, `  }`);
+	lines.push("");
+	lines.push("export function onRouterTransitionStart(url, type) {");
+	lines.push(...hookCalls);
+	lines.push(`}`);
+	lines.push("");
+	return lines.join("\n");
+}
+//#endregion
+export { INSTRUMENTATION_CLIENT_EMPTY_MODULE, generateInstrumentationClientInjectModule };

package/dist/client/instrumentation-client-state.d.ts

@@ -0,0 +1,9 @@
+import { ClientInstrumentationHooks } from "./instrumentation-client.js";
+
+//#region src/client/instrumentation-client-state.d.ts
+declare function normalizeClientInstrumentationHooks(hooks: ClientInstrumentationHooks): ClientInstrumentationHooks | null;
+declare function setClientInstrumentationHooks(hooks: ClientInstrumentationHooks | null): ClientInstrumentationHooks | null;
+declare function getClientInstrumentationHooks(): ClientInstrumentationHooks | null;
+declare function notifyAppRouterTransitionStart(href: string, navigationType: "push" | "replace" | "traverse"): void;
+//#endregion
+export { getClientInstrumentationHooks, normalizeClientInstrumentationHooks, notifyAppRouterTransitionStart, setClientInstrumentationHooks };

package/dist/client/instrumentation-client-state.js

@@ -0,0 +1,17 @@
+//#region src/client/instrumentation-client-state.ts
+let clientInstrumentationHooks = null;
+function normalizeClientInstrumentationHooks(hooks) {
+	return Object.values(hooks).some((value) => typeof value === "function") ? hooks : null;
+}
+function setClientInstrumentationHooks(hooks) {
+	clientInstrumentationHooks = hooks;
+	return clientInstrumentationHooks;
+}
+function getClientInstrumentationHooks() {
+	return clientInstrumentationHooks;
+}
+function notifyAppRouterTransitionStart(href, navigationType) {
+	clientInstrumentationHooks?.onRouterTransitionStart?.(href, navigationType);
+}
+//#endregion
+export { getClientInstrumentationHooks, normalizeClientInstrumentationHooks, notifyAppRouterTransitionStart, setClientInstrumentationHooks };

package/dist/client/instrumentation-client.d.ts

@@ -0,0 +1,7 @@
+//#region src/client/instrumentation-client.d.ts
+type ClientInstrumentationHooks = {
+  onRouterTransitionStart?: (href: string, navigationType: "push" | "replace" | "traverse") => void;
+};
+declare const clientInstrumentationHooks: ClientInstrumentationHooks | null;
+//#endregion
+export { ClientInstrumentationHooks, clientInstrumentationHooks };

package/dist/client/instrumentation-client.js

@@ -0,0 +1,6 @@
+import { normalizeClientInstrumentationHooks, setClientInstrumentationHooks } from "./instrumentation-client-state.js";
+import * as instrumentationClientHooks from "private-next-instrumentation-client";
+//#region src/client/instrumentation-client.ts
+const clientInstrumentationHooks = setClientInstrumentationHooks(normalizeClientInstrumentationHooks(instrumentationClientHooks));
+//#endregion
+export { clientInstrumentationHooks };

package/dist/client/navigation-runtime.d.ts

@@ -0,0 +1,70 @@
+import { RouteManifest } from "../routing/app-route-graph.js";
+import { AppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
+
+//#region src/client/navigation-runtime.d.ts
+type NavigationRuntimeSnapshot = {
+  pathname: string;
+  searchParams: [string, string][];
+};
+type NavigationRuntimeRscChunk = string | [3, string];
+type NavigationRuntimeRscBootstrap = {
+  done?: boolean;
+  nav?: NavigationRuntimeSnapshot;
+  params?: Record<string, string | string[]>;
+  rsc: NavigationRuntimeRscChunk[];
+};
+type NavigationRuntimeKind = "navigate" | "traverse" | "refresh";
+type NavigationRuntimeHistoryUpdateMode = "push" | "replace";
+type NavigationRuntimeVisibleCommitMode = "transition" | "synchronous";
+type NavigationRuntimeTraversalIntent = {
+  direction: "back" | "forward" | "unknown";
+  historyState: unknown;
+  targetHistoryIndex: number | null;
+};
+type NavigationRuntimeNavigate = (href: string, redirectDepth?: number, navigationKind?: NavigationRuntimeKind, historyUpdateMode?: NavigationRuntimeHistoryUpdateMode, previousNextUrlOverride?: string | null, programmaticTransition?: boolean, traversalIntent?: NavigationRuntimeTraversalIntent, scrollIntent?: AppRouterScrollIntent | null, visibleCommitMode?: NavigationRuntimeVisibleCommitMode) => Promise<void>;
+type NavigationRuntimeFunctions = {
+  clearNavigationCaches?: () => void;
+  commitHashNavigation?: (href: string, historyUpdateMode: NavigationRuntimeHistoryUpdateMode, scroll: boolean) => void;
+  navigateExternal?: (href: string, historyUpdateMode: NavigationRuntimeHistoryUpdateMode) => Promise<void>;
+  navigate?: NavigationRuntimeNavigate;
+  /**
+   * Called at the start of every App Router navigation so the <Link> shim can
+   * reset any link that is still showing a `useLinkStatus()` pending state but
+   * is not the one driving this navigation (e.g. a programmatic router.push or
+   * a shallow-routing transition). Registered by shims/link.tsx; decoupled
+   * through the runtime to avoid a circular import with shims/navigation.ts.
+   */
+  notifyLinkNavigationStart?: () => void;
+  pingVisibleLinks?: () => void;
+};
+type NavigationRuntimeBootstrap = {
+  routeManifest: RouteManifest | null;
+  rsc: NavigationRuntimeRscBootstrap | undefined;
+};
+type NavigationRuntime = {
+  bootstrap: NavigationRuntimeBootstrap;
+  functions: NavigationRuntimeFunctions;
+};
+declare const NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION = "vinext.navigationRuntime";
+declare const NAVIGATION_RUNTIME_KEY: unique symbol;
+declare function getNavigationRuntime(): NavigationRuntime | null;
+declare function registerNavigationRuntimeBootstrap(bootstrap: Partial<NavigationRuntimeBootstrap>): NavigationRuntime;
+declare function registerNavigationRuntimeFunctions(functions: Partial<NavigationRuntimeFunctions>): NavigationRuntime;
+declare function ensureNavigationRuntimeRscBootstrap(): NavigationRuntimeRscBootstrap;
+declare function subscribeNavigationRuntimeRscChunk(chunk: NavigationRuntimeRscChunk): NavigationRuntime;
+declare function hasAppNavigationRuntime(): boolean;
+/**
+ * True when the App Router has installed its runtime bootstrap on `window`,
+ * which the inline runtime-metadata script does synchronously in `<head>`.
+ *
+ * This is a stronger early-life signal than `hasAppNavigationRuntime()` — the
+ * latter checks for the fully-wired `navigate` function and so returns false
+ * during the brief window between HTML parse and the bootstrap module
+ * finishing initialization. Code that needs to differentiate App Router from
+ * Pages Router *during hydration* (e.g. the Script shim deciding whether the
+ * server-side pre-head splice already emitted the inline beforeInteractive
+ * tag) should call this instead.
+ */
+declare function hasAppNavigationRuntimeBootstrap(): boolean;
+//#endregion
+export { NAVIGATION_RUNTIME_KEY, NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION, NavigationRuntime, NavigationRuntimeBootstrap, NavigationRuntimeFunctions, NavigationRuntimeNavigate, NavigationRuntimeRscBootstrap, NavigationRuntimeRscChunk, NavigationRuntimeSnapshot, NavigationRuntimeVisibleCommitMode, ensureNavigationRuntimeRscBootstrap, getNavigationRuntime, hasAppNavigationRuntime, hasAppNavigationRuntimeBootstrap, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions, subscribeNavigationRuntimeRscChunk };

package/dist/client/navigation-runtime.js

@@ -0,0 +1,169 @@
+import { isUnknownRecord } from "../utils/record.js";
+//#region src/client/navigation-runtime.ts
+const NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION = "vinext.navigationRuntime";
+const NAVIGATION_RUNTIME_KEY = Symbol.for(NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION);
+const ROUTE_MANIFEST_SEGMENT_GRAPH_MAP_KEYS = [
+	"boundaries",
+	"defaults",
+	"interceptions",
+	"interceptionsBySlotId",
+	"layouts",
+	"pages",
+	"rootBoundaries",
+	"routeHandlers",
+	"routes",
+	"slotBindings",
+	"slots",
+	"templates"
+];
+function createNavigationRuntime() {
+	return {
+		bootstrap: {
+			routeManifest: null,
+			rsc: void 0
+		},
+		functions: {}
+	};
+}
+function readRuntimeWindow() {
+	if (typeof window === "undefined") return null;
+	return window;
+}
+function isNavigationRuntimeFunctions(value) {
+	if (!isUnknownRecord(value)) return false;
+	return isOptionalRuntimeFunction(Reflect.get(value, "clearNavigationCaches")) && isOptionalRuntimeFunction(Reflect.get(value, "commitHashNavigation")) && isOptionalRuntimeFunction(Reflect.get(value, "navigateExternal")) && isOptionalRuntimeFunction(Reflect.get(value, "navigate")) && isOptionalRuntimeFunction(Reflect.get(value, "notifyLinkNavigationStart")) && isOptionalRuntimeFunction(Reflect.get(value, "pingVisibleLinks"));
+}
+function isNavigationRuntimeRscChunk(value) {
+	if (typeof value === "string") return true;
+	return Array.isArray(value) && value.length === 2 && value[0] === 3 && typeof value[1] === "string";
+}
+function isNavigationRuntimeSnapshot(value) {
+	if (!isUnknownRecord(value)) return false;
+	const pathname = Reflect.get(value, "pathname");
+	const searchParams = Reflect.get(value, "searchParams");
+	return typeof pathname === "string" && Array.isArray(searchParams) && searchParams.every((entry) => Array.isArray(entry) && entry.length === 2 && typeof entry[0] === "string" && typeof entry[1] === "string");
+}
+function isNavigationRuntimeParams(value) {
+	if (!isUnknownRecord(value)) return false;
+	return Object.values(value).every((entry) => typeof entry === "string" || Array.isArray(entry) && entry.every((part) => typeof part === "string"));
+}
+function isNavigationRuntimeRscBootstrap(value) {
+	if (!isUnknownRecord(value)) return false;
+	const done = Reflect.get(value, "done");
+	const nav = Reflect.get(value, "nav");
+	const params = Reflect.get(value, "params");
+	const rsc = Reflect.get(value, "rsc");
+	return (done === void 0 || typeof done === "boolean") && (nav === void 0 || isNavigationRuntimeSnapshot(nav)) && (params === void 0 || isNavigationRuntimeParams(params)) && Array.isArray(rsc) && rsc.every(isNavigationRuntimeRscChunk);
+}
+function isReadonlyStringArray(value) {
+	return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function isNullableString(value) {
+	return value === null || typeof value === "string";
+}
+function isNavigationRuntimeInterception(value) {
+	if (!isUnknownRecord(value)) return false;
+	return typeof value.id === "string" && typeof value.sourcePattern === "string" && isReadonlyStringArray(value.sourcePatternParts) && typeof value.targetPattern === "string" && isReadonlyStringArray(value.targetPatternParts) && typeof value.slotId === "string" && isNullableString(value.ownerLayoutId) && isNullableString(value.interceptingRouteId) && isNullableString(value.targetRouteId);
+}
+function isNavigationRuntimeInterceptionArray(value) {
+	return Array.isArray(value) && value.every(isNavigationRuntimeInterception);
+}
+function isNavigationRuntimeRouteManifest(value) {
+	if (!isUnknownRecord(value)) return false;
+	const graphVersion = Reflect.get(value, "graphVersion");
+	const segmentGraph = Reflect.get(value, "segmentGraph");
+	if (typeof graphVersion !== "string" || !isUnknownRecord(segmentGraph)) return false;
+	const interceptions = Reflect.get(segmentGraph, "interceptions");
+	const interceptionsBySlotId = Reflect.get(segmentGraph, "interceptionsBySlotId");
+	if (!ROUTE_MANIFEST_SEGMENT_GRAPH_MAP_KEYS.every((key) => Reflect.get(segmentGraph, key) instanceof Map) || !(interceptions instanceof Map) || !(interceptionsBySlotId instanceof Map)) return false;
+	for (const interception of interceptions.values()) if (!isNavigationRuntimeInterception(interception)) return false;
+	for (const slotInterceptions of interceptionsBySlotId.values()) if (!isNavigationRuntimeInterceptionArray(slotInterceptions)) return false;
+	return true;
+}
+function isNavigationRuntimeBootstrap(value) {
+	if (!isUnknownRecord(value)) return false;
+	const routeManifest = Reflect.get(value, "routeManifest");
+	const rsc = Reflect.get(value, "rsc");
+	return (routeManifest === null || isNavigationRuntimeRouteManifest(routeManifest)) && (rsc === void 0 || isNavigationRuntimeRscBootstrap(rsc));
+}
+function isNavigationRuntime(value) {
+	if (!isUnknownRecord(value)) return false;
+	if (!("bootstrap" in value) || !("functions" in value)) return false;
+	const { bootstrap, functions } = value;
+	return isNavigationRuntimeBootstrap(bootstrap) && isNavigationRuntimeFunctions(functions);
+}
+function isOptionalRuntimeFunction(value) {
+	return value === void 0 || typeof value === "function";
+}
+function getNavigationRuntime() {
+	const runtimeWindow = readRuntimeWindow();
+	if (runtimeWindow === null) return null;
+	const runtime = Reflect.get(runtimeWindow, NAVIGATION_RUNTIME_KEY);
+	return isNavigationRuntime(runtime) ? runtime : null;
+}
+/**
+* Returns the registered browser runtime, creating it when a window exists.
+* Without a window, callers receive a detached runtime and must retain the
+* returned reference themselves; server calls are intentionally not global.
+*/
+function ensureNavigationRuntime() {
+	const runtimeWindow = readRuntimeWindow();
+	if (runtimeWindow === null) return createNavigationRuntime();
+	const existingRuntime = Reflect.get(runtimeWindow, NAVIGATION_RUNTIME_KEY);
+	const runtime = isNavigationRuntime(existingRuntime) ? existingRuntime : createNavigationRuntime();
+	Reflect.set(runtimeWindow, NAVIGATION_RUNTIME_KEY, runtime);
+	return runtime;
+}
+function registerNavigationRuntimeBootstrap(bootstrap) {
+	const runtime = ensureNavigationRuntime();
+	runtime.bootstrap = {
+		...runtime.bootstrap,
+		...bootstrap
+	};
+	return runtime;
+}
+function registerNavigationRuntimeFunctions(functions) {
+	const runtime = ensureNavigationRuntime();
+	runtime.functions = {
+		...runtime.functions,
+		...functions
+	};
+	return runtime;
+}
+function ensureNavigationRuntimeRscBootstrap() {
+	return ensureNavigationRuntimeRscBootstrapForRuntime(ensureNavigationRuntime());
+}
+function ensureNavigationRuntimeRscBootstrapForRuntime(runtime) {
+	const rscBootstrap = runtime.bootstrap.rsc;
+	if (rscBootstrap === void 0) {
+		const nextRscBootstrap = { rsc: [] };
+		runtime.bootstrap.rsc = nextRscBootstrap;
+		return nextRscBootstrap;
+	}
+	return rscBootstrap;
+}
+function subscribeNavigationRuntimeRscChunk(chunk) {
+	const runtime = ensureNavigationRuntime();
+	ensureNavigationRuntimeRscBootstrapForRuntime(runtime).rsc.push(chunk);
+	return runtime;
+}
+function hasAppNavigationRuntime() {
+	return typeof getNavigationRuntime()?.functions.navigate === "function";
+}
+/**
+* True when the App Router has installed its runtime bootstrap on `window`,
+* which the inline runtime-metadata script does synchronously in `<head>`.
+*
+* This is a stronger early-life signal than `hasAppNavigationRuntime()` — the
+* latter checks for the fully-wired `navigate` function and so returns false
+* during the brief window between HTML parse and the bootstrap module
+* finishing initialization. Code that needs to differentiate App Router from
+* Pages Router *during hydration* (e.g. the Script shim deciding whether the
+* server-side pre-head splice already emitted the inline beforeInteractive
+* tag) should call this instead.
+*/
+function hasAppNavigationRuntimeBootstrap() {
+	return getNavigationRuntime() !== null;
+}
+//#endregion
+export { NAVIGATION_RUNTIME_KEY, NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION, ensureNavigationRuntimeRscBootstrap, getNavigationRuntime, hasAppNavigationRuntime, hasAppNavigationRuntimeBootstrap, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions, subscribeNavigationRuntimeRscChunk };

package/dist/client/pages-router-link-navigation.d.ts

@@ -0,0 +1,61 @@
+//#region src/client/pages-router-link-navigation.d.ts
+type PagesRouterLinkTransitionOptions = {
+  scroll?: boolean;
+  shallow?: boolean;
+  locale?: string | false;
+  _vinextInterpolateDynamicRoute?: boolean;
+};
+type PagesRouterLinkRuntime = {
+  push(url: string, as?: string, options?: PagesRouterLinkTransitionOptions): Promise<boolean>;
+  replace(url: string, as?: string, options?: PagesRouterLinkTransitionOptions): Promise<boolean>;
+};
+type PagesRouterLinkNavigation = {
+  href: string;
+  /**
+   * Optional `as` mask — the browser-bar URL when it differs from `href`
+   * (a Pages Router route pattern, e.g. `<Link href="/posts/[id]" as="/posts/1">`).
+   * When present, `router.push/replace(href, as, ...)` is invoked with both
+   * values so the upstream (url, as) pair survives end-to-end. Mirrors
+   * Next.js's Link → Router contract: packages/next/src/client/link.tsx
+   * → router.push(href, as).
+   */
+  as?: string;
+  replace: boolean;
+  scroll: boolean;
+  shallow?: boolean;
+  locale?: string | false;
+  interpolateDynamicRoute?: boolean;
+};
+declare function resolvePagesRouterQueryOnlyHref(href: string, {
+  asPath,
+  basePath,
+  fallbackHref,
+  locales
+}: {
+  asPath?: string;
+  basePath: string;
+  fallbackHref: string;
+  locales?: readonly string[];
+}): string;
+declare function navigatePagesRouterLink(router: PagesRouterLinkRuntime, {
+  href,
+  as,
+  replace,
+  scroll,
+  shallow,
+  locale,
+  interpolateDynamicRoute
+}: PagesRouterLinkNavigation): Promise<void>;
+declare function navigatePagesRouterLinkWithFallback({
+  router,
+  loadRouter,
+  navigation,
+  fallback
+}: {
+  router?: PagesRouterLinkRuntime;
+  loadRouter: () => Promise<PagesRouterLinkRuntime | undefined>;
+  navigation: PagesRouterLinkNavigation;
+  fallback: () => void;
+}): Promise<void>;
+//#endregion
+export { navigatePagesRouterLink, navigatePagesRouterLinkWithFallback, resolvePagesRouterQueryOnlyHref };

package/dist/client/pages-router-link-navigation.js

@@ -0,0 +1,42 @@
+import { stripBasePath } from "../utils/base-path.js";
+import { getLocalePathPrefix } from "../utils/domain-locale.js";
+//#region src/client/pages-router-link-navigation.ts
+function resolvePagesRouterQueryOnlyHref(href, { asPath, basePath, fallbackHref, locales }) {
+	if (!href.startsWith("?")) return href;
+	try {
+		const fallbackUrl = new URL(fallbackHref);
+		const base = new URL(asPath ?? `${stripBasePath(fallbackUrl.pathname, basePath)}${fallbackUrl.search}${fallbackUrl.hash}`, "http://vinext.local");
+		const locale = getLocalePathPrefix(base.pathname, locales);
+		if (locale) base.pathname = base.pathname.slice(locale.length + 1) || "/";
+		const resolved = new URL(href, base);
+		return resolved.href.slice(resolved.origin.length);
+	} catch {
+		return href;
+	}
+}
+async function navigatePagesRouterLink(router, { href, as, replace, scroll, shallow, locale, interpolateDynamicRoute = false }) {
+	const routerOptions = {
+		scroll,
+		locale
+	};
+	if (interpolateDynamicRoute) routerOptions._vinextInterpolateDynamicRoute = true;
+	if (shallow !== void 0) routerOptions.shallow = shallow;
+	if (replace) await router.replace(href, as, routerOptions);
+	else await router.push(href, as, routerOptions);
+}
+async function navigatePagesRouterLinkWithFallback({ router, loadRouter, navigation, fallback }) {
+	let pagesRouter = router;
+	if (!pagesRouter) try {
+		pagesRouter = await loadRouter();
+	} catch {
+		fallback();
+		return;
+	}
+	if (!pagesRouter) {
+		fallback();
+		return;
+	}
+	await navigatePagesRouterLink(pagesRouter, navigation);
+}
+//#endregion
+export { navigatePagesRouterLink, navigatePagesRouterLinkWithFallback, resolvePagesRouterQueryOnlyHref };

package/dist/client/validate-module-path.d.ts

@@ -0,0 +1,17 @@
+//#region src/client/validate-module-path.d.ts
+/**
+ * Defense-in-depth: validate module paths before passing them to dynamic import().
+ *
+ * Shared between entry.ts (initial hydration) and router.ts (client-side navigation)
+ * to ensure all dynamic imports of page/app modules go through the same validation.
+ *
+ * Blocks:
+ * - Non-string or empty values
+ * - Paths that don't start with `/` or `./` (e.g., `https://evil.com/...`)
+ * - Protocol URLs (`://`)
+ * - Protocol-relative URLs (`//...`)
+ * - Directory traversal (`..`)
+ */
+declare function isValidModulePath(p: unknown): p is string;
+//#endregion
+export { isValidModulePath };

package/dist/client/validate-module-path.js

@@ -0,0 +1,24 @@
+//#region src/client/validate-module-path.ts
+/**
+* Defense-in-depth: validate module paths before passing them to dynamic import().
+*
+* Shared between entry.ts (initial hydration) and router.ts (client-side navigation)
+* to ensure all dynamic imports of page/app modules go through the same validation.
+*
+* Blocks:
+* - Non-string or empty values
+* - Paths that don't start with `/` or `./` (e.g., `https://evil.com/...`)
+* - Protocol URLs (`://`)
+* - Protocol-relative URLs (`//...`)
+* - Directory traversal (`..`)
+*/
+function isValidModulePath(p) {
+	if (typeof p !== "string" || p.length === 0) return false;
+	if (!p.startsWith("/") && !p.startsWith("./")) return false;
+	if (p.startsWith("//")) return false;
+	if (p.includes("://")) return false;
+	if (p.includes("..")) return false;
+	return true;
+}
+//#endregion
+export { isValidModulePath };

package/dist/client/vinext-next-data.d.ts

@@ -0,0 +1,44 @@
+import { NEXT_DATA } from "../shims/internal/utils.js";
+
+//#region src/client/vinext-next-data.d.ts
+type VinextLinkPrefetchRoute = {
+  canPrefetchLoadingShell: boolean;
+  documentOnly?: boolean;
+  isDynamic: boolean;
+  patternParts: string[];
+};
+/**
+ * Pages Router route pattern exposed to the client so the App Router's
+ * navigation runtime can decide whether a soft-navigated URL should be
+ * handled by Pages (hard nav) or App (RSC). Mirrors the public shape of
+ * `VinextLinkPrefetchRoute` so a single trie matcher handles both.
+ *
+ * `canPrefetchLoadingShell` is always `false` for Pages routes — Pages
+ * does not have a separate loading boundary and its prefetch surface is
+ * `_next/data/<buildId>/<page>.json`.
+ */
+type VinextPagesLinkPrefetchRoute = {
+  canPrefetchLoadingShell: false;
+  documentOnly?: boolean;
+  isDynamic: boolean;
+  patternParts: string[];
+};
+type VinextNextData = {
+  /** vinext-specific additions (not part of Next.js upstream). */__vinext?: {
+    /** Absolute URL of the page module for dynamic import. */pageModuleUrl?: string; /** Absolute URL of the `_app` module for dynamic import. */
+    appModuleUrl?: string; /** True when the Pages Router server has middleware/proxy configured. */
+    hasMiddleware?: boolean; /** True when build-time rewrites can affect the initial Pages Router ready state. */
+    hasRewrites?: boolean;
+  };
+} & NEXT_DATA;
+type BrowserVinextNextData = NonNullable<Window["__NEXT_DATA__"]> & VinextNextData;
+type VinextLocaleGlobalTarget = {
+  __VINEXT_LOCALE__: string | undefined;
+  __VINEXT_LOCALES__: string[] | undefined;
+  __VINEXT_DEFAULT_LOCALE__: string | undefined;
+};
+declare function extractVinextNextDataJson(html: string): string | null;
+declare function parseVinextNextDataJson(json: string): BrowserVinextNextData;
+declare function applyVinextLocaleGlobals(target: VinextLocaleGlobalTarget, nextData: VinextNextData): void;
+//#endregion
+export { VinextLinkPrefetchRoute, VinextNextData, VinextPagesLinkPrefetchRoute, applyVinextLocaleGlobals, extractVinextNextDataJson, parseVinextNextDataJson };