vinext 0.0.53 → 0.0.55

package/dist/shims/internal/app-route-detection.d.ts

@@ -0,0 +1,37 @@
+import { VinextLinkPrefetchRoute } from "../../client/vinext-next-data.js";
+
+//#region src/shims/internal/app-route-detection.d.ts
+declare global {
+  interface Window {
+    __VINEXT_LINK_PREFETCH_ROUTES__?: VinextLinkPrefetchRoute[];
+  }
+}
+/**
+ * Pages Router `components` map shape. Next.js types this loosely (route
+ * pattern → `PrivateRouteInfo`), but for the App Router-detected case it
+ * stores `{ __appRouter: true }` as a marker (see Next.js source link above).
+ * Vinext only writes the marker variant; reads are by test code that checks
+ * for `__appRouter: true`.
+ */
+type PagesRouterComponentsMap = Record<string, {
+  __appRouter: true;
+} | Record<string, unknown>>;
+/**
+ * Get-or-create the Pages Router `components` map. Returns the same object
+ * on every call so `router.components` and `window.next.router.components`
+ * have referential identity.
+ */
+declare function getPagesRouterComponentsMap(): PagesRouterComponentsMap;
+/**
+ * Record `components[pathname] = { __appRouter: true }` on the shared
+ * Pages Router map when the href matches an App Router route. No-op when the
+ * manifest is absent, the URL is external, or no app route matches.
+ *
+ * `pathname` is the basePath-stripped path — matching Next.js's
+ * `router.components[urlPathname]` key (see the source link in this file's
+ * leading comment).
+ */
+declare function markAppRouteDetectedOnPrefetch(href: string, basePath: string): void;
+//#endregion
+export { getPagesRouterComponentsMap, markAppRouteDetectedOnPrefetch };
+//# sourceMappingURL=app-route-detection.d.ts.map

package/dist/shims/internal/app-route-detection.js

@@ -0,0 +1,69 @@
+import { stripBasePath } from "../../utils/base-path.js";
+import { createRouteTrieCache, matchRouteWithTrie } from "../../routing/route-matching.js";
+//#region src/shims/internal/app-route-detection.ts
+const appRouteTrieCache = createRouteTrieCache();
+const _COMPONENTS_KEY = Symbol.for("vinext.pagesRouter.components");
+/**
+* Get-or-create the Pages Router `components` map. Returns the same object
+* on every call so `router.components` and `window.next.router.components`
+* have referential identity.
+*/
+function getPagesRouterComponentsMap() {
+	const globalState = globalThis;
+	let components = globalState[_COMPONENTS_KEY];
+	if (!components) {
+		components = {};
+		globalState[_COMPONENTS_KEY] = components;
+	}
+	return components;
+}
+/**
+* Resolve a prefetch href to a same-origin pathname (basePath-stripped),
+* suitable as the key used by Next.js for `router.components[urlPathname]`.
+*
+* Returns null for external URLs, malformed URLs, or non-browser contexts.
+*/
+function resolveSameOriginPathname(href, basePath) {
+	if (typeof window === "undefined") return null;
+	let url;
+	try {
+		url = new URL(href, window.location.href);
+	} catch {
+		return null;
+	}
+	if (url.origin !== window.location.origin) return null;
+	return stripBasePath(url.pathname, basePath);
+}
+/**
+* Returns true when the prefetch href matches any route in the App Router
+* prefetch manifest (static or dynamic). Returns false when the manifest is
+* absent (Pages-Router-only build), the URL is external, or no route matches.
+*/
+function matchesAppRoute(href, basePath) {
+	if (typeof window === "undefined") return false;
+	const routes = window.__VINEXT_LINK_PREFETCH_ROUTES__;
+	if (!routes || routes.length === 0) return false;
+	const pathname = resolveSameOriginPathname(href, basePath);
+	if (pathname === null) return false;
+	return matchRouteWithTrie(pathname, routes, appRouteTrieCache) !== null;
+}
+/**
+* Record `components[pathname] = { __appRouter: true }` on the shared
+* Pages Router map when the href matches an App Router route. No-op when the
+* manifest is absent, the URL is external, or no app route matches.
+*
+* `pathname` is the basePath-stripped path — matching Next.js's
+* `router.components[urlPathname]` key (see the source link in this file's
+* leading comment).
+*/
+function markAppRouteDetectedOnPrefetch(href, basePath) {
+	if (typeof window === "undefined") return;
+	if (!matchesAppRoute(href, basePath)) return;
+	const pathname = resolveSameOriginPathname(href, basePath);
+	if (pathname === null) return;
+	getPagesRouterComponentsMap()[pathname] = { __appRouter: true };
+}
+//#endregion
+export { getPagesRouterComponentsMap, markAppRouteDetectedOnPrefetch };
+
+//# sourceMappingURL=app-route-detection.js.map

package/dist/shims/internal/app-route-detection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-route-detection.js","names":[],"sources":["../../../src/shims/internal/app-route-detection.ts"],"sourcesContent":["/**\n * Shared helper for marking an App Router route as \"detected\" on the Pages\n * Router singleton when a `<Link>` or `Router.prefetch` targets it.\n *\n * Ported from Next.js: `packages/next/src/shared/lib/router/router.ts:2525`\n *\n *     if (await this._bfl(asPath, resolvedAs, options.locale, true)) {\n *       this.components[urlPathname] = { __appRouter: true } as any\n *     }\n *\n * Next.js uses a bloom filter (`_bfl`) of App Router routes that the Pages\n * Router cannot handle. When the prefetch target matches the filter, the\n * Pages Router records the route on `this.components` with\n * `{ __appRouter: true }`. The Next.js deploy test\n *   test/e2e/app-dir/app/index.test.ts → \"should successfully detect app\n *   route during prefetch\"\n * reads this through `window.next.router.components[\"/dashboard\"]`.\n *\n * Vinext does not need a bloom filter — the App Router prefetch route\n * manifest (`__VINEXT_LINK_PREFETCH_ROUTES__`) already lives on the client\n * for Link's App Router auto-prefetch decisions. This helper reuses that\n * manifest and the shared trie matcher to decide whether a prefetch target\n * is an App Router route.\n *\n * Lives in `shims/internal/` so both the Pages Router (`router.ts`) and the\n * Link shim's Pages-mode branch (`link.tsx`) can call it without pulling in\n * the other shim at module init.\n *\n * The components map is stored behind a `Symbol.for` global so the Pages\n * Router (`router.ts`) and the Link shim (`link.tsx`) both write through the\n * same instance even when Vite loads the router shim through a different\n * resolved module ID than the link shim (mirrors the same module-split\n * mitigation used by `navigation.ts`'s GLOBAL_ACCESSORS_KEY).\n *\n * Issue: https://github.com/cloudflare/vinext/issues/1526\n */\nimport type { VinextLinkPrefetchRoute } from \"../../client/vinext-next-data.js\";\nimport { createRouteTrieCache, matchRouteWithTrie } from \"../../routing/route-matching.js\";\nimport { stripBasePath } from \"../../utils/base-path.js\";\n\nconst appRouteTrieCache = createRouteTrieCache<VinextLinkPrefetchRoute>();\n\ndeclare global {\n  // oxlint-disable-next-line typescript-eslint/consistent-type-definitions\n  interface Window {\n    __VINEXT_LINK_PREFETCH_ROUTES__?: VinextLinkPrefetchRoute[];\n  }\n}\n\n/**\n * Pages Router `components` map shape. Next.js types this loosely (route\n * pattern → `PrivateRouteInfo`), but for the App Router-detected case it\n * stores `{ __appRouter: true }` as a marker (see Next.js source link above).\n * Vinext only writes the marker variant; reads are by test code that checks\n * for `__appRouter: true`.\n */\ntype PagesRouterComponentsMap = Record<string, { __appRouter: true } | Record<string, unknown>>;\n\nconst _COMPONENTS_KEY = Symbol.for(\"vinext.pagesRouter.components\");\ntype _GlobalWithComponents = typeof globalThis & {\n  [_COMPONENTS_KEY]?: PagesRouterComponentsMap;\n};\n\n/**\n * Get-or-create the Pages Router `components` map. Returns the same object\n * on every call so `router.components` and `window.next.router.components`\n * have referential identity.\n */\nexport function getPagesRouterComponentsMap(): PagesRouterComponentsMap {\n  const globalState = globalThis as _GlobalWithComponents;\n  let components = globalState[_COMPONENTS_KEY];\n  if (!components) {\n    components = {};\n    globalState[_COMPONENTS_KEY] = components;\n  }\n  return components;\n}\n\n/**\n * Resolve a prefetch href to a same-origin pathname (basePath-stripped),\n * suitable as the key used by Next.js for `router.components[urlPathname]`.\n *\n * Returns null for external URLs, malformed URLs, or non-browser contexts.\n */\nfunction resolveSameOriginPathname(href: string, basePath: string): string | null {\n  if (typeof window === \"undefined\") return null;\n  let url: URL;\n  try {\n    url = new URL(href, window.location.href);\n  } catch {\n    return null;\n  }\n  if (url.origin !== window.location.origin) return null;\n  return stripBasePath(url.pathname, basePath);\n}\n\n/**\n * Returns true when the prefetch href matches any route in the App Router\n * prefetch manifest (static or dynamic). Returns false when the manifest is\n * absent (Pages-Router-only build), the URL is external, or no route matches.\n */\nfunction matchesAppRoute(href: string, basePath: string): boolean {\n  if (typeof window === \"undefined\") return false;\n  const routes = window.__VINEXT_LINK_PREFETCH_ROUTES__;\n  if (!routes || routes.length === 0) return false;\n\n  const pathname = resolveSameOriginPathname(href, basePath);\n  if (pathname === null) return false;\n\n  return matchRouteWithTrie(pathname, routes, appRouteTrieCache) !== null;\n}\n\n/**\n * Record `components[pathname] = { __appRouter: true }` on the shared\n * Pages Router map when the href matches an App Router route. No-op when the\n * manifest is absent, the URL is external, or no app route matches.\n *\n * `pathname` is the basePath-stripped path — matching Next.js's\n * `router.components[urlPathname]` key (see the source link in this file's\n * leading comment).\n */\nexport function markAppRouteDetectedOnPrefetch(href: string, basePath: string): void {\n  if (typeof window === \"undefined\") return;\n  if (!matchesAppRoute(href, basePath)) return;\n\n  const pathname = resolveSameOriginPathname(href, basePath);\n  if (pathname === null) return;\n\n  getPagesRouterComponentsMap()[pathname] = { __appRouter: true };\n}\n"],"mappings":";;;AAwCA,MAAM,oBAAoB,sBAA+C;AAkBzE,MAAM,kBAAkB,OAAO,IAAI,gCAAgC;;;;;;AAUnE,SAAgB,8BAAwD;CACtE,MAAM,cAAc;CACpB,IAAI,aAAa,YAAY;CAC7B,IAAI,CAAC,YAAY;EACf,aAAa,EAAE;EACf,YAAY,mBAAmB;;CAEjC,OAAO;;;;;;;;AAST,SAAS,0BAA0B,MAAc,UAAiC;CAChF,IAAI,OAAO,WAAW,aAAa,OAAO;CAC1C,IAAI;CACJ,IAAI;EACF,MAAM,IAAI,IAAI,MAAM,OAAO,SAAS,KAAK;SACnC;EACN,OAAO;;CAET,IAAI,IAAI,WAAW,OAAO,SAAS,QAAQ,OAAO;CAClD,OAAO,cAAc,IAAI,UAAU,SAAS;;;;;;;AAQ9C,SAAS,gBAAgB,MAAc,UAA2B;CAChE,IAAI,OAAO,WAAW,aAAa,OAAO;CAC1C,MAAM,SAAS,OAAO;CACtB,IAAI,CAAC,UAAU,OAAO,WAAW,GAAG,OAAO;CAE3C,MAAM,WAAW,0BAA0B,MAAM,SAAS;CAC1D,IAAI,aAAa,MAAM,OAAO;CAE9B,OAAO,mBAAmB,UAAU,QAAQ,kBAAkB,KAAK;;;;;;;;;;;AAYrE,SAAgB,+BAA+B,MAAc,UAAwB;CACnF,IAAI,OAAO,WAAW,aAAa;CACnC,IAAI,CAAC,gBAAgB,MAAM,SAAS,EAAE;CAEtC,MAAM,WAAW,0BAA0B,MAAM,SAAS;CAC1D,IAAI,aAAa,MAAM;CAEvB,6BAA6B,CAAC,YAAY,EAAE,aAAa,MAAM"}

package/dist/shims/internal/pages-data-fetch-dedup.d.ts

@@ -0,0 +1,56 @@
+//#region src/shims/internal/pages-data-fetch-dedup.d.ts
+/**
+ * In-flight request dedup for the Pages Router `/_next/data/<id>/<page>.json`
+ * endpoint.
+ *
+ * Why this exists: when a user (or app code) triggers several near-simultaneous
+ * navigations to the same gSSP route — e.g. clicking the same `<Link>` multiple
+ * times before the first navigation lands — each call to `Router.push` would
+ * otherwise enter its own `navigateClientData()` flow and dispatch its own
+ * `fetch()` against the data endpoint. That balloons server load and breaks
+ * Next.js' documented "one fetch per unique data URL" guarantee.
+ *
+ * Ported from Next.js: `fetchNextData()` in
+ * `packages/next/src/shared/lib/router/router.ts`. Next.js maintains an
+ * `inflightCache` (keyed by the resolved data URL) and reuses the existing
+ * Promise when a concurrent caller asks for the same URL. The entry is
+ * dropped once the fetch settles (success or rejection) so the next
+ * navigation re-fetches fresh.
+ *
+ * Design notes:
+ *
+ * - Callers receive a cloned Response, so each can independently consume the
+ *   body (`.json()`, `.text()`, etc.). The originating Response is never read
+ *   directly by anyone, which keeps subsequent clones legal even after one
+ *   caller has consumed its copy.
+ *
+ * - No `AbortSignal` is honored at the shared layer. Each `Router.push` cycle
+ *   has its own AbortController that supersedes prior navigations via
+ *   `_navigationId`; aborting the shared fetch on behalf of one caller would
+ *   destroy the dedup gain for every other concurrent caller. Cancellation is
+ *   handled by the caller's `assertStillCurrent()` checkpoints after `await`,
+ *   not by abort propagation.
+ *
+ * - The map is module-scoped (one per realm). The Pages Router runs in the
+ *   browser only, so a single `Map` is sufficient.
+ */
+/**
+ * Dedupe a `fetch()` against the `_next/data` endpoint. Multiple concurrent
+ * callers for the same `dataHref` share one underlying network request.
+ *
+ * Each call returns a freshly-cloned `Response` so consumers can read the
+ * body independently. Once the in-flight Promise settles (resolve or reject)
+ * the entry is removed, and the next call will hit the network again.
+ *
+ * Errors propagate to every concurrent caller — the in-flight entry is
+ * dropped on failure so the next navigation can retry.
+ */
+declare function dedupedPagesDataFetch(dataHref: string, init?: RequestInit): Promise<Response>;
+/**
+ * Drop every cached in-flight entry. Intended for tests; production code
+ * does not need to call this because entries self-evict on settle.
+ */
+declare function clearPagesDataInflight(): void;
+//#endregion
+export { clearPagesDataInflight, dedupedPagesDataFetch };
+//# sourceMappingURL=pages-data-fetch-dedup.d.ts.map

package/dist/shims/internal/pages-data-fetch-dedup.js

@@ -0,0 +1,70 @@
+//#region src/shims/internal/pages-data-fetch-dedup.ts
+/**
+* In-flight request dedup for the Pages Router `/_next/data/<id>/<page>.json`
+* endpoint.
+*
+* Why this exists: when a user (or app code) triggers several near-simultaneous
+* navigations to the same gSSP route — e.g. clicking the same `<Link>` multiple
+* times before the first navigation lands — each call to `Router.push` would
+* otherwise enter its own `navigateClientData()` flow and dispatch its own
+* `fetch()` against the data endpoint. That balloons server load and breaks
+* Next.js' documented "one fetch per unique data URL" guarantee.
+*
+* Ported from Next.js: `fetchNextData()` in
+* `packages/next/src/shared/lib/router/router.ts`. Next.js maintains an
+* `inflightCache` (keyed by the resolved data URL) and reuses the existing
+* Promise when a concurrent caller asks for the same URL. The entry is
+* dropped once the fetch settles (success or rejection) so the next
+* navigation re-fetches fresh.
+*
+* Design notes:
+*
+* - Callers receive a cloned Response, so each can independently consume the
+*   body (`.json()`, `.text()`, etc.). The originating Response is never read
+*   directly by anyone, which keeps subsequent clones legal even after one
+*   caller has consumed its copy.
+*
+* - No `AbortSignal` is honored at the shared layer. Each `Router.push` cycle
+*   has its own AbortController that supersedes prior navigations via
+*   `_navigationId`; aborting the shared fetch on behalf of one caller would
+*   destroy the dedup gain for every other concurrent caller. Cancellation is
+*   handled by the caller's `assertStillCurrent()` checkpoints after `await`,
+*   not by abort propagation.
+*
+* - The map is module-scoped (one per realm). The Pages Router runs in the
+*   browser only, so a single `Map` is sufficient.
+*/
+/** Inflight fetch promises keyed by the resolved data URL. */
+const inflight = /* @__PURE__ */ new Map();
+/**
+* Dedupe a `fetch()` against the `_next/data` endpoint. Multiple concurrent
+* callers for the same `dataHref` share one underlying network request.
+*
+* Each call returns a freshly-cloned `Response` so consumers can read the
+* body independently. Once the in-flight Promise settles (resolve or reject)
+* the entry is removed, and the next call will hit the network again.
+*
+* Errors propagate to every concurrent caller — the in-flight entry is
+* dropped on failure so the next navigation can retry.
+*/
+function dedupedPagesDataFetch(dataHref, init) {
+	let entry = inflight.get(dataHref);
+	if (!entry) {
+		entry = fetch(dataHref, init).finally(() => {
+			if (inflight.get(dataHref) === entry) inflight.delete(dataHref);
+		});
+		inflight.set(dataHref, entry);
+	}
+	return entry.then((res) => res.clone());
+}
+/**
+* Drop every cached in-flight entry. Intended for tests; production code
+* does not need to call this because entries self-evict on settle.
+*/
+function clearPagesDataInflight() {
+	inflight.clear();
+}
+//#endregion
+export { clearPagesDataInflight, dedupedPagesDataFetch };
+
+//# sourceMappingURL=pages-data-fetch-dedup.js.map

package/dist/shims/internal/pages-data-fetch-dedup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pages-data-fetch-dedup.js","names":[],"sources":["../../../src/shims/internal/pages-data-fetch-dedup.ts"],"sourcesContent":["/**\n * In-flight request dedup for the Pages Router `/_next/data/<id>/<page>.json`\n * endpoint.\n *\n * Why this exists: when a user (or app code) triggers several near-simultaneous\n * navigations to the same gSSP route — e.g. clicking the same `<Link>` multiple\n * times before the first navigation lands — each call to `Router.push` would\n * otherwise enter its own `navigateClientData()` flow and dispatch its own\n * `fetch()` against the data endpoint. That balloons server load and breaks\n * Next.js' documented \"one fetch per unique data URL\" guarantee.\n *\n * Ported from Next.js: `fetchNextData()` in\n * `packages/next/src/shared/lib/router/router.ts`. Next.js maintains an\n * `inflightCache` (keyed by the resolved data URL) and reuses the existing\n * Promise when a concurrent caller asks for the same URL. The entry is\n * dropped once the fetch settles (success or rejection) so the next\n * navigation re-fetches fresh.\n *\n * Design notes:\n *\n * - Callers receive a cloned Response, so each can independently consume the\n *   body (`.json()`, `.text()`, etc.). The originating Response is never read\n *   directly by anyone, which keeps subsequent clones legal even after one\n *   caller has consumed its copy.\n *\n * - No `AbortSignal` is honored at the shared layer. Each `Router.push` cycle\n *   has its own AbortController that supersedes prior navigations via\n *   `_navigationId`; aborting the shared fetch on behalf of one caller would\n *   destroy the dedup gain for every other concurrent caller. Cancellation is\n *   handled by the caller's `assertStillCurrent()` checkpoints after `await`,\n *   not by abort propagation.\n *\n * - The map is module-scoped (one per realm). The Pages Router runs in the\n *   browser only, so a single `Map` is sufficient.\n */\n\n/** Inflight fetch promises keyed by the resolved data URL. */\nconst inflight = new Map<string, Promise<Response>>();\n\n/**\n * Dedupe a `fetch()` against the `_next/data` endpoint. Multiple concurrent\n * callers for the same `dataHref` share one underlying network request.\n *\n * Each call returns a freshly-cloned `Response` so consumers can read the\n * body independently. Once the in-flight Promise settles (resolve or reject)\n * the entry is removed, and the next call will hit the network again.\n *\n * Errors propagate to every concurrent caller — the in-flight entry is\n * dropped on failure so the next navigation can retry.\n */\nexport function dedupedPagesDataFetch(dataHref: string, init?: RequestInit): Promise<Response> {\n  let entry = inflight.get(dataHref);\n  if (!entry) {\n    entry = fetch(dataHref, init).finally(() => {\n      // Only drop the entry if it still matches the one we set. A racing\n      // caller could in principle overwrite, but inflight is keyed by URL\n      // and we never overwrite on a hit, so this check is defensive.\n      if (inflight.get(dataHref) === entry) inflight.delete(dataHref);\n    });\n    inflight.set(dataHref, entry);\n  }\n  // Always return a clone so each consumer gets an independently-readable\n  // body. The original `entry` Response is never consumed directly, so\n  // cloning remains valid for every caller (including the first).\n  return entry.then((res) => res.clone());\n}\n\n/**\n * Drop every cached in-flight entry. Intended for tests; production code\n * does not need to call this because entries self-evict on settle.\n */\nexport function clearPagesDataInflight(): void {\n  inflight.clear();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,MAAM,2BAAW,IAAI,KAAgC;;;;;;;;;;;;AAarD,SAAgB,sBAAsB,UAAkB,MAAuC;CAC7F,IAAI,QAAQ,SAAS,IAAI,SAAS;CAClC,IAAI,CAAC,OAAO;EACV,QAAQ,MAAM,UAAU,KAAK,CAAC,cAAc;GAI1C,IAAI,SAAS,IAAI,SAAS,KAAK,OAAO,SAAS,OAAO,SAAS;IAC/D;EACF,SAAS,IAAI,UAAU,MAAM;;CAK/B,OAAO,MAAM,MAAM,QAAQ,IAAI,OAAO,CAAC;;;;;;AAOzC,SAAgB,yBAA+B;CAC7C,SAAS,OAAO"}

package/dist/shims/link.d.ts

@@ -21,7 +21,15 @@ type LinkProps = {
    * is upgraded to a full prefetch when the user shows navigation intent.
    */
   unstable_dynamicOnHover?: boolean; /** Whether to pass the href to the child element */
-  passHref?: boolean; /** Scroll to top on navigation (default: true) */
+  passHref?: boolean;
+  /**
+   * Pre-Next.js-13 link behaviour. When true, <Link> expects its child to be
+   * an `<a>` (or a component that renders one) and forwards `href`, click,
+   * and prefetch handlers to the child via `React.cloneElement` instead of
+   * rendering its own wrapping `<a>`. Required when the user wants to
+   * style/instrument the anchor themselves.
+   */
+  legacyBehavior?: boolean; /** Scroll to top on navigation (default: true) */
   scroll?: boolean;
   /**
    * Pages Router: update the URL without re-running data fetching methods
@@ -68,7 +76,15 @@ declare const Link: React.ForwardRefExoticComponent<{
    * is upgraded to a full prefetch when the user shows navigation intent.
    */
   unstable_dynamicOnHover?: boolean; /** Whether to pass the href to the child element */
-  passHref?: boolean; /** Scroll to top on navigation (default: true) */
+  passHref?: boolean;
+  /**
+   * Pre-Next.js-13 link behaviour. When true, <Link> expects its child to be
+   * an `<a>` (or a component that renders one) and forwards `href`, click,
+   * and prefetch handlers to the child via `React.cloneElement` instead of
+   * rendering its own wrapping `<a>`. Required when the user wants to
+   * style/instrument the anchor themselves.
+   */
+  legacyBehavior?: boolean; /** Scroll to top on navigation (default: true) */
   scroll?: boolean;
   /**
    * Pages Router: update the URL without re-running data fetching methods

package/dist/shims/link.js

@@ -3,15 +3,16 @@ import { stripBasePath } from "../utils/base-path.js";
 import { createRouteTrieCache, matchRouteWithTrie } from "../routing/route-matching.js";
 import { VINEXT_MOUNTED_SLOTS_HEADER } from "../server/headers.js";
 import { isDangerousScheme, reportBlockedDangerousNavigation } from "./url-safety.js";
-import { appendSearchParamsToUrl, urlQueryToSearchParams } from "../utils/query.js";
 import { AppElementsWire } from "../server/app-elements-wire.js";
 import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL } from "../server/app-rsc-render-mode.js";
+import "../server/app-elements.js";
 import { addLocalePrefix, getDomainLocaleUrl } from "../utils/domain-locale.js";
 import { prefetchPagesData, resolvePagesDataNavigationTarget } from "./internal/pages-data-target.js";
+import { markAppRouteDetectedOnPrefetch } from "./internal/app-route-detection.js";
 import { isAbsoluteOrProtocolRelativeUrl, normalizePathTrailingSlash, resolveRelativeHref, toBrowserNavigationHref, toSameOriginAppPath, withBasePath } from "./url-utils.js";
+import { appendSearchParamsToUrl, urlQueryToSearchParams } from "../utils/query.js";
 import { getCurrentBrowserLocale } from "./client-locale.js";
 import { getNavigationRuntime, hasAppNavigationRuntime, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
-import "../server/app-elements.js";
 import { createRscRequestHeaders, createRscRequestUrl, stripRscCacheBustingSearchParam, stripRscSuffix } from "../server/app-rsc-cache-busting.js";
 import { getMountedSlotsHeader, getPrefetchCache, getPrefetchInterceptionContext, getPrefetchedUrls, navigateClientSide, prefetchRscResponse } from "./navigation.js";
 import { navigatePagesRouterLink } from "../client/pages-router-link-navigation.js";
@@ -40,6 +41,7 @@ function useLinkStatus() {
 const __basePath = process.env.__NEXT_ROUTER_BASEPATH ?? "";
 /** trailingSlash from next.config.js, injected by the plugin at build time */
 const __trailingSlash = process.env.__VINEXT_TRAILING_SLASH === "true";
+const __prefetchInlining = process.env.__VINEXT_PREFETCH_INLINING === "true";
 const linkPrefetchRouteTrieCache = createRouteTrieCache();
 function resolveHref(href) {
 	if (typeof href === "string") return href;
@@ -167,7 +169,11 @@ function prefetchUrl(href, mode, priority = "low") {
 	});
 	if (prefetchHref == null) return;
 	const fullHref = toBrowserNavigationHref(prefetchHref, window.location.href, __basePath);
-	(window.requestIdleCallback ?? ((fn) => setTimeout(fn, 100)))(() => {
+	const target = new URL(fullHref, window.location.href);
+	if (target.origin === window.location.origin && target.pathname === window.location.pathname && target.search === window.location.search) return;
+	(priority === "high" ? (fn) => {
+		fn();
+	} : window.requestIdleCallback ?? ((fn) => setTimeout(fn, 100)))(() => {
 		(async () => {
 			if (hasAppNavigationRuntime()) {
 				const autoPrefetch = mode === "auto" ? resolveAutoAppRoutePrefetch(prefetchHref) : {
@@ -195,7 +201,28 @@ function prefetchUrl(href, mode, priority = "low") {
 					return;
 				}
 				prefetched.add(cacheKey);
-				prefetchRscResponse(rscUrl, fetch(rscUrl, {
+				prefetchRscResponse(rscUrl, __prefetchInlining && autoPrefetch.cacheForNavigation ? (async () => {
+					const shellHeaders = createRscRequestHeaders({
+						interceptionContext,
+						renderMode: APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL
+					});
+					if (mountedSlotsHeader) shellHeaders.set(VINEXT_MOUNTED_SLOTS_HEADER, mountedSlotsHeader);
+					const shellRscUrl = await createRscRequestUrl(fullHref, shellHeaders);
+					const shellResponse = await fetch(shellRscUrl, {
+						headers: shellHeaders,
+						credentials: "include",
+						priority,
+						purpose: "prefetch"
+					});
+					if (!shellResponse.ok) return shellResponse;
+					await shellResponse.arrayBuffer().catch(() => {});
+					return fetch(rscUrl, {
+						headers,
+						credentials: "include",
+						priority,
+						purpose: "prefetch"
+					});
+				})() : fetch(rscUrl, {
 					headers,
 					credentials: "include",
 					priority,
@@ -208,6 +235,7 @@ function prefetchUrl(href, mode, priority = "low") {
 				const dataTarget = resolvePagesDataNavigationTarget(fullHref, __basePath);
 				if (dataTarget) prefetchPagesData(dataTarget);
 				else {
+					markAppRouteDetectedOnPrefetch(fullHref, __basePath);
 					const link = document.createElement("link");
 					link.rel = "prefetch";
 					link.href = fullHref;
@@ -334,8 +362,10 @@ function applyLocaleToHref(href, locale) {
 	}
 	return addLocalePrefix(href, resolvedLocale, defaultLocale);
 }
-const Link = forwardRef(function Link({ href, as, replace = false, prefetch: prefetchProp, scroll = true, shallow = false, children, onClick, onMouseEnter, onTouchStart, onNavigate, unstable_dynamicOnHover = false, ...rest }, forwardedRef) {
+const Link = forwardRef(function Link({ href, as, replace = false, prefetch: prefetchProp, scroll = true, shallow = false, children: childrenProp, onClick, onMouseEnter, onTouchStart, onNavigate, unstable_dynamicOnHover = false, legacyBehavior = false, passHref = false, ...rest }, forwardedRef) {
 	const { locale, ...restWithoutLocale } = rest;
+	let children = childrenProp;
+	if (legacyBehavior && (typeof childrenProp === "string" || typeof childrenProp === "number")) children = React.createElement("a", null, childrenProp);
 	const rawResolvedHref = as ?? resolveHref(href);
 	const resolvedHref = typeof rawResolvedHref === "string" ? warnAndNormalizeRepeatedSlashesInHref(rawResolvedHref) : rawResolvedHref;
 	const isDangerous = typeof resolvedHref === "string" && isDangerousScheme(resolvedHref);
@@ -422,8 +452,8 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 		onTouchStart?.(e);
 		prefetchOnIntent();
 	}, [onTouchStart, prefetchOnIntent]);
-	const handleClick = async (e) => {
-		if (onClick) onClick(e);
+	const handleClick = async (e, options = {}) => {
+		if (!options.skipLinkOnClick && onClick) onClick(e);
 		if (e.defaultPrevented) return;
 		if (e.currentTarget.hasAttribute("download")) return;
 		if (e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
@@ -481,7 +511,7 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 			window.dispatchEvent(new PopStateEvent("popstate"));
 		}
 	};
-	const { passHref: _p, ...anchorProps } = restWithoutLocale;
+	const anchorProps = restWithoutLocale;
 	const linkStatusValue = React.useMemo(() => ({ pending }), [pending]);
 	if (isDangerous) {
 		if (process.env.NODE_ENV !== "production") console.warn(`<Link> blocked dangerous href: ${resolvedHref}`);
@@ -489,6 +519,26 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 			if (onClick) onClick(event);
 			reportBlockedDangerousNavigation();
 		};
+		if (legacyBehavior) {
+			const child = React.Children.only(children);
+			const childOnClick = child.props.onClick;
+			const childRef = child.props.ref;
+			const setDangerousRefs = (node) => {
+				internalRef.current = node;
+				if (typeof childRef === "function") childRef(node);
+				else if (childRef) childRef.current = node;
+			};
+			return /* @__PURE__ */ jsx(LinkStatusContext.Provider, {
+				value: linkStatusValue,
+				children: React.cloneElement(child, {
+					ref: setDangerousRefs,
+					onClick: (event) => {
+						if (childOnClick) childOnClick(event);
+						reportBlockedDangerousNavigation();
+					}
+				})
+			});
+		}
 		return /* @__PURE__ */ jsx(LinkStatusContext.Provider, {
 			value: linkStatusValue,
 			children: /* @__PURE__ */ jsx("a", {
@@ -501,6 +551,46 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 			})
 		});
 	}
+	if (legacyBehavior) {
+		const child = React.Children.only(children);
+		if (process.env.NODE_ENV !== "production") {
+			if (onClick) console.warn(`"onClick" was passed to <Link> with \`href\` of \`${resolveHref(href)}\` but "legacyBehavior" was set. The legacy behavior requires onClick be set on the child of next/link`);
+			if (onMouseEnter) console.warn(`"onMouseEnter" was passed to <Link> with \`href\` of \`${resolveHref(href)}\` but "legacyBehavior" was set. The legacy behavior requires onMouseEnter be set on the child of next/link`);
+		}
+		const childPropsExisting = child.props;
+		const childHasOwnHref = child.type === "a" ? "href" in childPropsExisting : false;
+		const shouldForwardHref = passHref || child.type === "a" && !childHasOwnHref;
+		const childOnClick = childPropsExisting.onClick;
+		const childOnMouseEnter = childPropsExisting.onMouseEnter;
+		const childOnTouchStart = childPropsExisting.onTouchStart;
+		const childRef = childPropsExisting.ref;
+		const setLegacyRefs = (node) => {
+			internalRef.current = node;
+			if (typeof childRef === "function") childRef(node);
+			else if (childRef) childRef.current = node;
+		};
+		const clonedProps = {
+			ref: setLegacyRefs,
+			onClick: (event) => {
+				if (childOnClick) childOnClick(event);
+				if (event.defaultPrevented) return;
+				handleClick(event, { skipLinkOnClick: true });
+			},
+			onMouseEnter: (event) => {
+				if (childOnMouseEnter) childOnMouseEnter(event);
+				prefetchOnIntent();
+			},
+			onTouchStart: (event) => {
+				if (childOnTouchStart) childOnTouchStart(event);
+				prefetchOnIntent();
+			}
+		};
+		if (shouldForwardHref) clonedProps.href = fullHref;
+		return /* @__PURE__ */ jsx(LinkStatusContext.Provider, {
+			value: linkStatusValue,
+			children: React.cloneElement(child, clonedProps)
+		});
+	}
 	return /* @__PURE__ */ jsx(LinkStatusContext.Provider, {
 		value: linkStatusValue,
 		children: /* @__PURE__ */ jsx("a", {