vinext 1.0.0-beta.9 → 1.0.0

package/dist/shims/image.js

@@ -453,10 +453,12 @@ const Image = forwardRef(function Image({ src: srcProp, alt, width, height, fill
 	}
 	if (isRemoteUrl(src)) {
 		const validation = validateRemoteUrl(src);
-		if (!validation.allowed) if (__isDev) console.warn(`[next/image] ${validation.reason}`);
-		else {
-			console.error(`[next/image] ${validation.reason}`);
-			return null;
+		if (!validation.allowed) {
+			if (__isDev) console.warn(`[next/image] ${validation.reason}`);
+			else {
+				console.error(`[next/image] ${validation.reason}`);
+				return null;
+			}
 		}
 		const sanitizedBlur = imgBlurDataURL ? sanitizeBlurDataURL(imgBlurDataURL) : void 0;
 		const showBlur = !blurComplete && placeholder === "blur" && sanitizedBlur;
@@ -603,10 +605,12 @@ function getImageProps(props) {
 	let blockedInProd = false;
 	if (isRemoteUrl(src)) {
 		const validation = validateRemoteUrl(src);
-		if (!validation.allowed) if (__isDev) console.warn(`[next/image] ${validation.reason}`);
-		else {
-			console.error(`[next/image] ${validation.reason}`);
-			blockedInProd = true;
+		if (!validation.allowed) {
+			if (__isDev) console.warn(`[next/image] ${validation.reason}`);
+			else {
+				console.error(`[next/image] ${validation.reason}`);
+				blockedInProd = true;
+			}
 		}
 	}
 	const imgQuality = typeof _quality === "string" ? Number(_quality) : _quality ?? 75;

package/dist/shims/internal/als-registry.d.ts

@@ -8,7 +8,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
  * @param key - String key fed to `Symbol.for(...)`. By convention vinext
  *   shims use a dotted namespace such as `"vinext.cache.als"`.
  */
-declare function getOrCreateAls<T>(key: string): AsyncLocalStorage<T>;
+export declare function getOrCreateAls<T>(key: string): AsyncLocalStorage<T>;
 /**
  * Enrol an ALS that is *not* created through `getOrCreateAls` into the
  * scope-exit set. For stores that must stay module-local for identity reasons
@@ -19,7 +19,7 @@ declare function getOrCreateAls<T>(key: string): AsyncLocalStorage<T>;
  * keeps importing nothing but `node:async_hooks` and stays safe to evaluate in
  * client bundles where that resolves to a constructor-less stub.
  */
-declare function registerAlsForScopeExit(als: AsyncLocalStorage<never>): void;
+export declare function registerAlsForScopeExit(als: AsyncLocalStorage<never>): void;
 /**
  * Run `fn` — and every async continuation it starts — outside every
  * request-scoped AsyncLocalStorage vinext installs, so the callback observes no
@@ -38,6 +38,5 @@ declare function registerAlsForScopeExit(als: AsyncLocalStorage<never>): void;
  * the unified store is absent, so a partial exit would enable that path rather
  * than close it.
  */
-declare function runOutsideRequestScopes<T>(fn: () => T): T;
-//#endregion
-export { getOrCreateAls, registerAlsForScopeExit, runOutsideRequestScopes };
+export declare function runOutsideRequestScopes<T>(fn: () => T): T;
+//#endregion

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

@@ -4,11 +4,10 @@
  *
  * Used by: @clerk/nextjs (type-only import of NextApiRequestCookies).
  */
-type NextApiRequestCookies = Partial<{
+export type NextApiRequestCookies = Partial<{
   [key: string]: string;
 }>;
-type NextApiRequestQuery = Partial<{
+export type NextApiRequestQuery = Partial<{
   [key: string]: string | string[];
 }>;
-//#endregion
-export { NextApiRequestCookies, NextApiRequestQuery };
+//#endregion

package/dist/shims/internal/app-page-props-cache-key.d.ts

@@ -1,5 +1,33 @@
 //#region src/shims/internal/app-page-props-cache-key.d.ts
-declare function markAppPagePropsForUseCache<T extends object>(props: T): T;
-declare function isMarkedAppPagePropsObject(value: object): boolean;
-//#endregion
-export { isMarkedAppPagePropsObject, markAppPagePropsForUseCache };
+/**
+ * Enumerable page marker, matching Next.js's `$$isPage` prop. It must be an
+ * ordinary string key: React's createElement drops symbol and non-enumerable
+ * props before a server component is invoked.
+ */
+export declare const APP_PAGE_USE_CACHE_MARKER = "$$isPage";
+export declare function markAppPagePropsForUseCache<T extends object>(props: T): T;
+export declare function isMarkedAppPagePropsObject(value: object): boolean;
+/**
+ * Whether `fn` is a transformed `"use cache"` function, including a bound
+ * one. Like Next.js's `isUseCacheFunction`, this survives `.bind()`: React's
+ * server-reference `bind` copies `$$typeof`/`$$id` to the bound function but
+ * not vinext's own marker symbol.
+ */
+export declare function isUseCacheFunctionReference(fn: unknown): boolean;
+/**
+ * Add Next.js's `$$isPage` marker when `fn` is a `"use cache"` function
+ * invoked as a page component or as a page's generateMetadata/generateViewport
+ * (create-component-tree.tsx, resolve-metadata.ts `createSegmentProps`). The
+ * cache wrapper reads and removes it, so page semantics follow the invocation
+ * even when the cached function is defined in (or re-exported from) another
+ * module, or bound.
+ */
+export declare function withUseCachePageMarker<T extends Record<string, unknown>>(fn: unknown, props: T): T;
+/**
+ * Whether `value` is page props carrying the `$$isPage` marker. Only plain
+ * objects qualify: the framework always passes a plain props object, and
+ * reading the marker through a thenable params/searchParams proxy would be
+ * observed as a param access.
+ */
+export declare function hasUseCachePageMarker(value: unknown): value is Record<string, unknown>;
+//#endregion

package/dist/shims/internal/app-page-props-cache-key.js

@@ -1,5 +1,20 @@
 //#region src/shims/internal/app-page-props-cache-key.ts
 const APP_PAGE_PROPS_CACHE_KEY_MARKER = Symbol.for("vinext.appPagePropsCacheKeyMarker");
+const USE_CACHE_FUNCTION_SYMBOL = Symbol.for("vinext.useCacheFunction");
+const SERVER_REFERENCE_TAG = Symbol.for("react.server.reference");
+/**
+* Server reference ids of transformed cache functions end in the export name
+* the use-cache transform assigns (`secureExportName` in
+* plugins/use-cache-callable.ts): `$$vinext_cache_` plus an HMAC-SHA256 hex
+* digest. `"use server"` actions keep their own export names.
+*/
+const USE_CACHE_SERVER_REFERENCE_ID_RE = /#\$\$vinext_cache_[0-9a-f]{64}$/;
+/**
+* Enumerable page marker, matching Next.js's `$$isPage` prop. It must be an
+* ordinary string key: React's createElement drops symbol and non-enumerable
+* props before a server component is invoked.
+*/
+const APP_PAGE_USE_CACHE_MARKER = "$$isPage";
 function markAppPagePropsForUseCache(props) {
 	Object.defineProperty(props, APP_PAGE_PROPS_CACHE_KEY_MARKER, {
 		configurable: false,
@@ -12,5 +27,42 @@ function markAppPagePropsForUseCache(props) {
 function isMarkedAppPagePropsObject(value) {
 	return Reflect.get(value, APP_PAGE_PROPS_CACHE_KEY_MARKER) === true;
 }
+/**
+* Whether `fn` is a transformed `"use cache"` function, including a bound
+* one. Like Next.js's `isUseCacheFunction`, this survives `.bind()`: React's
+* server-reference `bind` copies `$$typeof`/`$$id` to the bound function but
+* not vinext's own marker symbol.
+*/
+function isUseCacheFunctionReference(fn) {
+	if (typeof fn !== "function") return false;
+	if (Reflect.get(fn, USE_CACHE_FUNCTION_SYMBOL) === true) return true;
+	const reference = fn;
+	return reference.$$typeof === SERVER_REFERENCE_TAG && typeof reference.$$id === "string" && USE_CACHE_SERVER_REFERENCE_ID_RE.test(reference.$$id);
+}
+/**
+* Add Next.js's `$$isPage` marker when `fn` is a `"use cache"` function
+* invoked as a page component or as a page's generateMetadata/generateViewport
+* (create-component-tree.tsx, resolve-metadata.ts `createSegmentProps`). The
+* cache wrapper reads and removes it, so page semantics follow the invocation
+* even when the cached function is defined in (or re-exported from) another
+* module, or bound.
+*/
+function withUseCachePageMarker(fn, props) {
+	return isUseCacheFunctionReference(fn) ? {
+		...props,
+		[APP_PAGE_USE_CACHE_MARKER]: true
+	} : props;
+}
+/**
+* Whether `value` is page props carrying the `$$isPage` marker. Only plain
+* objects qualify: the framework always passes a plain props object, and
+* reading the marker through a thenable params/searchParams proxy would be
+* observed as a param access.
+*/
+function hasUseCachePageMarker(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return (prototype === Object.prototype || prototype === null) && value["$$isPage"] === true;
+}
 //#endregion
-export { isMarkedAppPagePropsObject, markAppPagePropsForUseCache };
+export { APP_PAGE_USE_CACHE_MARKER, hasUseCachePageMarker, isMarkedAppPagePropsObject, isUseCacheFunctionReference, markAppPagePropsForUseCache, withUseCachePageMarker };

package/dist/shims/internal/app-prefetch-fetch-queue.d.ts

@@ -1,13 +1,13 @@
 //#region src/shims/internal/app-prefetch-fetch-queue.d.ts
-declare function releaseAppPrefetchFetchSlot(response: Response): void;
+export declare function releaseAppPrefetchFetchSlot(response: Response): void;
 /**
  * Low-priority App Router prefetches share a small request queue. The consumer
  * must either snapshot the returned Response with snapshotRscResponse() or call
  * releaseAppPrefetchFetchSlot() when it drops the response without consuming it.
  */
-declare function scheduleAppPrefetchFetch(fetcher: (signal: AbortSignal) => Promise<Response>, priority: "low" | "high"): Promise<Response>;
+export declare function scheduleAppPrefetchFetch(fetcher: (signal: AbortSignal) => Promise<Response>, priority: "low" | "high"): Promise<Response>;
 /** Cancel a queued or in-flight prefetch request. No-op once it has settled. */
-declare function cancelAppPrefetchFetch(promise: Promise<Response> | undefined): void;
+export declare function cancelAppPrefetchFetch(promise: Promise<Response> | undefined): void;
 /**
  * Start a still-queued prefetch request immediately.
  *
@@ -20,6 +20,5 @@ declare function cancelAppPrefetchFetch(promise: Promise<Response> | undefined):
  *
  * No-op when the request has already started or was never queued.
  */
-declare function promoteAppPrefetchFetch(promise: Promise<Response> | undefined): void;
-//#endregion
-export { cancelAppPrefetchFetch, promoteAppPrefetchFetch, releaseAppPrefetchFetchSlot, scheduleAppPrefetchFetch };
+export declare function promoteAppPrefetchFetch(promise: Promise<Response> | undefined): void;
+//#endregion

package/dist/shims/internal/app-prefetch-rsc-request.d.ts

@@ -1,25 +1,13 @@
 //#region src/shims/internal/app-prefetch-rsc-request.d.ts
-type ResolveAppPrefetchRscRequestOptions = {
-  canUseCanonicalLoadingShell: boolean;
+export type ResolveAppPrefetchRscRequestOptions = {
   fullHref: string;
   headers: Headers;
-  interceptionContext: string | null;
-  mountedSlotsHeader: string | null;
-  prefetchInlining: boolean;
-  requiresRouteTreePrefetch: boolean;
   rewrittenPrefetchHref: string | null;
 };
-type ResolvedAppPrefetchRscRequest = {
+export type ResolvedAppPrefetchRscRequest = {
   additionalRscUrls: string[];
   rscUrl: string;
-  usesCanonicalPrewarmedRequest: boolean;
 };
-/**
- * Resolve the RSC request identity shared by `<Link>` and `router.prefetch()`.
- * Only full routes and ordinary loading shells without request-specific
- * context can reuse deploy-prewarmed CDN entries. Contextual requests retain
- * their varying headers and deterministic `_rsc` digest.
- */
-declare function resolveAppPrefetchRscRequest({ canUseCanonicalLoadingShell, fullHref, headers, interceptionContext, mountedSlotsHeader, prefetchInlining, requiresRouteTreePrefetch, rewrittenPrefetchHref }: ResolveAppPrefetchRscRequestOptions): Promise<ResolvedAppPrefetchRscRequest>;
-//#endregion
-export { ResolveAppPrefetchRscRequestOptions, ResolvedAppPrefetchRscRequest, resolveAppPrefetchRscRequest };
+/** Resolve the ordinary RSC request identities shared by `<Link>` and `router.prefetch()`. */
+export declare function resolveAppPrefetchRscRequest({ fullHref, headers, rewrittenPrefetchHref }: ResolveAppPrefetchRscRequestOptions): Promise<ResolvedAppPrefetchRscRequest>;
+//#endregion

package/dist/shims/internal/app-prefetch-rsc-request.js

@@ -1,20 +1,11 @@
-import { canonicalizeLoadingShellRscRequestHeaders, canonicalizePrewarmableRscRequestHeaders, createCanonicalRscRequestUrl, createRscRequestUrl } from "../../server/app-rsc-cache-busting.js";
+import { createRscRequestUrl } from "../../server/app-rsc-cache-busting.js";
 //#region src/shims/internal/app-prefetch-rsc-request.ts
-/**
-* Resolve the RSC request identity shared by `<Link>` and `router.prefetch()`.
-* Only full routes and ordinary loading shells without request-specific
-* context can reuse deploy-prewarmed CDN entries. Contextual requests retain
-* their varying headers and deterministic `_rsc` digest.
-*/
-async function resolveAppPrefetchRscRequest({ canUseCanonicalLoadingShell, fullHref, headers, interceptionContext, mountedSlotsHeader, prefetchInlining, requiresRouteTreePrefetch, rewrittenPrefetchHref }) {
-	const canUseCanonicalSharedRequest = process.env.__NEXT_CONFIG_OUTPUT !== "export" && process.env.__VINEXT_CANONICAL_RSC_REQUESTS === "1" && interceptionContext === null && mountedSlotsHeader === null && (rewrittenPrefetchHref === null || rewrittenPrefetchHref === fullHref) && !requiresRouteTreePrefetch && !prefetchInlining;
-	const usesCanonicalLoadingShell = canUseCanonicalSharedRequest && canUseCanonicalLoadingShell && canonicalizeLoadingShellRscRequestHeaders(headers);
-	const usesCanonicalFullRoute = canUseCanonicalSharedRequest && !usesCanonicalLoadingShell && canonicalizePrewarmableRscRequestHeaders(headers);
-	const [rscUrl, ...additionalRscUrls] = await Promise.all([usesCanonicalFullRoute ? createCanonicalRscRequestUrl(fullHref) : createRscRequestUrl(fullHref, headers), ...rewrittenPrefetchHref !== null && rewrittenPrefetchHref !== fullHref ? [createRscRequestUrl(rewrittenPrefetchHref, headers)] : []]);
+/** Resolve the ordinary RSC request identities shared by `<Link>` and `router.prefetch()`. */
+async function resolveAppPrefetchRscRequest({ fullHref, headers, rewrittenPrefetchHref }) {
+	const [rscUrl, ...additionalRscUrls] = await Promise.all([createRscRequestUrl(fullHref, headers), ...rewrittenPrefetchHref !== null && rewrittenPrefetchHref !== fullHref ? [createRscRequestUrl(rewrittenPrefetchHref, headers)] : []]);
 	return {
 		additionalRscUrls,
-		rscUrl,
-		usesCanonicalPrewarmedRequest: usesCanonicalLoadingShell || usesCanonicalFullRoute
+		rscUrl
 	};
 }
 //#endregion

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

@@ -18,6 +18,6 @@ declare global {
  * first (e.g. `link.tsx` normalises to match `trailingSlash` config before
  * calling, while `router.prefetch()` passes the raw user-supplied URL).
  */
-declare function markAppRouteDetectedOnPrefetch(href: string, basePath: string): Promise<void>;
+export declare function markAppRouteDetectedOnPrefetch(href: string, basePath: string): Promise<void>;
 //#endregion
-export { getPagesRouterComponentsMap, markAppRouteDetectedOnPrefetch };
+export { getPagesRouterComponentsMap };

package/dist/shims/internal/app-route-prefetch-policy.d.ts

@@ -10,10 +10,8 @@ declare global {
  * it at all, whether the response is reusable by a later navigation, and which
  * cache TTL family applies.
  */
-type AppRoutePrefetchPolicy = {
+export type AppRoutePrefetchPolicy = {
   cacheForNavigation: boolean;
-  /** The selected loading shell has the canonical deploy-warmed identity. */
-  canUseCanonicalLoadingShell?: true;
   /**
    * How the dynamic stale-time signal affects this prefetch. Navigation data
    * takes it verbatim, explicit full prefetches fall back to the static window
@@ -27,8 +25,7 @@ type AppRoutePrefetchPolicy = {
   requiresRouteTreePrefetch?: true;
   shouldPrefetch: boolean;
 };
-declare function canAutoPrefetchFullAppRoute(href: string): boolean;
-declare function resolveAutoAppRoutePrefetch(href: string): AppRoutePrefetchPolicy;
-declare function resolveFullAppRoutePrefetch(): AppRoutePrefetchPolicy;
-//#endregion
-export { AppRoutePrefetchPolicy, canAutoPrefetchFullAppRoute, resolveAutoAppRoutePrefetch, resolveFullAppRoutePrefetch };
+export declare function canAutoPrefetchFullAppRoute(href: string): boolean;
+export declare function resolveAutoAppRoutePrefetch(href: string): AppRoutePrefetchPolicy;
+export declare function resolveFullAppRoutePrefetch(): AppRoutePrefetchPolicy;
+//#endregion

package/dist/shims/internal/app-route-prefetch-policy.js

@@ -45,7 +45,6 @@ function resolveAutoAppRoutePrefetch(href) {
 	const cacheForNavigation = !hasSearchParams && !hasCacheComponentsLearningOnlyDynamicPath && (requiresRouteTreePrefetch || !route.canPrefetchLoadingShell && route.requiresDynamicNavigationRequest !== true);
 	return {
 		cacheForNavigation,
-		...route.canUseCanonicalLoadingShell === true ? { canUseCanonicalLoadingShell: true } : {},
 		dynamicStaleTime: cacheForNavigation ? "verbatim" : "ignore",
 		fallbackTtl: "static",
 		prefetchShellFirst: requiresRouteTreePrefetch || hasSearchParams || !route.isDynamic,

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

@@ -1,13 +1,13 @@
 import * as React$1 from "react";
 //#region src/shims/internal/app-router-context.d.ts
-type NavigateOptions = {
+export type NavigateOptions = {
   scroll?: boolean;
 };
-type PrefetchOptions = {
+export type PrefetchOptions = {
   kind?: unknown;
   onInvalidate?: () => void;
 };
-type AppRouterInstance = {
+export type AppRouterInstance = {
   bfcacheId: string;
   back(): void;
   forward(): void;
@@ -21,10 +21,9 @@ type AppRouterInstance = {
    */
   experimental_gesturePush?(href: string, options?: NavigateOptions): void;
 };
-declare const AppRouterContext: React$1.Context<AppRouterInstance | null> | null;
-declare const GlobalLayoutRouterContext: React$1.Context<unknown> | null;
-declare const LayoutRouterContext: React$1.Context<unknown> | null;
-declare const MissingSlotContext: React$1.Context<Set<string>> | null;
-declare const TemplateContext: React$1.Context<unknown> | null;
-//#endregion
-export { AppRouterContext, AppRouterInstance, GlobalLayoutRouterContext, LayoutRouterContext, MissingSlotContext, NavigateOptions, PrefetchOptions, TemplateContext };
+export declare const AppRouterContext: React$1.Context<AppRouterInstance | null> | null;
+export declare const GlobalLayoutRouterContext: React$1.Context<unknown> | null;
+export declare const LayoutRouterContext: React$1.Context<unknown> | null;
+export declare const MissingSlotContext: React$1.Context<Set<string>> | null;
+export declare const TemplateContext: React$1.Context<unknown> | null;
+//#endregion

package/dist/shims/internal/cookie-serialize.d.ts

@@ -24,12 +24,12 @@ type SerializeSetCookieOptions = {
   partitioned?: boolean;
   priority?: "low" | "medium" | "high";
 };
-declare function validateCookieName(name: string): void;
+export declare function validateCookieName(name: string): void;
 /**
  * Validate cookie attribute values (path, domain) to prevent injection
  * via semicolons, newlines, or other control characters.
  */
-declare function validateCookieAttributeValue(value: string, attributeName: string): void;
+export declare function validateCookieAttributeValue(value: string, attributeName: string): void;
 /**
  * Build a Set-Cookie header string from a cookie name, value, and attributes.
  *
@@ -43,6 +43,5 @@ declare function validateCookieAttributeValue(value: string, attributeName: stri
  * The caller is responsible for validating the cookie name (typically before
  * mutating any internal state) via `validateCookieName`.
  */
-declare function serializeSetCookie(name: string, value: string | null | undefined, options?: SerializeSetCookieOptions): string;
-//#endregion
-export { serializeSetCookie, validateCookieAttributeValue, validateCookieName };
+export declare function serializeSetCookie(name: string, value: string | null | undefined, options?: SerializeSetCookieOptions): string;
+//#endregion

package/dist/shims/internal/format-url-object.d.ts

@@ -0,0 +1,7 @@
+import { UrlObject } from "node:url";
+//#region src/shims/internal/format-url-object.d.ts
+/** Format Node's public UrlObject shape with the semantics used by Next.js. */
+export declare function formatUrlObject(url: UrlObject): string;
+/** Format a Pages Router UrlObject and surface Next.js's development diagnostics. */
+export declare function formatUrlObjectWithValidation(url: UrlObject): string;
+//#endregion

package/dist/shims/internal/format-url-object.js

@@ -0,0 +1,53 @@
+import { urlQueryToSearchParams } from "../../utils/query.js";
+//#region src/shims/internal/format-url-object.ts
+const slashedProtocols = /https?|ftp|gopher|file/;
+const urlObjectKeys = /* @__PURE__ */ new Set([
+	"auth",
+	"hash",
+	"host",
+	"hostname",
+	"href",
+	"path",
+	"pathname",
+	"port",
+	"protocol",
+	"query",
+	"search",
+	"slashes"
+]);
+/** Format Node's public UrlObject shape with the semantics used by Next.js. */
+function formatUrlObject(url) {
+	let { auth, hostname } = url;
+	let protocol = url.protocol || "";
+	let pathname = url.pathname || "";
+	let hash = url.hash || "";
+	let query = url.query || "";
+	let host = false;
+	auth = auth ? `${encodeURIComponent(auth).replace(/%3A/i, ":")}@` : "";
+	if (url.host) host = auth + url.host;
+	else if (hostname) {
+		host = auth + (hostname.includes(":") ? `[${hostname}]` : hostname);
+		if (url.port) host += `:${url.port}`;
+	}
+	if (query && typeof query === "object") query = String(urlQueryToSearchParams(query));
+	let search = url.search || query && `?${query}` || "";
+	if (protocol && !protocol.endsWith(":")) protocol += ":";
+	if (url.slashes || (!protocol || slashedProtocols.test(protocol)) && host !== false) {
+		host = `//${host || ""}`;
+		if (pathname && !pathname.startsWith("/")) pathname = `/${pathname}`;
+	} else if (!host) host = "";
+	if (hash && !hash.startsWith("#")) hash = `#${hash}`;
+	if (search && !search.startsWith("?")) search = `?${search}`;
+	pathname = pathname.replace(/[?#]/g, encodeURIComponent);
+	search = search.replace("#", "%23");
+	return `${protocol}${host}${pathname}${search}${hash}`;
+}
+/** Format a Pages Router UrlObject and surface Next.js's development diagnostics. */
+function formatUrlObjectWithValidation(url) {
+	if (process.env.NODE_ENV === "development") {
+		for (const key of Object.keys(url)) if (!urlObjectKeys.has(key)) console.warn(`Unknown key passed via urlObject into url.format: ${key}`);
+	}
+	return formatUrlObject(url);
+}
+//#endregion
+export { formatUrlObject, formatUrlObjectWithValidation };

package/dist/shims/internal/hybrid-client-route-owner-direct.d.ts

@@ -1,6 +1,6 @@
 import { VinextLinkPrefetchRoute, VinextPagesLinkPrefetchRoute } from "../../client/vinext-next-data.js";
 //#region src/shims/internal/hybrid-client-route-owner-direct.d.ts
-type HybridClientOwner = "app" | "document" | "pages";
+export type HybridClientOwner = "app" | "document" | "pages";
 type HybridClientRouteMatches = {
   appMatch: VinextLinkPrefetchRoute | null;
   pagesMatch: VinextPagesLinkPrefetchRoute | null;
@@ -11,9 +11,8 @@ declare global {
     __VINEXT_PAGES_LINK_PREFETCH_ROUTES__?: VinextPagesLinkPrefetchRoute[];
   }
 }
-declare function resolveSameOriginAppPathname(href: string, basePath: string): string | null;
-declare function matchDirectHybridClientRoutes(href: string, basePath: string): HybridClientRouteMatches;
-declare function resolveMatchedHybridClientRouteOwner({ appMatch, pagesMatch }: HybridClientRouteMatches): HybridClientOwner | null;
-declare function resolveDirectHybridClientRouteOwner(href: string, basePath: string): HybridClientOwner | null;
-//#endregion
-export { HybridClientOwner, matchDirectHybridClientRoutes, resolveDirectHybridClientRouteOwner, resolveMatchedHybridClientRouteOwner, resolveSameOriginAppPathname };
+export declare function resolveSameOriginAppPathname(href: string, basePath: string): string | null;
+export declare function matchDirectHybridClientRoutes(href: string, basePath: string): HybridClientRouteMatches;
+export declare function resolveMatchedHybridClientRouteOwner({ appMatch, pagesMatch }: HybridClientRouteMatches): HybridClientOwner | null;
+export declare function resolveDirectHybridClientRouteOwner(href: string, basePath: string): HybridClientOwner | null;
+//#endregion

package/dist/shims/internal/hybrid-client-route-owner.d.ts

@@ -1,6 +1,6 @@
 import { HybridClientOwner } from "./hybrid-client-route-owner-direct.js";
 //#region src/shims/internal/hybrid-client-route-owner.d.ts
-declare function resolveHybridClientRewriteHref(href: string, basePath: string): string | null;
+export declare function resolveHybridClientRewriteHref(href: string, basePath: string): string | null;
 /**
  * Decide which router should own a soft-navigated URL. Returns:
  *   - "app"    → the App Router runtime handles the navigation (RSC fetch).
@@ -13,6 +13,6 @@ declare function resolveHybridClientRewriteHref(href: string, basePath: string):
  * matcher trie produces the same result the server will see when the
  * request lands.
  */
-declare function resolveHybridClientRouteOwner(href: string, basePath: string): HybridClientOwner | null;
+export declare function resolveHybridClientRouteOwner(href: string, basePath: string): HybridClientOwner | null;
 //#endregion
-export { type HybridClientOwner, resolveHybridClientRewriteHref, resolveHybridClientRouteOwner };
+export type { HybridClientOwner };

package/dist/shims/internal/hybrid-client-route-owner.js

@@ -32,12 +32,13 @@ function resolveClientRewrite(href, basePath, rewrites, continueAfterMatch = fal
 		if (pathname === null) return null;
 		const url = new URL(currentHref, window.location.href);
 		const headers = new Headers({ "user-agent": globalThis.navigator?.userAgent ?? "" });
-		const result = matchClientRewrite(pathname, rewrite, {
+		const context = {
 			cookies: parseCookies(globalThis.document?.cookie ?? ""),
 			headers,
 			host: url.hostname,
 			query: url.searchParams
-		}, basePathState);
+		};
+		const result = matchClientRewrite(pathname, rewrite, context, basePathState);
 		if (result === null) continue;
 		if (result.kind === "server") return { kind: "document" };
 		currentHref = mergeRewriteQuery(currentHref, result.destination);

package/dist/shims/internal/interpolate-as.d.ts

@@ -7,13 +7,13 @@ import { UrlQuery } from "../../utils/query.js";
 type ParsedUrlQuery = {
   [key: string]: string | string[] | undefined;
 };
-type DynamicRouteHrefProjection = {
+export type DynamicRouteHrefProjection = {
   href: string;
   params: string[];
   query: ParsedUrlQuery;
   routePathname: string;
 };
-type DynamicRouteHrefResolution = {
+export type DynamicRouteHrefResolution = {
   /** Route-pattern URL passed to the Pages Router. */
   href: string;
   /** Interpolated URL rendered in the anchor and displayed in the browser. */
@@ -25,7 +25,7 @@ type DynamicRouteHrefResolution = {
  * href (string-form hrefs). A `?` after `#` is part of the fragment, not a
  * query delimiter.
  */
-declare function interpolateDynamicRouteHref(routeHref: string, asHref: string, queryInput?: UrlQuery): DynamicRouteHrefProjection | null;
+export declare function interpolateDynamicRouteHref(routeHref: string, asHref: string, queryInput?: UrlQuery): DynamicRouteHrefProjection | null;
 /**
  * Resolve the two URLs that Next.js' Pages Router derives from a dynamic
  * href: the original route-pattern URL used to load the page and the
@@ -35,6 +35,5 @@ declare function interpolateDynamicRouteHref(routeHref: string, asHref: string,
  * Mirrors `resolveHref(router, href, true)` from Next.js:
  * packages/next/src/client/resolve-href.ts.
  */
-declare function resolveDynamicRouteHref(routeHref: string): DynamicRouteHrefResolution | null;
-//#endregion
-export { DynamicRouteHrefProjection, DynamicRouteHrefResolution, interpolateDynamicRouteHref, resolveDynamicRouteHref };
+export declare function resolveDynamicRouteHref(routeHref: string): DynamicRouteHrefResolution | null;
+//#endregion

package/dist/shims/internal/interpolate-as.js

@@ -132,8 +132,10 @@ function getRouteMatcher({ re, groups }) {
 		const params = {};
 		for (const [key, group] of Object.entries(groups)) {
 			const match = routeMatch[group.pos];
-			if (match !== void 0) if (group.repeat) params[key] = match.split("/").map((entry) => decode(entry));
-			else params[key] = decode(match);
+			if (match !== void 0) {
+				if (group.repeat) params[key] = match.split("/").map((entry) => decode(entry));
+				else params[key] = decode(match);
+			}
 		}
 		return params;
 	};

package/dist/shims/internal/link-status-registry.d.ts

@@ -16,19 +16,19 @@
  * React state model: instead of an optimistic-status dispatcher, we hold the
  * link's `setPending` setter.
  */
-type PendingLinkSetter = (pending: boolean) => void;
+export type PendingLinkSetter = (pending: boolean) => void;
 /**
  * Mark `setter` as the link that started the most recent navigation, resetting
  * the previously-tracked link's pending state to idle so only the last-clicked
  * link shows a pending state.
  */
-declare function setLinkForCurrentNavigation(setter: PendingLinkSetter): void;
+export declare function setLinkForCurrentNavigation(setter: PendingLinkSetter): void;
 /**
  * Stop tracking `setter` if it is the current navigation link. Called when a
  * <Link> finishes its own navigation or unmounts so we never hold a stale
  * reference to an unmounted component's setter.
  */
-declare function clearLinkForCurrentNavigation(setter: PendingLinkSetter): void;
+export declare function clearLinkForCurrentNavigation(setter: PendingLinkSetter): void;
 /**
  * Reset any link that is currently showing a pending state. Invoked at the
  * start of every App Router navigation so that navigations not initiated by the
@@ -38,6 +38,5 @@ declare function clearLinkForCurrentNavigation(setter: PendingLinkSetter): void;
  * `setLinkForCurrentNavigation`; the matching call here consumes that marker and
  * keeps the link pending.
  */
-declare function notifyLinkNavigationStart(): void;
-//#endregion
-export { PendingLinkSetter, clearLinkForCurrentNavigation, notifyLinkNavigationStart, setLinkForCurrentNavigation };
+export declare function notifyLinkNavigationStart(): void;
+//#endregion

package/dist/shims/internal/make-hanging-promise.d.ts

@@ -10,12 +10,11 @@
  * Ported from Next.js: packages/next/src/server/dynamic-rendering-utils.ts
  * https://github.com/vercel/next.js/blob/canary/packages/next/src/server/dynamic-rendering-utils.ts
  */
-declare function makeHangingPromise<T>(signal: AbortSignal, route: string, expression: string): Promise<T>;
+export declare function makeHangingPromise<T>(signal: AbortSignal, route: string, expression: string): Promise<T>;
 /**
  * Keep user-visible suspension promises pending while their owning renderer is
  * aborted after an uncatchable framework bailout. The abort event still reaches
  * renderer-owned listeners; only these promise rejections are suppressed.
  */
-declare function suppressHangingPromiseAbortRejections(signal: AbortSignal): void;
-//#endregion
-export { makeHangingPromise, suppressHangingPromiseAbortRejections };
+export declare function suppressHangingPromiseAbortRejections(signal: AbortSignal): void;
+//#endregion

package/dist/shims/internal/navigation-untracked.d.ts

@@ -30,6 +30,5 @@
  *
  * @internal
  */
-declare function useUntrackedPathname(): string | null;
-//#endregion
-export { useUntrackedPathname };
+export declare function useUntrackedPathname(): string | null;
+//#endregion

package/dist/shims/internal/normalize-router-href.d.ts

@@ -0,0 +1,15 @@
+//#region src/shims/internal/normalize-router-href.d.ts
+/**
+ * Warn about and normalize repeated path separators like Next.js `resolveHref`.
+ * The protocol separator is preserved and query strings are left untouched.
+ *
+ * Ported from Next.js: packages/next/src/client/resolve-href.ts
+ * https://github.com/vercel/next.js/blob/canary/packages/next/src/client/resolve-href.ts
+ */
+export declare function normalizeRouterHref(href: string, routePathname: string): string;
+/** Resolve a Pages Router href against the route state used by Next.js Link. */
+export declare function resolvePagesRouterHref(href: string, router: {
+  pathname: string;
+  asPath: string;
+}, basePath: string): string;
+//#endregion