@qzsy/vinext 0.1.7

package/dist/shims/internal/pages-data-target.js

@@ -0,0 +1,98 @@
+import { stripBasePath } from "../../utils/base-path.js";
+import { getLocalePathPrefix } from "../../utils/domain-locale.js";
+import { buildPagesDataHref, matchPagesPattern } from "./pages-data-url.js";
+import { NEXT_DEPLOYMENT_ID_HEADER, getDeploymentId } from "../../utils/deployment-id.js";
+import { dedupedPagesDataFetch } from "./pages-data-fetch-dedup.js";
+//#region src/shims/internal/pages-data-target.ts
+/**
+* Shared decision helper for the Pages Router `/_next/data/<id>/<page>.json`
+* navigation fast path. Used by both the router shim (for `navigateClient` and
+* `Router.prefetch`) and the Link shim (for hover/viewport prefetch).
+*
+* Lives in `shims/internal/` so neither caller pulls in the router shim at
+* module init time — link.tsx and router.ts must remain free of circular
+* imports and SSR-side router-init side effects.
+*/
+/**
+* Decide whether the JSON data-endpoint navigation path is usable for this
+* browser URL. We require:
+*   - A registered code-split loader for the matched route pattern. Without
+*     this, the client has no chunk URL to import for the new page.
+*   - A buildId on the current `__NEXT_DATA__`, since the data URL embeds it.
+*   - Same-origin (cross-origin URLs do not hit our data endpoint).
+*
+* Locale handling: route patterns in `__VINEXT_PAGE_PATTERNS__` are
+* locale-unaware (`/about`, not `/fr/about`), but the browser URL for a
+* locale-prefixed page is `/fr/about`. We strip the locale prefix before
+* pattern matching so locale transitions hit the JSON fast path. The data URL
+* itself keeps the locale prefix because the server uses it to pick
+* locale-specific gSSP data.
+*
+* Returns the resolved target, or `null` to signal the caller should fall
+* back to the HTML extraction path (dev server, or a route that exists on the
+* server but is not in the client loader map).
+*
+* Ported from Next.js: `packages/next/src/client/page-loader.ts`
+* (`getDataHref`). vinext's equivalent uses an in-memory loader map instead
+* of Next.js' `_buildManifest.js`.
+*/
+function resolvePagesDataNavigationTarget(browserUrl, basePath) {
+	if (typeof window === "undefined") return null;
+	const loaders = window.__VINEXT_PAGE_LOADERS__;
+	const patterns = window.__VINEXT_PAGE_PATTERNS__;
+	if (!loaders || !patterns || patterns.length === 0) return null;
+	const buildId = window.__NEXT_DATA__?.buildId ?? void 0;
+	if (!buildId) return null;
+	let parsed;
+	try {
+		parsed = new URL(browserUrl, window.location.href);
+	} catch {
+		return null;
+	}
+	if (parsed.origin !== window.location.origin) return null;
+	const pagePath = stripBasePath(parsed.pathname, basePath);
+	const locale = getLocalePathPrefix(pagePath, window.__VINEXT_LOCALES__);
+	const match = matchPagesPattern(locale ? pagePath.slice(locale.length + 1) || "/" : pagePath, patterns);
+	if (!match) return null;
+	const loader = loaders[match.pattern];
+	if (!loader) return null;
+	return {
+		dataHref: buildPagesDataHref(basePath, buildId, pagePath, parsed.search),
+		pattern: match.pattern,
+		params: match.params,
+		loader,
+		buildId,
+		pagePath,
+		search: parsed.search,
+		locale
+	};
+}
+/**
+* Prefetch the data JSON and kick off the code-split loader so the chunk is
+* warm by the time the user clicks.
+*
+* Used by both `Router.prefetch()` and `<Link>` hover/viewport prefetch. The
+* JSON request uses `fetch()` rather than `<link rel="prefetch">` so it can
+* carry Next.js's `x-deployment-id` skew-protection header. The in-flight
+* request is shared with a racing navigation; after it settles, the browser's
+* normal HTTP cache remains responsible for reuse.
+*
+* loader's returned Promise is intentionally discarded — `import()` caches the
+* result, so a subsequent navigation re-invocation hits the cache without
+* paying for a second round trip. Errors are swallowed: prefetch is
+* best-effort and must never break the page.
+*/
+function prefetchPagesData(target) {
+	if (typeof document === "undefined") return;
+	const headers = {
+		Accept: "application/json",
+		purpose: "prefetch",
+		"x-nextjs-data": "1"
+	};
+	const deploymentId = getDeploymentId();
+	if (deploymentId) headers[NEXT_DEPLOYMENT_ID_HEADER] = deploymentId;
+	dedupedPagesDataFetch(target.dataHref, { headers }).catch(() => {});
+	target.loader().catch(() => {});
+}
+//#endregion
+export { prefetchPagesData, resolvePagesDataNavigationTarget };

package/dist/shims/internal/pages-data-url.d.ts

@@ -0,0 +1,41 @@
+//#region src/shims/internal/pages-data-url.d.ts
+/**
+ * Append `.json` and the `/_next/data/<buildId>` prefix to a page pathname.
+ *
+ * Mirrors Next.js' `getAssetPathFromRoute` + `getDataHref` behaviour:
+ *   `/`            → `/_next/data/<id>/index.json`
+ *   `/about`       → `/_next/data/<id>/about.json`
+ *   `/index`       → `/_next/data/<id>/index/index.json`  (explicit `/index` page)
+ *   `/blog/foo`    → `/_next/data/<id>/blog/foo.json`
+ *
+ * `pagePath` is the resolved page pathname (already including any locale
+ * prefix and dynamic-param substitution), with a leading slash and NO
+ * trailing slash. The function does not URL-encode — the caller is expected
+ * to have produced a server-routable path.
+ */
+declare function buildPagesDataPath(buildId: string, pagePath: string): string;
+/**
+ * Build the full data URL including the basePath, the search string, and the
+ * `/_next/data/<buildId>/<page>.json` segment.
+ *
+ * `pagePath` must already be the resolved pathname (param-substituted,
+ * locale-prefixed where applicable). `search` includes the leading `?`.
+ */
+declare function buildPagesDataHref(basePath: string, buildId: string, pagePath: string, search: string): string;
+/** Result of matching a URL pathname against the registered route patterns. */
+type PagesPatternMatch = {
+  /** The matched route pattern in Next.js bracket format (e.g. `/blog/[slug]`). */pattern: string; /** Dynamic route params extracted from the URL. */
+  params: Record<string, string | string[]>;
+};
+/**
+ * Find the route pattern (Next.js bracket format) that matches `pathname`.
+ *
+ * Patterns are tried in `patterns` order — callers should pre-sort so more
+ * specific patterns come before catch-alls. Returns `null` when no pattern
+ * matches, so the caller can fall back to a hard navigation (this is how
+ * vinext handles routes that exist on the server but are not in the
+ * client-side loader map, e.g. dev-only pages).
+ */
+declare function matchPagesPattern(pathname: string, patterns: readonly string[]): PagesPatternMatch | null;
+//#endregion
+export { buildPagesDataHref, buildPagesDataPath, matchPagesPattern };

package/dist/shims/internal/pages-data-url.js

@@ -0,0 +1,71 @@
+import { matchRoutePattern, routePatternParts } from "../../routing/route-pattern.js";
+//#region src/shims/internal/pages-data-url.ts
+/**
+* Client-side helpers for the Pages Router `/_next/data/<buildId>/<page>.json`
+* endpoint.
+*
+* Ported from Next.js:
+*   - `packages/next/src/client/page-loader.ts` (`getDataHref`)
+*   - `packages/next/src/shared/lib/router/utils/get-asset-path-from-route.ts`
+*
+* The server-side counterpart lives in `server/pages-data-route.ts` and parses
+* the URL shape this module generates. Keep the two in sync — they are the
+* wire-format contract between vinext's client navigation and its data
+* endpoint.
+*/
+/**
+* Append `.json` and the `/_next/data/<buildId>` prefix to a page pathname.
+*
+* Mirrors Next.js' `getAssetPathFromRoute` + `getDataHref` behaviour:
+*   `/`            → `/_next/data/<id>/index.json`
+*   `/about`       → `/_next/data/<id>/about.json`
+*   `/index`       → `/_next/data/<id>/index/index.json`  (explicit `/index` page)
+*   `/blog/foo`    → `/_next/data/<id>/blog/foo.json`
+*
+* `pagePath` is the resolved page pathname (already including any locale
+* prefix and dynamic-param substitution), with a leading slash and NO
+* trailing slash. The function does not URL-encode — the caller is expected
+* to have produced a server-routable path.
+*/
+function buildPagesDataPath(buildId, pagePath) {
+	let path = pagePath;
+	if (path.length > 1 && path.endsWith("/")) path = path.slice(0, -1);
+	let asset;
+	if (path === "/") asset = "/index";
+	else if (path === "/index" || path.startsWith("/index/")) asset = "/index" + path;
+	else asset = path;
+	return `/_next/data/${buildId}${asset}.json`;
+}
+/**
+* Build the full data URL including the basePath, the search string, and the
+* `/_next/data/<buildId>/<page>.json` segment.
+*
+* `pagePath` must already be the resolved pathname (param-substituted,
+* locale-prefixed where applicable). `search` includes the leading `?`.
+*/
+function buildPagesDataHref(basePath, buildId, pagePath, search) {
+	const dataPath = buildPagesDataPath(buildId, pagePath);
+	return `${basePath ? basePath : ""}${dataPath}${search}`;
+}
+/**
+* Find the route pattern (Next.js bracket format) that matches `pathname`.
+*
+* Patterns are tried in `patterns` order — callers should pre-sort so more
+* specific patterns come before catch-alls. Returns `null` when no pattern
+* matches, so the caller can fall back to a hard navigation (this is how
+* vinext handles routes that exist on the server but are not in the
+* client-side loader map, e.g. dev-only pages).
+*/
+function matchPagesPattern(pathname, patterns) {
+	const urlParts = pathname.split("/").filter(Boolean);
+	for (const pattern of patterns) {
+		const params = matchRoutePattern(urlParts, routePatternParts(pattern));
+		if (params !== null) return {
+			pattern,
+			params
+		};
+	}
+	return null;
+}
+//#endregion
+export { buildPagesDataHref, buildPagesDataPath, matchPagesPattern };

package/dist/shims/internal/pages-router-accessor.d.ts

@@ -0,0 +1,19 @@
+//#region src/shims/internal/pages-router-accessor.d.ts
+/**
+ * Shared Pages Router navigation accessor.
+ *
+ * Both `next/navigation` (usePathname/useParams/useSearchParams) and the
+ * internal `useUntrackedPathname` read from the same global Symbol. Keeping
+ * the lookup in one place avoids the Symbol string and the error-handling
+ * shape from drifting across modules.
+ *
+ * @internal
+ */
+type PagesNavigationContext = {
+  pathname: string | null;
+  searchParams: URLSearchParams;
+  params: Record<string, string | string[]> | null;
+};
+declare function getPagesNavigationContext(): PagesNavigationContext | null;
+//#endregion
+export { PagesNavigationContext, getPagesNavigationContext };

package/dist/shims/internal/pages-router-accessor.js

@@ -0,0 +1,13 @@
+//#region src/shims/internal/pages-router-accessor.ts
+const PAGES_NAVIGATION_ACCESSOR_KEY = Symbol.for("vinext.navigation.pagesNavigationContextAccessor");
+function getPagesNavigationContext() {
+	const accessor = globalThis[PAGES_NAVIGATION_ACCESSOR_KEY];
+	if (!accessor) return null;
+	try {
+		return accessor();
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { getPagesNavigationContext };

package/dist/shims/internal/route-pattern-for-warning.d.ts

@@ -0,0 +1,27 @@
+//#region src/shims/internal/route-pattern-for-warning.d.ts
+/**
+ * Side-effect-free accessor for the current render's route pattern, used by
+ * Next.js-parity diagnostics such as the Link shim's
+ * "Invalid href ... in page: '...'" `console.error`.
+ *
+ * Mirrors Next.js's `router.pathname`, which is the *route pattern* (e.g.
+ * `/posts/[id]`), not the resolved URL. During Pages Router SSR the route
+ * pattern lives on the request-scoped SSR context; the server-only
+ * `router-state.ts` publishes an accessor for it under a well-known
+ * `Symbol.for` handle. We read it through that handle rather than importing
+ * `router.ts` directly — importing `router.ts` would pull its browser-only
+ * `installWindowNext()` side effect into every consumer of the Link shim
+ * (including the App Router client bundle), clobbering `window.next.router`.
+ *
+ * On the client (or when no accessor is registered, e.g. App Router) we fall
+ * back to `window.location.pathname`, then to `"/"`.
+ */
+/**
+ * Register the server-side route-pattern accessor. Called once by the
+ * server-only router-state module on import. Idempotent.
+ * @internal
+ */
+declare function registerRoutePatternForWarningAccessor(accessor: () => string | null): void;
+declare function getCurrentRoutePathnameForWarning(): string;
+//#endregion
+export { getCurrentRoutePathnameForWarning, registerRoutePatternForWarningAccessor };

package/dist/shims/internal/route-pattern-for-warning.js

@@ -0,0 +1,40 @@
+//#region src/shims/internal/route-pattern-for-warning.ts
+/**
+* Side-effect-free accessor for the current render's route pattern, used by
+* Next.js-parity diagnostics such as the Link shim's
+* "Invalid href ... in page: '...'" `console.error`.
+*
+* Mirrors Next.js's `router.pathname`, which is the *route pattern* (e.g.
+* `/posts/[id]`), not the resolved URL. During Pages Router SSR the route
+* pattern lives on the request-scoped SSR context; the server-only
+* `router-state.ts` publishes an accessor for it under a well-known
+* `Symbol.for` handle. We read it through that handle rather than importing
+* `router.ts` directly — importing `router.ts` would pull its browser-only
+* `installWindowNext()` side effect into every consumer of the Link shim
+* (including the App Router client bundle), clobbering `window.next.router`.
+*
+* On the client (or when no accessor is registered, e.g. App Router) we fall
+* back to `window.location.pathname`, then to `"/"`.
+*/
+const ROUTE_PATTERN_FOR_WARNING_ACCESSOR_KEY = Symbol.for("vinext.router.routePatternForWarningAccessor");
+/**
+* Register the server-side route-pattern accessor. Called once by the
+* server-only router-state module on import. Idempotent.
+* @internal
+*/
+function registerRoutePatternForWarningAccessor(accessor) {
+	globalThis[ROUTE_PATTERN_FOR_WARNING_ACCESSOR_KEY] = accessor;
+}
+function getCurrentRoutePathnameForWarning() {
+	if (typeof window === "undefined") {
+		const accessor = globalThis[ROUTE_PATTERN_FOR_WARNING_ACCESSOR_KEY];
+		if (accessor) try {
+			const pattern = accessor();
+			if (pattern) return pattern;
+		} catch {}
+		return "/";
+	}
+	return window.location?.pathname ?? "/";
+}
+//#endregion
+export { getCurrentRoutePathnameForWarning, registerRoutePatternForWarningAccessor };

package/dist/shims/internal/router-context.d.ts

@@ -0,0 +1,7 @@
+import { NextRouter } from "../router.js";
+import { Context } from "react";
+
+//#region src/shims/internal/router-context.d.ts
+declare const RouterContext: Context<NextRouter | null>;
+//#endregion
+export { RouterContext };

package/dist/shims/internal/router-context.js

@@ -0,0 +1,13 @@
+import { createContext } from "react";
+//#region src/shims/internal/router-context.ts
+/**
+* Shim for next/dist/shared/lib/router-context.shared-runtime
+*
+* Used by: some testing utilities and older libraries.
+* Provides the Pages Router context.
+*/
+const ROUTER_CONTEXT_KEY = Symbol.for("vinext.routerContext");
+const globalState = globalThis;
+const RouterContext = globalState[ROUTER_CONTEXT_KEY] ?? (globalState[ROUTER_CONTEXT_KEY] = createContext(null));
+//#endregion
+export { RouterContext };

package/dist/shims/internal/utils.d.ts

@@ -0,0 +1,52 @@
+//#region src/shims/internal/utils.d.ts
+/**
+ * Shim for next/dist/shared/lib/utils
+ *
+ * Used by: @sentry/nextjs (type-only import of NEXT_DATA).
+ * Provides the NEXT_DATA type that matches window.__NEXT_DATA__.
+ */
+type NEXT_DATA = {
+  props: Record<string, unknown>;
+  page: string;
+  query: Record<string, string | string[]>;
+  buildId?: string;
+  assetPrefix?: string;
+  runtimeConfig?: Record<string, unknown>;
+  nextExport?: boolean;
+  autoExport?: boolean;
+  isFallback?: boolean;
+  dynamicIds?: (string | number)[];
+  err?: {
+    message: string;
+    statusCode: number;
+    name?: string;
+  };
+  isExperimentalCompile?: boolean;
+  gsp?: boolean;
+  gssp?: boolean;
+  customServer?: boolean;
+  gip?: boolean;
+  appGip?: boolean;
+  locale?: string;
+  locales?: string[];
+  defaultLocale?: string;
+  domainLocales?: Array<{
+    domain: string;
+    defaultLocale: string;
+    locales?: string[];
+    http?: boolean;
+  }>;
+  scriptLoader?: unknown[];
+  isPreview?: boolean;
+  notFoundSrcPage?: string;
+};
+/**
+ * Standard Next.js error shape.
+ */
+declare function execOnce<T extends (...args: unknown[]) => unknown>(fn: T): T;
+declare function getLocationOrigin(): string;
+declare function getURL(): string;
+declare const SP: boolean;
+declare const ST: boolean;
+//#endregion
+export { NEXT_DATA, SP, ST, execOnce, getLocationOrigin, getURL };

package/dist/shims/internal/utils.js

@@ -0,0 +1,27 @@
+//#region src/shims/internal/utils.ts
+/**
+* Standard Next.js error shape.
+*/
+function execOnce(fn) {
+	let used = false;
+	let result;
+	return ((...args) => {
+		if (!used) {
+			used = true;
+			result = fn(...args);
+		}
+		return result;
+	});
+}
+function getLocationOrigin() {
+	if (typeof window !== "undefined") return window.location.origin;
+	return "http://localhost";
+}
+function getURL() {
+	if (typeof window !== "undefined") return window.location.href;
+	return "http://localhost/";
+}
+const SP = typeof performance !== "undefined";
+const ST = SP && typeof performance.mark === "function";
+//#endregion
+export { SP, ST, execOnce, getLocationOrigin, getURL };

package/dist/shims/internal/work-unit-async-storage.d.ts

@@ -0,0 +1,30 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/shims/internal/work-unit-async-storage.d.ts
+type RequestStore = {
+  readonly type: "request";
+};
+type PrerenderStore = {
+  readonly type: "prerender" | "prerender-client" | "prerender-runtime"; /** AbortSignal that fires when the prerender is cancelled or completed. */
+  readonly renderSignal: AbortSignal; /** Optional route identifier for debugging and error messages. */
+  readonly route?: string;
+};
+type CacheStore = {
+  readonly type: "cache" | "private-cache" | "unstable-cache";
+};
+type GenerateStaticParamsStore = {
+  readonly type: "generate-static-params";
+};
+type PrerenderLegacyStore = {
+  readonly type: "prerender-legacy";
+};
+/**
+ * Discriminated union of all known work unit types.
+ * Matches Next.js's WorkUnitStore: packages/next/src/server/app-render/work-unit-async-storage.external.ts
+ */
+type WorkUnitStore = RequestStore | PrerenderStore | CacheStore | GenerateStaticParamsStore | PrerenderLegacyStore;
+type WorkUnitAsyncStorage = AsyncLocalStorage<WorkUnitStore>;
+declare const workUnitAsyncStorage: WorkUnitAsyncStorage;
+declare const requestAsyncStorage: WorkUnitAsyncStorage;
+//#endregion
+export { CacheStore, GenerateStaticParamsStore, PrerenderLegacyStore, PrerenderStore, RequestStore, WorkUnitAsyncStorage, WorkUnitStore, requestAsyncStorage, workUnitAsyncStorage };

package/dist/shims/internal/work-unit-async-storage.js

@@ -0,0 +1,17 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/shims/internal/work-unit-async-storage.ts
+/**
+* Shim for next/dist/server/app-render/work-unit-async-storage.external
+* and next/dist/client/components/request-async-storage.external
+*
+* Tracks the current rendering context type so that dynamic APIs
+* (io, headers, cookies, etc.) can branch on whether they're
+* inside a request, prerender, cache scope, or other context.
+*
+* Used by: @sentry/nextjs (runtime resolve for request context injection),
+* io() for hanging-promise behavior during prerendering.
+*/
+const workUnitAsyncStorage = new AsyncLocalStorage();
+const requestAsyncStorage = workUnitAsyncStorage;
+//#endregion
+export { requestAsyncStorage, workUnitAsyncStorage };

package/dist/shims/layout-segment-context.d.ts

@@ -0,0 +1,24 @@
+import { SegmentMap } from "./navigation-context-state.js";
+import { ReactNode } from "react";
+
+//#region src/shims/layout-segment-context.d.ts
+/**
+ * Wraps children with the layout segment context.
+ *
+ * Each layout in the App Router tree wraps its children with this provider,
+ * passing a map of parallel route key to segment path. The "children" key is
+ * always present (the default parallel route). Named parallel slots at this
+ * layout level add their own keys.
+ *
+ * Components inside the provider call useSelectedLayoutSegments(parallelRoutesKey)
+ * to read the segments for a specific parallel route.
+ */
+declare function LayoutSegmentProvider({
+  segmentMap,
+  children
+}: {
+  segmentMap: SegmentMap;
+  children: ReactNode;
+}): string | number | bigint | boolean | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").FunctionComponentElement<import("react").ProviderProps<SegmentMap>> | null | undefined;
+//#endregion
+export { LayoutSegmentProvider };

package/dist/shims/layout-segment-context.js

@@ -0,0 +1,39 @@
+"use client";
+import { getLayoutSegmentContext } from "./navigation-context-state.js";
+import "./navigation-server.js";
+import { createElement } from "react";
+//#region src/shims/layout-segment-context.tsx
+/**
+* Layout segment context provider.
+*
+* Must be "use client" so that Vite's RSC bundler renders this component in
+* the SSR/browser environment where React.createContext is available. The RSC
+* entry imports and renders LayoutSegmentProvider directly, but because of the
+* "use client" boundary the actual execution happens on the SSR/client side
+* where the context can be created and consumed by useSelectedLayoutSegment(s).
+*
+* Without "use client", this runs in the RSC environment where
+* React.createContext is undefined, getLayoutSegmentContext() returns null,
+* the provider becomes a no-op, and useSelectedLayoutSegments always returns [].
+*
+* The context is shared with navigation.ts via getLayoutSegmentContext()
+* to avoid creating separate contexts in different modules.
+*/
+/**
+* Wraps children with the layout segment context.
+*
+* Each layout in the App Router tree wraps its children with this provider,
+* passing a map of parallel route key to segment path. The "children" key is
+* always present (the default parallel route). Named parallel slots at this
+* layout level add their own keys.
+*
+* Components inside the provider call useSelectedLayoutSegments(parallelRoutesKey)
+* to read the segments for a specific parallel route.
+*/
+function LayoutSegmentProvider({ segmentMap, children }) {
+	const ctx = getLayoutSegmentContext();
+	if (!ctx) return children;
+	return createElement(ctx.Provider, { value: segmentMap }, children);
+}
+//#endregion
+export { LayoutSegmentProvider };

package/dist/shims/legacy-image.d.ts

@@ -0,0 +1,41 @@
+import React from "react";
+
+//#region src/shims/legacy-image.d.ts
+type LegacyImageProps = {
+  src: string | {
+    src: string;
+    width: number;
+    height: number;
+    blurDataURL?: string;
+  };
+  alt: string;
+  width?: number | string;
+  height?: number | string; /** Legacy layout mode */
+  layout?: "fixed" | "intrinsic" | "responsive" | "fill"; /** CSS object-fit (used with layout="fill") */
+  objectFit?: React.CSSProperties["objectFit"]; /** CSS object-position (used with layout="fill") */
+  objectPosition?: string;
+  priority?: boolean;
+  quality?: number;
+  placeholder?: "blur" | "empty";
+  blurDataURL?: string;
+  loader?: (params: {
+    src: string;
+    width: number;
+    quality?: number;
+  }) => string;
+  sizes?: string;
+  className?: string;
+  style?: React.CSSProperties;
+  onLoad?: React.ReactEventHandler<HTMLImageElement>;
+  onLoadingComplete?: (result: {
+    naturalWidth: number;
+    naturalHeight: number;
+  }) => void;
+  onError?: React.ReactEventHandler<HTMLImageElement>;
+  loading?: "lazy" | "eager";
+  unoptimized?: boolean;
+  id?: string;
+};
+declare const LegacyImage: React.ForwardRefExoticComponent<LegacyImageProps & React.RefAttributes<HTMLImageElement>>;
+//#endregion
+export { LegacyImage as default };

package/dist/shims/legacy-image.js

@@ -0,0 +1,49 @@
+import Image from "./image.js";
+import { forwardRef } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/shims/legacy-image.tsx
+/**
+* next/legacy/image shim
+*
+* Provides the pre-Next.js 13 Image component API with layout prop.
+* Translates legacy props (layout, objectFit, objectPosition) to the
+* modern Image component's fill/style props.
+*
+* This module is used by apps that ran the `next-image-to-legacy-image`
+* codemod when upgrading from Next.js 12.
+*/
+const LegacyImage = forwardRef(function LegacyImage(props, ref) {
+	const { layout = "intrinsic", objectFit, objectPosition, onLoadingComplete, onLoad, width, height, style, ...rest } = props;
+	const modernStyle = { ...style };
+	if (objectFit) modernStyle.objectFit = objectFit;
+	if (objectPosition) modernStyle.objectPosition = objectPosition;
+	const handleLoad = onLoadingComplete ? (e) => {
+		const img = e.currentTarget;
+		onLoadingComplete({
+			naturalWidth: img.naturalWidth,
+			naturalHeight: img.naturalHeight
+		});
+		onLoad?.(e);
+	} : onLoad;
+	if (layout === "fill") return /* @__PURE__ */ jsx(Image, {
+		ref,
+		fill: true,
+		style: modernStyle,
+		onLoad: handleLoad,
+		...rest
+	});
+	if (layout === "responsive") {
+		modernStyle.width = "100%";
+		modernStyle.height = "auto";
+	}
+	return /* @__PURE__ */ jsx(Image, {
+		ref,
+		width: typeof width === "string" ? parseInt(width, 10) : width,
+		height: typeof height === "string" ? parseInt(height, 10) : height,
+		style: modernStyle,
+		onLoad: handleLoad,
+		...rest
+	});
+});
+//#endregion
+export { LegacyImage as default };

package/dist/shims/link-prefetch.d.ts

@@ -0,0 +1,41 @@
+//#region src/shims/link-prefetch.d.ts
+type LinkPrefetchIntent = "viewport" | "intent";
+type LinkPrefetchPriority = "low" | "high";
+type LinkPrefetchRouterMode = "app" | "pages";
+type LinkPrefetchDecision = {
+  shouldPrefetch: false;
+} | {
+  shouldPrefetch: true;
+  priority: LinkPrefetchPriority;
+};
+declare function canLinkPrefetch(input: {
+  nodeEnv: string | undefined;
+  prefetch: boolean | "auto" | null | undefined;
+  isDangerous: boolean;
+}): boolean;
+declare function canLinkIntentPrefetch(input: {
+  nodeEnv: string | undefined;
+  prefetch: boolean | "auto" | null | undefined;
+  isDangerous: boolean;
+  routerMode: LinkPrefetchRouterMode;
+}): boolean;
+declare function getLinkPrefetchDecision(input: {
+  nodeEnv: string | undefined;
+  prefetch: boolean | "auto" | null | undefined;
+  isDangerous: boolean;
+  intent: LinkPrefetchIntent;
+  routerMode?: LinkPrefetchRouterMode;
+}): LinkPrefetchDecision;
+/**
+ * Normalize absolute and protocol-relative Link hrefs to app-relative paths
+ * that are eligible for prefetching. Non-absolute relative hrefs are returned
+ * unchanged; callers must resolve them against the current browser URL before
+ * constructing a concrete fetch target.
+ */
+declare function getLinkPrefetchHref(input: {
+  href: string;
+  basePath: string;
+  currentOrigin: string | undefined;
+}): string | null;
+//#endregion
+export { LinkPrefetchDecision, LinkPrefetchIntent, LinkPrefetchPriority, LinkPrefetchRouterMode, canLinkIntentPrefetch, canLinkPrefetch, getLinkPrefetchDecision, getLinkPrefetchHref };