vinext 0.1.1 → 0.1.2

package/dist/shims/dynamic-preload-chunks.js

@@ -0,0 +1,77 @@
+"use client";
+import { useScriptNonce } from "./script-nonce-context.js";
+import React from "react";
+import * as ReactDOM from "react-dom";
+//#region src/shims/dynamic-preload-chunks.tsx
+/**
+* Preload links for rendered next/dynamic() boundaries.
+*
+* This MUST be a "use client" component. next/dynamic() can be called from
+* either a Server Component or a Client Component. If this rendered in the
+* environment of the call site, a Server-Component call site would render it in
+* the RSC environment, where the script-nonce React context is unavailable
+* (createContext is not callable in react-server), so emitted preload links
+* would drop the request CSP nonce — a CSP violation under
+* `script-src 'nonce-…' 'strict-dynamic'`.
+*
+* Marking it "use client" forces it into the SSR pass (where vinext installs
+* the ScriptNonceProvider via withScriptNonce()), so the nonce is available
+* regardless of whether the dynamic() call site is a Server or Client
+* Component. This mirrors Next.js's <PreloadChunks> ('use client') and vinext's
+* own next/script shim.
+*
+* Deliberate divergence from Next.js: for CSS we render
+* `<link rel="stylesheet">` WITHOUT `as="style"`. Next.js emits `as="style"`,
+* but per the HTML spec `as` is only meaningful on `rel="preload"`/`modulepreload`
+* — on `rel="stylesheet"` it is ignored by browsers and is semantically wrong.
+* React keys stylesheet resources on href + precedence, not `as`, so omitting it
+* is safe. This is an intentional, documented difference, not a parity bug.
+*/
+function dynamicPreloadHref(file) {
+	if (file.startsWith("/") || file.startsWith("http://") || file.startsWith("https://") || file.startsWith("//")) return file;
+	return `/${file}`;
+}
+function resolveDynamicPreloadFiles(moduleIds) {
+	if (!moduleIds || moduleIds.length === 0) return [];
+	const preloadMap = globalThis.__VINEXT_DYNAMIC_PRELOADS__;
+	if (!preloadMap) return [];
+	const files = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const moduleId of moduleIds) for (const file of preloadMap[moduleId] ?? []) {
+		if (seen.has(file)) continue;
+		seen.add(file);
+		files.push(file);
+	}
+	return files;
+}
+function DynamicPreloadChunks(props) {
+	const nonce = useScriptNonce();
+	if (typeof window !== "undefined") return null;
+	const files = resolveDynamicPreloadFiles(props.moduleIds);
+	if (files.length === 0) return null;
+	const stylesheets = [];
+	for (const file of files) {
+		const href = dynamicPreloadHref(file);
+		if (href.endsWith(".css")) {
+			stylesheets.push(React.createElement("link", {
+				key: href,
+				rel: "stylesheet",
+				href,
+				nonce,
+				precedence: "dynamic"
+			}));
+			continue;
+		}
+		if (href.endsWith(".js") && typeof ReactDOM.preload === "function") {
+			const preloadOptions = {
+				as: "script",
+				fetchPriority: "low",
+				nonce
+			};
+			ReactDOM.preload(href, preloadOptions);
+		}
+	}
+	return stylesheets.length > 0 ? React.createElement(React.Fragment, null, ...stylesheets) : null;
+}
+//#endregion
+export { DynamicPreloadChunks };

package/dist/shims/dynamic.d.ts

@@ -16,6 +16,10 @@ type LoaderFn<P> = () => LoaderComponent<P>;
 type DynamicOptions<P> = {
   loading?: ComponentType<DynamicLoadingProps>;
   loader?: Loader<P>;
+  loadableGenerated?: {
+    modules?: readonly string[];
+  };
+  modules?: readonly string[];
   ssr?: boolean;
 };
 type Loader<P> = LoaderFn<P> | LoaderComponent<P>;

package/dist/shims/dynamic.js

@@ -1,3 +1,4 @@
+import { DynamicPreloadChunks } from "./dynamic-preload-chunks.js";
 import React from "react";
 //#region src/shims/dynamic.ts
 /**
@@ -121,8 +122,9 @@ function flushPreloads() {
 	return Promise.all(pending);
 }
 function dynamic(dynamicInput, options) {
-	const { loader: dynamicLoader, loading: LoadingComponent, ssr = true } = normalizeDynamicOptions(dynamicInput, options);
+	const { loader: dynamicLoader, loadableGenerated, loading: LoadingComponent, modules, ssr = true } = normalizeDynamicOptions(dynamicInput, options);
 	const loader = dynamicLoader ? normalizeLoader(dynamicLoader) : () => Promise.resolve(() => null);
+	const preloadModuleIds = loadableGenerated?.modules ?? modules;
 	if (!ssr) {
 		if (isServer) {
 			const SSRFalse = (_props) => LoadingComponent ? React.createElement(LoadingComponent, createDynamicLoadingProps({ pastDelay: false })) : null;
@@ -174,7 +176,7 @@ function dynamic(dynamicInput, options) {
 					resetKey: 0
 				}, lazyElement);
 			}
-			return React.createElement(React.Suspense, { fallback }, content);
+			return React.createElement(React.Fragment, null, React.createElement(DynamicPreloadChunks, { moduleIds: preloadModuleIds }), React.createElement(React.Suspense, { fallback }, content));
 		};
 		ServerDynamic.displayName = "DynamicServer";
 		return ServerDynamic;

package/dist/shims/error-boundary.d.ts

@@ -31,7 +31,7 @@ declare class RedirectErrorBoundary extends React.Component<{
     children?: React.ReactNode;
   });
   static getDerivedStateFromError(error: unknown): RedirectBoundaryState;
-  render(): string | number | bigint | boolean | React.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined;
+  render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
 }
 declare function RedirectBoundary({
   children
@@ -51,7 +51,7 @@ declare class ErrorBoundaryInner extends React.Component<ErrorBoundaryInnerProps
   componentDidMount(): void;
   componentWillUnmount(): void;
   reset: () => void;
-  render(): string | number | bigint | boolean | React.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined;
+  render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
 }
 declare function ErrorBoundary({
   fallback,
@@ -99,7 +99,7 @@ declare class ForbiddenBoundaryInner extends React.Component<ForbiddenBoundaryIn
   constructor(props: ForbiddenBoundaryInnerProps);
   static getDerivedStateFromProps(props: ForbiddenBoundaryInnerProps, state: ForbiddenBoundaryState): ForbiddenBoundaryState | null;
   static getDerivedStateFromError(error: unknown): Partial<ForbiddenBoundaryState>;
-  render(): string | number | bigint | boolean | React.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined;
+  render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
 }
 declare function ForbiddenBoundary({
   fallback,
@@ -123,7 +123,7 @@ declare class UnauthorizedBoundaryInner extends React.Component<UnauthorizedBoun
   constructor(props: UnauthorizedBoundaryInnerProps);
   static getDerivedStateFromProps(props: UnauthorizedBoundaryInnerProps, state: UnauthorizedBoundaryState): UnauthorizedBoundaryState | null;
   static getDerivedStateFromError(error: unknown): Partial<UnauthorizedBoundaryState>;
-  render(): string | number | bigint | boolean | React.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined;
+  render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
 }
 declare function UnauthorizedBoundary({
   fallback,

package/dist/shims/error.js

@@ -1,5 +1,6 @@
+import { AppRouterContext } from "./internal/app-router-context.js";
 import { RouterContext } from "./internal/router-context.js";
-import { appRouterInstance, isNextRouterError } from "./navigation.js";
+import { isNextRouterError, usePathname } from "./navigation.js";
 import React from "react";
 //#region src/shims/error.tsx
 /**
@@ -39,33 +40,53 @@ function ErrorComponent({ statusCode, title }) {
 		margin: 0
 	} }, displayTitle + "."))));
 }
+const _CatchErrorAppRouterContext = AppRouterContext ?? React.createContext(null);
 var _CatchError = class extends React.Component {
-	static contextType = RouterContext;
+	static contextType = _CatchErrorAppRouterContext;
 	static displayName = "unstable_catchError(Next.CatchError)";
-	state = { error: null };
+	constructor(props) {
+		super(props);
+		this.state = {
+			error: null,
+			previousPathname: props.pathname
+		};
+	}
 	static getDerivedStateFromError(thrownValue) {
 		if (isNextRouterError(thrownValue)) throw thrownValue;
 		return { error: { thrownValue } };
 	}
+	static getDerivedStateFromProps(props, state) {
+		if (props.pathname !== state.previousPathname && state.error) return {
+			error: null,
+			previousPathname: props.pathname
+		};
+		return {
+			error: state.error,
+			previousPathname: props.pathname
+		};
+	}
 	reset = () => {
 		this.setState({ error: null });
 	};
 	unstable_retry = () => {
-		if (this.context !== null) throw new Error("`unstable_retry()` can only be used in the App Router. Use `reset()` in the Pages Router.");
-		if (typeof window === "undefined") throw new Error("`unstable_retry()` can only be used on the client. Call it from a user interaction handler inside the error fallback.");
+		if (this.props.isPagesRouter) throw new Error("`unstable_retry()` can only be used in the App Router. Use `reset()` in the Pages Router.");
 		React.startTransition(() => {
-			appRouterInstance.refresh();
+			this.context?.refresh();
 			this.reset();
 		});
 	};
 	render() {
 		if (this.state.error) {
+			const Fallback = this.props.fallback;
 			const errorInfo = {
 				error: this.state.error.thrownValue,
 				reset: this.reset,
 				unstable_retry: this.unstable_retry
 			};
-			return this.props.fallback(this.props.forwardedProps, errorInfo);
+			return React.createElement(Fallback, {
+				props: this.props.props,
+				errorInfo
+			});
 		}
 		return this.props.children;
 	}
@@ -79,13 +100,18 @@ var _CatchError = class extends React.Component {
 *   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/catch-error.tsx
 */
 function unstable_catchError(fallback) {
-	const TypedCatchError = _CatchError;
+	const Fallback = ({ props, errorInfo }) => fallback(props, errorInfo);
+	Fallback.displayName = fallback.name || "CatchErrorFallback";
 	function CatchErrorBoundary(allProps) {
 		const { children, ...rest } = allProps;
+		const pathname = usePathname();
+		const isPagesRouter = React.useContext(RouterContext) !== null;
 		const forwardedProps = rest;
-		return React.createElement(TypedCatchError, {
-			fallback,
-			forwardedProps
+		return React.createElement(_CatchError, {
+			fallback: Fallback,
+			isPagesRouter,
+			pathname,
+			props: forwardedProps
 		}, children);
 	}
 	CatchErrorBoundary.displayName = `unstable_catchError(${fallback.name || "CatchErrorFallback"})`;

package/dist/shims/fetch-cache.d.ts

@@ -75,6 +75,14 @@ declare function addCollectedRequestTags(tags: readonly string[]): void;
  * affected route, without permanently coupling a shared fetch entry to one path.
  */
 declare function setCurrentFetchSoftTags(tags: string[]): void;
+/**
+ * Read the path-derived soft tags for the current render.
+ *
+ * Used by the "use cache" runtime to pass soft tags to the cache handler
+ * so that `revalidatePath()` invalidates "use cache" entries during the
+ * affected route's next request, even when the entry carries no hard tags.
+ */
+declare function getCurrentFetchSoftTags(): string[];
 declare function setCurrentFetchCacheMode(mode: FetchCacheMode | null): void;
 /**
  * Install the patched fetch and reset per-request tag state.
@@ -123,4 +131,4 @@ declare function ensureFetchPatch(): void;
  */
 declare function getOriginalFetch(): typeof globalThis.fetch;
 //#endregion
-export { FetchCacheMode, FetchCacheState, _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, withFetchCache };
+export { FetchCacheMode, FetchCacheState, _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, withFetchCache };

package/dist/shims/fetch-cache.js

@@ -369,6 +369,16 @@ function addCollectedRequestTags(tags) {
 function setCurrentFetchSoftTags(tags) {
 	_getState().currentFetchSoftTags = [...tags];
 }
+/**
+* Read the path-derived soft tags for the current render.
+*
+* Used by the "use cache" runtime to pass soft tags to the cache handler
+* so that `revalidatePath()` invalidates "use cache" entries during the
+* affected route's next request, even when the entry carries no hard tags.
+*/
+function getCurrentFetchSoftTags() {
+	return _getState().currentFetchSoftTags;
+}
 function setCurrentFetchCacheMode(mode) {
 	_getState().currentFetchCacheMode = mode;
 }
@@ -728,4 +738,4 @@ function getOriginalFetch() {
 	return originalFetch;
 }
 //#endregion
-export { _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, withFetchCache };
+export { _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, withFetchCache };

package/dist/shims/head.js

@@ -104,6 +104,10 @@ const SELF_CLOSING_HEAD_TAGS = new Set([
 ]);
 /** Tags whose content is raw text — closing-tag sequences must be escaped during SSR. */
 const RAW_CONTENT_TAGS = new Set(["script", "style"]);
+const INLINE_CLOSE_TAG_RES = {
+	script: /<\/(script)/gi,
+	style: /<\/(style)/gi
+};
 function warnDisallowedHeadTag(tag) {
 	if (process.env.NODE_ENV !== "production") console.warn(`[vinext] <Head> ignoring disallowed tag <${tag}>. Only ${ALLOWED_HEAD_TAGS_LIST} are allowed.`);
 }
@@ -247,7 +251,8 @@ function escapeAttr(s) {
 * context but prevents the HTML parser from seeing a closing tag.
 */
 function escapeInlineContent(content, tag) {
-	const pattern = new RegExp(`<\\/(${tag})`, "gi");
+	const pattern = INLINE_CLOSE_TAG_RES[tag];
+	if (!pattern) return content;
 	return content.replace(pattern, "<\\/$1");
 }
 function getDangerouslySetInnerHTML(value) {

package/dist/shims/headers.d.ts

@@ -18,12 +18,24 @@ type HeadersAccessPhase = "render" | "action" | "route-handler";
 type VinextHeadersShimState = {
   headersContext: HeadersContext | null;
   dynamicUsageDetected: boolean;
-  renderRequestApiUsage: Set<RenderRequestApiKind>; /** Error recorded by throwIfInsideCacheScope for dev diagnostics, persists even if caught by user code. */
+  renderRequestApiUsage: Set<RenderRequestApiKind>;
+  connectionProbe: ConnectionProbeState | null; /** Error recorded by throwIfInsideCacheScope for dev diagnostics, persists even if caught by user code. */
   invalidDynamicUsageError: unknown;
   pendingSetCookies: string[];
   draftModeCookieHeader: string | null;
   phase: HeadersAccessPhase;
 };
+type ConnectionProbeState = {
+  interrupted: boolean;
+  interrupt: () => void;
+  pending: Promise<never>;
+};
+type ConnectionProbeResult<T> = {
+  completed: true;
+  result: T;
+} | {
+  completed: false;
+};
 /**
  * Dynamic usage flag — set when a component calls connection(), cookies(),
  * headers(), or noStore() during rendering. When true, ISR caching is
@@ -35,6 +47,8 @@ type VinextHeadersShimState = {
  */
 declare function markDynamicUsage(): void;
 declare function markRenderRequestApiUsage(kind: RenderRequestApiKind): void;
+declare function runWithConnectionProbe<T>(fn: () => T | Promise<T>): Promise<ConnectionProbeResult<T>>;
+declare function suspendConnectionProbe(): Promise<never> | null;
 declare function peekRenderRequestApiUsage(): RenderRequestApiKind[];
 declare function consumeRenderRequestApiUsage(): RenderRequestApiKind[];
 /**
@@ -236,4 +250,4 @@ declare class RequestCookies {
   toString(): string;
 }
 //#endregion
-export { HeadersAccessPhase, HeadersContext, type RequestCookies, VinextHeadersShimState, applyMiddlewareRequestHeaders, consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, cookies, draftMode, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersAccessPhase, getHeadersContext, headers, headersContextFromRequest, isDraftModeRequest, markDynamicUsage, markRenderRequestApiUsage, peekDynamicUsage, peekRenderRequestApiUsage, runWithHeadersContext, setHeadersAccessPhase, setHeadersContext, throwIfInsideCacheScope };
+export { HeadersAccessPhase, HeadersContext, type RequestCookies, VinextHeadersShimState, applyMiddlewareRequestHeaders, consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, cookies, draftMode, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersAccessPhase, getHeadersContext, headers, headersContextFromRequest, isDraftModeRequest, markDynamicUsage, markRenderRequestApiUsage, peekDynamicUsage, peekRenderRequestApiUsage, runWithConnectionProbe, runWithHeadersContext, setHeadersAccessPhase, setHeadersContext, suspendConnectionProbe, throwIfInsideCacheScope };

package/dist/shims/headers.js

@@ -21,6 +21,7 @@ const _fallbackState = _g[_FALLBACK_KEY] ??= {
 	headersContext: null,
 	dynamicUsageDetected: false,
 	renderRequestApiUsage: /* @__PURE__ */ new Set(),
+	connectionProbe: null,
 	invalidDynamicUsageError: null,
 	pendingSetCookies: [],
 	draftModeCookieHeader: null,
@@ -115,6 +116,39 @@ function markDynamicUsage() {
 function markRenderRequestApiUsage(kind) {
 	_getState().renderRequestApiUsage.add(kind);
 }
+async function runWithConnectionProbe(fn) {
+	const state = _getState();
+	const previousProbe = state.connectionProbe;
+	let interruptProbe = () => {};
+	const interrupted = new Promise((resolve) => {
+		interruptProbe = () => resolve({ completed: false });
+	});
+	const probe = {
+		interrupted: false,
+		interrupt() {
+			if (probe.interrupted) return;
+			probe.interrupted = true;
+			interruptProbe();
+		},
+		pending: new Promise(() => {})
+	};
+	state.connectionProbe = probe;
+	try {
+		const completed = Promise.resolve().then(fn).then((result) => ({
+			completed: true,
+			result
+		}));
+		return await Promise.race([completed, interrupted]);
+	} finally {
+		state.connectionProbe = previousProbe;
+	}
+}
+function suspendConnectionProbe() {
+	const probe = _getState().connectionProbe;
+	if (!probe) return null;
+	probe.interrupt();
+	return probe.pending;
+}
 function peekRenderRequestApiUsage() {
 	return [..._getState().renderRequestApiUsage].sort();
 }
@@ -260,6 +294,7 @@ function runWithHeadersContext(ctx, fn) {
 		uCtx.headersContext = ctx;
 		uCtx.dynamicUsageDetected = false;
 		uCtx.renderRequestApiUsage = /* @__PURE__ */ new Set();
+		uCtx.connectionProbe = null;
 		uCtx.pendingSetCookies = [];
 		uCtx.draftModeCookieHeader = null;
 		uCtx.phase = "render";
@@ -268,6 +303,7 @@ function runWithHeadersContext(ctx, fn) {
 		headersContext: ctx,
 		dynamicUsageDetected: false,
 		renderRequestApiUsage: /* @__PURE__ */ new Set(),
+		connectionProbe: null,
 		invalidDynamicUsageError: null,
 		pendingSetCookies: [],
 		draftModeCookieHeader: null,
@@ -690,4 +726,4 @@ var RequestCookies = class {
 	}
 };
 //#endregion
-export { applyMiddlewareRequestHeaders, consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, cookies, draftMode, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersAccessPhase, getHeadersContext, headers, headersContextFromRequest, isDraftModeRequest, markDynamicUsage, markRenderRequestApiUsage, peekDynamicUsage, peekRenderRequestApiUsage, runWithHeadersContext, setHeadersAccessPhase, setHeadersContext, throwIfInsideCacheScope };
+export { applyMiddlewareRequestHeaders, consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, cookies, draftMode, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersAccessPhase, getHeadersContext, headers, headersContextFromRequest, isDraftModeRequest, markDynamicUsage, markRenderRequestApiUsage, peekDynamicUsage, peekRenderRequestApiUsage, runWithConnectionProbe, runWithHeadersContext, setHeadersAccessPhase, setHeadersContext, suspendConnectionProbe, throwIfInsideCacheScope };

package/dist/shims/image-config.js

@@ -1,5 +1,6 @@
 import ipaddr from "ipaddr.js";
 //#region src/shims/image-config.ts
+const globRegexCache = /* @__PURE__ */ new Map();
 /**
 * Convert a glob pattern (with `*` and `**`) to a RegExp.
 *
@@ -14,6 +15,9 @@ import ipaddr from "ipaddr.js";
 * Literal characters are escaped for regex safety.
 */
 function globToRegex(pattern, separator) {
+	const key = `${separator}\0${pattern}`;
+	const cached = globRegexCache.get(key);
+	if (cached !== void 0) return cached;
 	let regexStr = "^";
 	const doubleStar = separator === "." ? ".+" : ".*";
 	const singleStar = separator === "." ? "[^.]+" : "[^/]+";
@@ -27,7 +31,9 @@ function globToRegex(pattern, separator) {
 		}
 	}
 	regexStr += "$";
-	return new RegExp(regexStr);
+	const re = new RegExp(regexStr);
+	globRegexCache.set(key, re);
+	return re;
 }
 /**
 * Check whether a URL matches a single remote pattern.

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

@@ -27,9 +27,12 @@ declare function getPagesRouterComponentsMap(): PagesRouterComponentsMap;
  * 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).
+ * `pathname` is the basePath-stripped, trailing-slash-stripped path —
+ * matching Next.js's `removeTrailingSlash(removeBasePath(pathname))` key used
+ * at read time (router.ts:1442). Stripping here ensures the write and read
+ * keys agree regardless of whether the caller normalised trailing slashes
+ * 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): void;
 //#endregion

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

@@ -1,4 +1,4 @@
-import { stripBasePath } from "../../utils/base-path.js";
+import { removeTrailingSlash, 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();
@@ -52,15 +52,19 @@ function matchesAppRoute(href, basePath) {
 * 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).
+* `pathname` is the basePath-stripped, trailing-slash-stripped path —
+* matching Next.js's `removeTrailingSlash(removeBasePath(pathname))` key used
+* at read time (router.ts:1442). Stripping here ensures the write and read
+* keys agree regardless of whether the caller normalised trailing slashes
+* first (e.g. `link.tsx` normalises to match `trailingSlash` config before
+* calling, while `router.prefetch()` passes the raw user-supplied URL).
 */
 function markAppRouteDetectedOnPrefetch(href, basePath) {
 	if (typeof window === "undefined") return;
 	if (!matchesAppRoute(href, basePath)) return;
-	const pathname = resolveSameOriginPathname(href, basePath);
-	if (pathname === null) return;
+	const rawPathname = resolveSameOriginPathname(href, basePath);
+	if (rawPathname === null) return;
+	const pathname = removeTrailingSlash(rawPathname);
 	getPagesRouterComponentsMap()[pathname] = { __appRouter: true };
 }
 //#endregion

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

@@ -16,6 +16,11 @@ type AppRouterInstance = {
   push(href: string, options?: NavigateOptions): void;
   replace(href: string, options?: NavigateOptions): void;
   prefetch(href: string, options?: PrefetchOptions): void;
+  /**
+   * Perform an experimental gesture transition navigation.
+   * Only available when experimental.gestureTransition is enabled.
+   */
+  experimental_gesturePush?(href: string, options?: NavigateOptions): void;
 };
 declare const AppRouterContext: React$1.Context<AppRouterInstance | null> | null;
 declare const GlobalLayoutRouterContext: React$1.Context<unknown> | null;

package/dist/shims/metadata.d.ts

@@ -271,11 +271,15 @@ declare function resolveModuleMetadata(mod: Record<string, unknown>, params?: Re
 type MetadataHeadProps = {
   metadata: Metadata;
   pathname?: string;
+  trailingSlash?: boolean;
 };
-declare function renderMetadataToHtml(metadata: Metadata, pathname?: string): string;
+declare function renderMetadataToHtml(metadata: Metadata, pathname?: string, options?: {
+  trailingSlash?: boolean;
+}): string;
 declare function MetadataHead({
   metadata,
-  pathname
+  pathname,
+  trailingSlash
 }: MetadataHeadProps): React.JSX.Element;
 //#endregion
 export { DEFAULT_VIEWPORT, Metadata, MetadataHead, MetadataMergeEntry, Viewport, ViewportHead, mergeMetadata, mergeMetadataEntries, mergeViewport, postProcessMetadata, renderMetadataToHtml, resolveModuleMetadata, resolveModuleViewport };

package/dist/shims/metadata.js

@@ -287,18 +287,35 @@ function formatResolvedMetadataUrl(url) {
 	if (url.pathname === "/" && url.search === "" && url.hash === "") return url.origin;
 	return url.href;
 }
-function resolveMetadataUrl(url, metadataBase) {
+const TRAILING_SLASH_FILE_REGEX = /^(?:\/((?!\.well-known(?:\/.*)?)((?:[^/]+\/)*)([^/]+\.\w+)))(\/?|$)/i;
+function resolveMetadataUrl(url, metadataBase, trailingSlash) {
 	const value = stringifyUrl(url);
-	if (isAbsoluteOrProtocolRelativeUrl(value) || !metadataBase) return value;
+	if (!metadataBase) return value;
 	try {
-		return formatResolvedMetadataUrl(new URL(joinMetadataPath(metadataBase.pathname, value), metadataBase));
+		const isAbsolute = isAbsoluteOrProtocolRelativeUrl(value);
+		const composed = isAbsolute ? new URL(value, metadataBase) : new URL(joinMetadataPath(metadataBase.pathname, value), metadataBase);
+		if (isAbsolute && composed.origin !== metadataBase.origin) return value;
+		if (trailingSlash === true && composed.search === "") {
+			if (composed.pathname !== "/" && !composed.pathname.endsWith("/") && !TRAILING_SLASH_FILE_REGEX.test(composed.pathname)) composed.pathname += "/";
+		}
+		const result = formatResolvedMetadataUrl(composed);
+		if (trailingSlash === true && result === metadataBase.origin) return `${metadataBase.origin}/`;
+		return result;
 	} catch {
 		return value;
 	}
 }
-function resolveCanonicalUrl(url, metadataBase, pathname) {
-	if (url instanceof URL) return resolveMetadataUrl(url, metadataBase);
-	return resolveMetadataUrl(resolveRelativeMetadataUrl(url, pathname), metadataBase);
+function resolveCanonicalUrl(url, metadataBase, pathname, trailingSlash) {
+	if (url instanceof URL) return resolveMetadataUrl(url, metadataBase, trailingSlash);
+	return resolveMetadataUrl(resolveRelativeMetadataUrl(url, pathname), metadataBase, trailingSlash);
+}
+function resolveAlternateUrl(url, metadataBase, pathname, trailingSlash) {
+	if (url instanceof URL) {
+		const resolvedUrl = new URL(pathname, url);
+		url.searchParams.forEach((value, key) => resolvedUrl.searchParams.set(key, value));
+		return resolveMetadataUrl(resolvedUrl, metadataBase, trailingSlash);
+	}
+	return resolveCanonicalUrl(url, metadataBase, pathname, trailingSlash);
 }
 function isSocialImageDescriptor(value) {
 	return typeof value === "object" && !(value instanceof URL);
@@ -359,13 +376,14 @@ function renderMetadataElementToHtml(node) {
 		default: return "";
 	}
 }
-function renderMetadataToHtml(metadata, pathname = "/") {
+function renderMetadataToHtml(metadata, pathname = "/", options) {
 	return renderMetadataElementToHtml(MetadataHead({
 		metadata,
-		pathname
+		pathname,
+		trailingSlash: options?.trailingSlash
 	}));
 }
-function MetadataHead({ metadata, pathname = "/" }) {
+function MetadataHead({ metadata, pathname = "/", trailingSlash }) {
 	const elements = [];
 	let key = 0;
 	const base = metadata.metadataBase;
@@ -474,7 +492,7 @@ function MetadataHead({ metadata, pathname = "/" }) {
 		}, key++));
 		if (og.url) elements.push(/* @__PURE__ */ jsx("meta", {
 			property: "og:url",
-			content: resolveUrl(og.url)
+			content: resolveCanonicalUrl(og.url, base, pathname, trailingSlash)
 		}, key++));
 		if (og.siteName) elements.push(/* @__PURE__ */ jsx("meta", {
 			property: "og:site_name",
@@ -691,22 +709,22 @@ function MetadataHead({ metadata, pathname = "/" }) {
 		const alt = metadata.alternates;
 		if (alt.canonical) elements.push(/* @__PURE__ */ jsx("link", {
 			rel: "canonical",
-			href: resolveCanonicalUrl(alt.canonical, base, pathname)
+			href: resolveCanonicalUrl(alt.canonical, base, pathname, trailingSlash)
 		}, key++));
 		if (alt.languages) for (const [lang, href] of Object.entries(alt.languages)) elements.push(/* @__PURE__ */ jsx("link", {
 			rel: "alternate",
 			hrefLang: lang,
-			href: resolveUrl(href)
+			href: resolveAlternateUrl(href, base, pathname, trailingSlash)
 		}, key++));
 		if (alt.media) for (const [media, href] of Object.entries(alt.media)) elements.push(/* @__PURE__ */ jsx("link", {
 			rel: "alternate",
 			media,
-			href: resolveUrl(href)
+			href: resolveAlternateUrl(href, base, pathname, trailingSlash)
 		}, key++));
 		if (alt.types) for (const [type, href] of Object.entries(alt.types)) elements.push(/* @__PURE__ */ jsx("link", {
 			rel: "alternate",
 			type,
-			href: resolveUrl(href)
+			href: resolveAlternateUrl(href, base, pathname, trailingSlash)
 		}, key++));
 	}
 	if (metadata.verification) {