vinext 0.0.54 → 0.1.0

package/dist/shims/slot.d.ts

@@ -1,6 +1,5 @@
 import { AppElementValue, AppElements, UNMATCHED_SLOT } from "../server/app-elements-wire.js";
 import * as React$1 from "react";
-import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 
 //#region src/shims/slot.d.ts
 /**
@@ -11,12 +10,21 @@ import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 declare const ElementsContext: React$1.Context<Readonly<Record<string, AppElementValue>>>;
 declare const ChildrenContext: React$1.Context<React$1.ReactNode>;
 declare const ParallelSlotsContext: React$1.Context<Readonly<Record<string, React$1.ReactNode>> | null>;
+declare const BfcacheStateKeyMapContext: React$1.Context<Readonly<Record<string, string>>>;
+type BfcacheSlotEntry = {
+  content: React$1.ReactNode;
+  elements?: AppElements;
+  segmentId?: string;
+  stateKey: string;
+  stateKeyMap?: Readonly<Record<string, string>>;
+};
 type MergeElementsOptions = {
   clearAbsentSlots?: boolean;
   preserveAbsentSlots?: boolean;
   preserveElementIds?: readonly string[];
   preservePreviousSlotIds?: readonly string[];
 };
+declare function updateBfcacheSlotEntryOrder(previousOrder: readonly string[], activeStateKey: string, maxEntries?: number): string[];
 declare function mergeElements(prev: AppElements, next: AppElements, options?: MergeElementsOptions | boolean): AppElements;
 declare function Slot({
   id,
@@ -26,7 +34,7 @@ declare function Slot({
   id: string;
   children?: React$1.ReactNode;
   parallelSlots?: Readonly<Record<string, React$1.ReactNode>>;
-}): _$react_jsx_runtime0.JSX.Element | null;
+}): React$1.JSX.Element | null;
 declare function Children(): React$1.ReactNode;
 declare function ParallelSlot({
   name
@@ -34,5 +42,4 @@ declare function ParallelSlot({
   name: string;
 }): string | number | bigint | boolean | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | null;
 //#endregion
-export { Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, Slot, UNMATCHED_SLOT, mergeElements };
-//# sourceMappingURL=slot.d.ts.map
+export { BfcacheSlotEntry, BfcacheStateKeyMapContext, Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, Slot, UNMATCHED_SLOT, mergeElements, updateBfcacheSlotEntryOrder };

package/dist/shims/slot.js

@@ -1,9 +1,9 @@
 "use client";
 import { AppElementsWire, UNMATCHED_SLOT } from "../server/app-elements-wire.js";
 import "../server/app-elements.js";
-import { notFound } from "./navigation.js";
+import { getBfcacheIdMapContext, getBfcacheSegmentIdContext, notFound } from "./navigation.js";
 import * as React$1 from "react";
-import { jsx } from "react/jsx-runtime";
+import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
 //#region src/shims/slot.tsx
 const EMPTY_ELEMENTS = Object.freeze({});
 const warnedMissingEntryIds = /* @__PURE__ */ new Set();
@@ -16,6 +16,41 @@ const warnedTransportMetadataEntryIds = /* @__PURE__ */ new Set();
 const ElementsContext = React$1.createContext(EMPTY_ELEMENTS);
 const ChildrenContext = React$1.createContext(null);
 const ParallelSlotsContext = React$1.createContext(null);
+const BfcacheIdMapContext = getBfcacheIdMapContext();
+const BfcacheSegmentIdContext = getBfcacheSegmentIdContext();
+const EMPTY_BFCACHE_STATE_KEYS = Object.freeze({});
+const MAX_BFCACHE_SLOT_ENTRIES_WITH_CACHE_COMPONENTS = 3;
+const MAX_BFCACHE_SLOT_ENTRIES_WITHOUT_CACHE_COMPONENTS = 1;
+const BfcacheStateKeyMapContext = React$1.createContext(EMPTY_BFCACHE_STATE_KEYS);
+function isCacheComponentsEnabled() {
+	return process.env.__NEXT_CACHE_COMPONENTS === "true";
+}
+function getBfcacheSlotEntryLimit() {
+	return isCacheComponentsEnabled() ? MAX_BFCACHE_SLOT_ENTRIES_WITH_CACHE_COMPONENTS : MAX_BFCACHE_SLOT_ENTRIES_WITHOUT_CACHE_COMPONENTS;
+}
+function normalizeBfcacheSlotEntryLimit(maxEntries) {
+	if (!Number.isFinite(maxEntries)) return 1;
+	return Math.max(1, Math.trunc(maxEntries));
+}
+function updateBfcacheSlotEntryOrder(previousOrder, activeStateKey, maxEntries = getBfcacheSlotEntryLimit()) {
+	const entryLimit = normalizeBfcacheSlotEntryLimit(maxEntries);
+	const nextOrder = [activeStateKey];
+	for (const stateKey of previousOrder) {
+		if (nextOrder.length >= entryLimit) break;
+		if (stateKey === activeStateKey) continue;
+		nextOrder.push(stateKey);
+	}
+	return nextOrder;
+}
+function pruneBfcacheSlotEntrySnapshots(snapshotsByStateKey, retainedOrder) {
+	const retainedKeys = new Set(retainedOrder);
+	for (const stateKey of snapshotsByStateKey.keys()) if (!retainedKeys.has(stateKey)) snapshotsByStateKey.delete(stateKey);
+}
+function haveSameBfcacheSlotEntryOrder(left, right) {
+	if (left.length !== right.length) return false;
+	for (let index = 0; index < left.length; index++) if (left[index] !== right[index]) return false;
+	return true;
+}
 function isLayoutFlagsValue(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
 	const entries = Object.values(value);
@@ -32,6 +67,9 @@ function isSlotBindingValue(value) {
 function isSlotBindingListValue(value) {
 	return Array.isArray(value) && value.length > 0 && value.every(isSlotBindingValue);
 }
+function isSkippedLayoutIdsMetadataValue(id, value) {
+	return id === "__skippedLayoutIds" && Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
 function isInterceptionMetadataValue(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
 	return "sourceMatchedUrl" in value && typeof value.sourceMatchedUrl === "string" && "sourceRouteId" in value && typeof value.sourceRouteId === "string" && "slotId" in value && typeof value.slotId === "string" && "targetMatchedUrl" in value && typeof value.targetMatchedUrl === "string" && "targetRouteId" in value && typeof value.targetRouteId === "string";
@@ -40,8 +78,8 @@ function isCacheEntryReuseProofValue(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
 	return "kind" in value && value.kind === "runtime-cache-entry" && "decision" in value;
 }
-function isTransportMetadataValue(value) {
-	return isLayoutFlagsValue(value) || isArtifactCompatibilityEnvelopeValue(value) || isCacheEntryReuseProofValue(value) || isInterceptionMetadataValue(value) || isSlotBindingListValue(value);
+function isTransportMetadataValue(id, value) {
+	return isLayoutFlagsValue(value) || isArtifactCompatibilityEnvelopeValue(value) || isCacheEntryReuseProofValue(value) || isInterceptionMetadataValue(value) || isSkippedLayoutIdsMetadataValue(id, value) || isSlotBindingListValue(value);
 }
 function warnTransportMetadataEntry(id) {
 	if (process.env.NODE_ENV === "production") return;
@@ -49,6 +87,77 @@ function warnTransportMetadataEntry(id) {
 	warnedTransportMetadataEntryIds.add(id);
 	console.warn("[vinext] Transport metadata value found under App Router render entry: " + id);
 }
+/**
+* Provider stack for Activity-retained BFCache entries. Each retained entry
+* re-provides the elements, state-key map, and segment id it was captured with,
+* falling back to the live boundary values for entries that predate per-entry
+* capture.
+*/
+function BfcacheEntryProviders({ entry, fallbackElements, fallbackSegmentId, fallbackStateKeyMap, SegmentContext }) {
+	return /* @__PURE__ */ jsx(BfcacheStateKeyMapContext.Provider, {
+		value: entry.stateKeyMap ?? fallbackStateKeyMap,
+		children: /* @__PURE__ */ jsx(ElementsContext.Provider, {
+			value: entry.elements ?? fallbackElements,
+			children: /* @__PURE__ */ jsx(SegmentContext.Provider, {
+				value: entry.segmentId ?? fallbackSegmentId,
+				children: entry.content
+			})
+		})
+	});
+}
+function useBfcacheSlotEntries(activeEntry) {
+	const snapshotsByStateKey = React$1.useRef(/* @__PURE__ */ new Map());
+	const [entryOrder, setEntryOrder] = React$1.useState(() => [activeEntry.stateKey]);
+	snapshotsByStateKey.current.set(activeEntry.stateKey, activeEntry);
+	const nextOrder = updateBfcacheSlotEntryOrder(entryOrder, activeEntry.stateKey);
+	const orderChanged = !haveSameBfcacheSlotEntryOrder(entryOrder, nextOrder);
+	const renderOrder = orderChanged ? nextOrder : entryOrder;
+	pruneBfcacheSlotEntrySnapshots(snapshotsByStateKey.current, renderOrder);
+	if (process.env.NODE_ENV !== "production" && !snapshotsByStateKey.current.has(activeEntry.stateKey)) throw new Error("BFCache Activity slot is missing the active entry snapshot");
+	if (orderChanged) setEntryOrder(nextOrder);
+	return renderOrder.map((stateKey) => snapshotsByStateKey.current.get(stateKey)).filter((entry) => entry !== void 0);
+}
+function BfcacheActivitySlotBoundary({ activeStateKey, content, elements, id, SegmentContext, stateKeyMap }) {
+	return /* @__PURE__ */ jsx(Fragment$1, { children: useBfcacheSlotEntries({
+		content,
+		elements,
+		segmentId: id,
+		stateKey: activeStateKey,
+		stateKeyMap
+	}).map((entry) => /* @__PURE__ */ jsx(React$1.Activity, {
+		mode: entry.stateKey === activeStateKey ? "visible" : "hidden",
+		children: /* @__PURE__ */ jsx(BfcacheEntryProviders, {
+			entry,
+			fallbackElements: elements,
+			fallbackSegmentId: id,
+			fallbackStateKeyMap: stateKeyMap,
+			SegmentContext
+		})
+	}, entry.stateKey)) });
+}
+function BfcacheSlotBoundary({ content, id }) {
+	const SegmentContext = BfcacheSegmentIdContext;
+	const elements = React$1.useContext(ElementsContext);
+	const stateKeyMap = React$1.useContext(BfcacheStateKeyMapContext);
+	const activeStateKey = stateKeyMap[id];
+	if (!SegmentContext) return /* @__PURE__ */ jsx(Fragment$1, { children: content });
+	if (activeStateKey === void 0) return /* @__PURE__ */ jsx(SegmentContext.Provider, {
+		value: id,
+		children: content
+	});
+	if (!isCacheComponentsEnabled()) return /* @__PURE__ */ jsx(SegmentContext.Provider, {
+		value: id,
+		children: content
+	});
+	return /* @__PURE__ */ jsx(BfcacheActivitySlotBoundary, {
+		activeStateKey,
+		content,
+		elements,
+		id,
+		SegmentContext,
+		stateKeyMap
+	});
+}
 function mergeElements(prev, next, options = {}) {
 	const clearAbsentSlots = typeof options === "boolean" ? options : options.clearAbsentSlots ?? false;
 	const preserveAbsentSlots = typeof options === "boolean" ? !options : options.preserveAbsentSlots ?? true;
@@ -91,18 +200,23 @@ function Slot({ id, children, parallelSlots }) {
 		return null;
 	}
 	const element = elements[id];
-	if (isTransportMetadataValue(element)) {
+	if (isTransportMetadataValue(id, element)) {
 		warnTransportMetadataEntry(id);
 		return null;
 	}
 	if (element === UNMATCHED_SLOT) notFound();
-	return /* @__PURE__ */ jsx(ParallelSlotsContext.Provider, {
+	if (element === null) return null;
+	const content = /* @__PURE__ */ jsx(ParallelSlotsContext.Provider, {
 		value: parallelSlots ?? null,
 		children: /* @__PURE__ */ jsx(ChildrenContext.Provider, {
 			value: children ?? null,
 			children: element
 		})
 	});
+	return BfcacheIdMapContext && BfcacheSegmentIdContext ? /* @__PURE__ */ jsx(BfcacheSlotBoundary, {
+		id,
+		content
+	}) : content;
 }
 function Children() {
 	return React$1.useContext(ChildrenContext);
@@ -111,6 +225,4 @@ function ParallelSlot({ name }) {
 	return React$1.useContext(ParallelSlotsContext)?.[name] ?? null;
 }
 //#endregion
-export { Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, Slot, UNMATCHED_SLOT, mergeElements };
-
-//# sourceMappingURL=slot.js.map
+export { BfcacheStateKeyMapContext, Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, Slot, UNMATCHED_SLOT, mergeElements, updateBfcacheSlotEntryOrder };

package/dist/shims/thenable-params.d.ts

@@ -2,7 +2,10 @@
 declare const WELL_KNOWN_PROPERTIES: readonly ["hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toString", "valueOf", "toLocaleString", "then", "catch", "finally", "status", "value", "error", "displayName", "_debugInfo", "toJSON", "$$typeof", "__esModule", "@@iterator"];
 type WellKnownProperty = (typeof WELL_KNOWN_PROPERTIES)[number];
 type ThenableParams<T extends Record<string, unknown>> = Promise<T> & Omit<T, WellKnownProperty>;
-declare function makeThenableParams<T extends Record<string, unknown>>(obj: T): ThenableParams<T>;
+type ThenableParamsObserver = Readonly<{
+  observeParamAccess: (keys: readonly string[]) => void;
+  observeReactPromiseStatus?: boolean;
+}>;
+declare function makeThenableParams<T extends Record<string, unknown>>(obj: T, observer?: ThenableParamsObserver): ThenableParams<T>;
 //#endregion
-export { ThenableParams, makeThenableParams };
-//# sourceMappingURL=thenable-params.d.ts.map
+export { ThenableParams, ThenableParamsObserver, makeThenableParams };

package/dist/shims/thenable-params.js

@@ -1,3 +1,4 @@
+import { createPprFallbackShellSuspensePromiseForState, getPprFallbackShellState } from "./ppr-fallback-shell.js";
 //#region src/shims/thenable-params.ts
 function hasParamProperty(obj, prop) {
 	return Object.prototype.hasOwnProperty.call(obj, prop);
@@ -25,33 +26,151 @@ const wellKnownProperties = new Set([
 function isWellKnownProperty(prop) {
 	return wellKnownProperties.has(prop);
 }
-function makeThenableParams(obj) {
+function observeParamKeys(observer, keys) {
+	if (observer) observer.observeParamAccess(keys);
+}
+function observeAllParamKeys(observer, plain) {
+	observeParamKeys(observer, Object.keys(plain));
+}
+function observeReadableParamKeys(observer, plain) {
+	observeParamKeys(observer, Object.keys(plain).filter((key) => !isWellKnownProperty(key)));
+}
+function isPromiseContinuation(prop) {
+	return prop === "then" || prop === "catch" || prop === "finally";
+}
+/**
+* Build a proxy around `plain` that preserves fallback-key suspension.
+* This is the value `await params` resolves to during fallback-shell
+* prerendering. Known params are readable synchronously; fallback params
+* suspend (throw a hanging promise) only when actually accessed.
+*
+* The handler is typed as `ProxyHandler<T>` and no cast is needed because
+* the target is already `plain: T`.
+*/
+function createResolvedParamsProxy(plain, fallbackParamNames, observer, getFallbackShellPromise) {
+	if (!fallbackParamNames || fallbackParamNames.size === 0) return plain;
+	function isFallbackParam(prop) {
+		return typeof prop === "string" && fallbackParamNames !== null && fallbackParamNames.has(prop);
+	}
+	return new Proxy(plain, {
+		get(_target, prop, _receiver) {
+			if (typeof prop === "string" && !isWellKnownProperty(prop)) observeParamKeys(observer, [prop]);
+			if (!isWellKnownProperty(prop) && hasParamProperty(plain, prop)) {
+				if (isFallbackParam(prop)) {
+					const p = getFallbackShellPromise();
+					if (p) throw p;
+				}
+				return Reflect.get(plain, prop);
+			}
+			return Reflect.get(plain, prop);
+		},
+		getOwnPropertyDescriptor(_target, prop) {
+			if (typeof prop === "string" && !isWellKnownProperty(prop)) observeParamKeys(observer, [prop]);
+			if (!isWellKnownProperty(prop) && hasParamProperty(plain, prop)) {
+				if (isFallbackParam(prop)) return {
+					configurable: true,
+					enumerable: true,
+					get() {
+						const p = getFallbackShellPromise();
+						if (p) throw p;
+					}
+				};
+				return {
+					configurable: true,
+					enumerable: true,
+					value: Reflect.get(plain, prop),
+					writable: true
+				};
+			}
+			return Reflect.getOwnPropertyDescriptor(plain, prop);
+		},
+		has(_target, prop) {
+			if (typeof prop === "string" && !isWellKnownProperty(prop)) observeParamKeys(observer, [prop]);
+			return Reflect.has(plain, prop) || !isWellKnownProperty(prop) && hasParamProperty(plain, prop);
+		},
+		ownKeys() {
+			observeReadableParamKeys(observer, plain);
+			return Reflect.ownKeys(plain).filter((prop) => !isWellKnownProperty(prop));
+		}
+	});
+}
+/**
+* Wrap a `Promise<T>` with a proxy that also exposes param properties for
+* synchronous access. TypeScript cannot prove this hybrid shape statically,
+* so the single `as ThenableParams<T>` cast is isolated here.
+*/
+function createThenableParamsProxy(promise, handler) {
+	return new Proxy(promise, handler);
+}
+function makeThenableParams(obj, observer) {
 	const plain = { ...obj };
-	const promise = Promise.resolve(plain);
-	return new Proxy(promise, {
+	const fallbackShellState = getPprFallbackShellState();
+	const fallbackParamNames = fallbackShellState && Object.keys(plain).some((key) => fallbackShellState.fallbackParamNames.has(key)) ? fallbackShellState.fallbackParamNames : null;
+	let fallbackShellPromise = null;
+	let fallbackShellPromiseController = null;
+	function getFallbackShellPromise() {
+		if (!fallbackParamNames || !fallbackShellState) return null;
+		if (fallbackShellPromise && fallbackShellPromiseController === fallbackShellState.abortController) return fallbackShellPromise;
+		fallbackShellPromiseController = fallbackShellState.abortController;
+		fallbackShellPromise = createPprFallbackShellSuspensePromiseForState(fallbackShellState, "`params`");
+		return fallbackShellPromise;
+	}
+	const resolvedParams = createResolvedParamsProxy(plain, fallbackParamNames, observer, getFallbackShellPromise);
+	const promise = Promise.resolve(resolvedParams);
+	function isFallbackParam(prop) {
+		return typeof prop === "string" && (fallbackParamNames?.has(prop) ?? false);
+	}
+	return createThenableParamsProxy(promise, {
 		get(target, prop, receiver) {
-			if (!isWellKnownProperty(prop) && hasParamProperty(plain, prop)) return Reflect.get(plain, prop);
+			if (isPromiseContinuation(prop)) {
+				const value = Reflect.get(target, prop, receiver);
+				if (typeof value !== "function") return value;
+				return (...args) => {
+					if (!fallbackParamNames) observeAllParamKeys(observer, plain);
+					return Reflect.apply(value, target, args);
+				};
+			}
+			if (prop === "status" && observer?.observeReactPromiseStatus === true) observeAllParamKeys(observer, plain);
+			if (typeof prop === "string" && !isWellKnownProperty(prop)) observeParamKeys(observer, [prop]);
+			if (!isWellKnownProperty(prop) && hasParamProperty(plain, prop)) {
+				if (isFallbackParam(prop)) {
+					const p = getFallbackShellPromise();
+					if (p) throw p;
+				}
+				return Reflect.get(plain, prop);
+			}
 			const value = Reflect.get(target, prop, receiver);
 			return typeof value === "function" ? value.bind(target) : value;
 		},
 		getOwnPropertyDescriptor(target, prop) {
-			if (!isWellKnownProperty(prop) && hasParamProperty(plain, prop)) return {
-				configurable: true,
-				enumerable: true,
-				value: Reflect.get(plain, prop),
-				writable: true
-			};
+			if (typeof prop === "string" && !isWellKnownProperty(prop)) observeParamKeys(observer, [prop]);
+			if (!isWellKnownProperty(prop) && hasParamProperty(plain, prop)) {
+				if (isFallbackParam(prop)) return {
+					configurable: true,
+					enumerable: true,
+					get() {
+						const p = getFallbackShellPromise();
+						if (p) throw p;
+					}
+				};
+				return {
+					configurable: true,
+					enumerable: true,
+					value: Reflect.get(plain, prop),
+					writable: true
+				};
+			}
 			return Reflect.getOwnPropertyDescriptor(target, prop);
 		},
 		has(target, prop) {
+			if (typeof prop === "string" && !isWellKnownProperty(prop)) observeParamKeys(observer, [prop]);
 			return Reflect.has(target, prop) || !isWellKnownProperty(prop) && hasParamProperty(plain, prop);
 		},
 		ownKeys() {
+			observeReadableParamKeys(observer, plain);
 			return Reflect.ownKeys(plain).filter((prop) => !isWellKnownProperty(prop));
 		}
 	});
 }
 //#endregion
 export { makeThenableParams };
-
-//# sourceMappingURL=thenable-params.js.map

package/dist/shims/unified-request-context.d.ts

@@ -65,5 +65,4 @@ declare function getRequestContext(): UnifiedRequestContext;
  */
 declare function isInsideUnifiedScope(): boolean;
 //#endregion
-export { UnifiedRequestContext, createRequestContext, getRequestContext, isInsideUnifiedScope, runWithRequestContext, runWithUnifiedStateMutation };
-//# sourceMappingURL=unified-request-context.d.ts.map
+export { UnifiedRequestContext, createRequestContext, getRequestContext, isInsideUnifiedScope, runWithRequestContext, runWithUnifiedStateMutation };

package/dist/shims/unified-request-context.js

@@ -26,8 +26,10 @@ function createRequestContext(opts) {
 		serverContext: null,
 		serverInsertedHTMLCallbacks: [],
 		requestScopedCacheLife: null,
+		unstableCacheObservations: /* @__PURE__ */ new Map(),
 		unstableCacheRevalidation: "foreground",
 		_privateCache: null,
+		cacheableFetchUrls: /* @__PURE__ */ new Set(),
 		currentRequestTags: [],
 		currentFetchSoftTags: [],
 		currentFetchCacheMode: null,
@@ -38,6 +40,7 @@ function createRequestContext(opts) {
 		requestCache: /* @__PURE__ */ new WeakMap(),
 		ssrContext: null,
 		ssrHeadChildren: [],
+		documentInitialHead: [],
 		rootParams: null,
 		...opts
 	};
@@ -79,5 +82,3 @@ function isInsideUnifiedScope() {
 }
 //#endregion
 export { createRequestContext, getRequestContext, isInsideUnifiedScope, runWithRequestContext, runWithUnifiedStateMutation };
-
-//# sourceMappingURL=unified-request-context.js.map

package/dist/shims/unrecognized-action-error.d.ts

@@ -31,5 +31,4 @@ declare class UnrecognizedActionError extends Error {
  */
 declare function unstable_isUnrecognizedActionError(error: unknown): error is UnrecognizedActionError;
 //#endregion
-export { UnrecognizedActionError, unstable_isUnrecognizedActionError };
-//# sourceMappingURL=unrecognized-action-error.d.ts.map
+export { UnrecognizedActionError, unstable_isUnrecognizedActionError };

package/dist/shims/unrecognized-action-error.js

@@ -37,5 +37,3 @@ function unstable_isUnrecognizedActionError(error) {
 }
 //#endregion
 export { UnrecognizedActionError, unstable_isUnrecognizedActionError };
-
-//# sourceMappingURL=unrecognized-action-error.js.map

package/dist/shims/url-safety.d.ts

@@ -31,5 +31,4 @@ declare function isDangerousScheme(url: string): boolean;
 declare function reportBlockedDangerousNavigation(): void;
 declare function assertSafeNavigationUrl(url: string): void;
 //#endregion
-export { DANGEROUS_URL_BLOCK_MESSAGE, assertSafeNavigationUrl, isDangerousScheme, reportBlockedDangerousNavigation };
-//# sourceMappingURL=url-safety.d.ts.map
+export { DANGEROUS_URL_BLOCK_MESSAGE, assertSafeNavigationUrl, isDangerousScheme, reportBlockedDangerousNavigation };

package/dist/shims/url-safety.js

@@ -68,5 +68,3 @@ function assertSafeNavigationUrl(url) {
 }
 //#endregion
 export { DANGEROUS_URL_BLOCK_MESSAGE, assertSafeNavigationUrl, isDangerousScheme, reportBlockedDangerousNavigation };
-
-//# sourceMappingURL=url-safety.js.map

package/dist/shims/url-utils.d.ts

@@ -48,5 +48,4 @@ declare function resolveRelativeHref(href: string, currentUrl?: string, basePath
 declare function toBrowserNavigationHref(href: string, currentUrl?: string, basePath?: string): string;
 declare function isHashOnlyBrowserUrlChange(href: string, currentHref: string, basePath?: string): boolean;
 //#endregion
-export { getWindowOrigin, isAbsoluteOrProtocolRelativeUrl, isAbsoluteUrl, isHashOnlyBrowserUrlChange, normalizePathTrailingSlash, resolveRelativeHref, toBrowserNavigationHref, toSameOriginAppPath, toSameOriginPath, withBasePath };
-//# sourceMappingURL=url-utils.d.ts.map
+export { getWindowOrigin, isAbsoluteOrProtocolRelativeUrl, isAbsoluteUrl, isHashOnlyBrowserUrlChange, normalizePathTrailingSlash, resolveRelativeHref, toBrowserNavigationHref, toSameOriginAppPath, toSameOriginPath, withBasePath };

package/dist/shims/url-utils.js

@@ -154,5 +154,3 @@ function isHashOnlyBrowserUrlChange(href, currentHref, basePath = "") {
 }
 //#endregion
 export { getWindowOrigin, isAbsoluteOrProtocolRelativeUrl, isAbsoluteUrl, isHashOnlyBrowserUrlChange, normalizePathTrailingSlash, resolveRelativeHref, toBrowserNavigationHref, toSameOriginAppPath, toSameOriginPath, withBasePath };
-
-//# sourceMappingURL=url-utils.js.map

package/dist/shims/use-merged-ref.d.ts

@@ -3,5 +3,4 @@ import { Ref } from "react";
 //#region src/shims/use-merged-ref.d.ts
 declare function useMergedRef<TElement>(refA: Ref<TElement>, refB: Ref<TElement>): Ref<TElement>;
 //#endregion
-export { useMergedRef };
-//# sourceMappingURL=use-merged-ref.d.ts.map
+export { useMergedRef };

package/dist/shims/use-merged-ref.js

@@ -36,5 +36,3 @@ function applyRef(refA, current) {
 }
 //#endregion
 export { useMergedRef };
-
-//# sourceMappingURL=use-merged-ref.js.map

package/dist/shims/web-vitals.d.ts

@@ -5,5 +5,4 @@ type WebVitalsMetric = MetricType;
 type ReportWebVitalsCallback = (metric: WebVitalsMetric) => void;
 declare function useReportWebVitals(callback: ReportWebVitalsCallback): void;
 //#endregion
-export { type ReportWebVitalsCallback, type WebVitalsMetric, useReportWebVitals };
-//# sourceMappingURL=web-vitals.d.ts.map
+export { type ReportWebVitalsCallback, type WebVitalsMetric, useReportWebVitals };

package/dist/shims/web-vitals.js

@@ -20,5 +20,3 @@ function useReportWebVitals(callback) {
 }
 //#endregion
 export { useReportWebVitals };
-
-//# sourceMappingURL=web-vitals.js.map

package/dist/typegen.d.ts

@@ -6,5 +6,4 @@ type GenerateRouteTypesOptions = {
 };
 declare function generateRouteTypes(options: GenerateRouteTypesOptions): Promise<string>;
 //#endregion
-export { generateRouteTypes };
-//# sourceMappingURL=typegen.d.ts.map
+export { generateRouteTypes };

package/dist/typegen.js

@@ -1,6 +1,6 @@
-import { decodeRouteSegment } from "./routing/utils.js";
+import { decodeRouteSegment, isInvisibleSegment } from "./routing/utils.js";
 import { patternToNextFormat } from "./routing/route-validation.js";
-import { isInvisibleSegment } from "./routing/app-route-graph.js";
+import { compareStrings } from "./utils/compare.js";
 import { appRouteGraph } from "./routing/app-router.js";
 import path from "node:path";
 import fs from "node:fs/promises";
@@ -231,12 +231,5 @@ function propertyName(name) {
 function quote(value) {
 	return JSON.stringify(value);
 }
-function compareStrings(left, right) {
-	if (left < right) return -1;
-	if (left > right) return 1;
-	return 0;
-}
 //#endregion
 export { generateRouteTypes };
-
-//# sourceMappingURL=typegen.js.map

package/dist/utils/asset-prefix.d.ts

@@ -93,5 +93,4 @@ declare function assetPrefixPathname(assetPrefix: string): string;
  */
 declare function isNextStaticPath(pathname: string, basePath: string, assetPathPrefix: string): boolean;
 //#endregion
-export { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix, isNextStaticPath, resolveAssetUrlPrefix, resolveAssetsDir };
-//# sourceMappingURL=asset-prefix.d.ts.map
+export { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix, isNextStaticPath, resolveAssetUrlPrefix, resolveAssetsDir };

package/dist/utils/asset-prefix.js

@@ -120,5 +120,3 @@ function isNextStaticPath(pathname, basePath, assetPathPrefix) {
 }
 //#endregion
 export { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix, isNextStaticPath, resolveAssetUrlPrefix, resolveAssetsDir };
-
-//# sourceMappingURL=asset-prefix.js.map

package/dist/utils/base-path.d.ts

@@ -28,5 +28,4 @@ declare function addBasePathToPathname(pathname: string, basePath: string | unde
  */
 declare function removeTrailingSlash(pathname: string): string;
 //#endregion
-export { addBasePathToPathname, hasBasePath, removeTrailingSlash, stripBasePath };
-//# sourceMappingURL=base-path.d.ts.map
+export { addBasePathToPathname, hasBasePath, removeTrailingSlash, stripBasePath };

package/dist/utils/base-path.js

@@ -43,5 +43,3 @@ function removeTrailingSlash(pathname) {
 }
 //#endregion
 export { addBasePathToPathname, hasBasePath, removeTrailingSlash, stripBasePath };
-
-//# sourceMappingURL=base-path.js.map

package/dist/utils/cache-control-metadata.d.ts

@@ -1,7 +1,4 @@
-import { isUnknownRecord } from "./record.js";
-
 //#region src/utils/cache-control-metadata.d.ts
 declare function readCacheControlNumberField(ctx: Record<string, unknown> | undefined, field: string): number | undefined;
 //#endregion
-export { isUnknownRecord, readCacheControlNumberField };
-//# sourceMappingURL=cache-control-metadata.d.ts.map
+export { readCacheControlNumberField };

package/dist/utils/cache-control-metadata.js

@@ -9,6 +9,4 @@ function readCacheControlNumberField(ctx, field) {
 	return typeof value === "number" ? value : void 0;
 }
 //#endregion
-export { isUnknownRecord, readCacheControlNumberField };
-
-//# sourceMappingURL=cache-control-metadata.js.map
+export { readCacheControlNumberField };

package/dist/utils/client-build-manifest.d.ts

@@ -0,0 +1,14 @@
+import { BuildManifestChunk } from "./lazy-chunks.js";
+
+//#region src/utils/client-build-manifest.d.ts
+type ClientBuildManifest = Record<string, BuildManifestChunk>;
+declare function readClientBuildManifest(manifestPath: string): ClientBuildManifest | undefined;
+declare function findClientEntryFileFromManifest(buildManifest: ClientBuildManifest, assetBase: string): string | undefined;
+declare function findClientEntryFile(options: {
+  buildManifest?: ClientBuildManifest;
+  clientDir: string;
+  assetsSubdir: string;
+  assetBase: string;
+}): string | undefined;
+//#endregion
+export { findClientEntryFile, findClientEntryFileFromManifest, readClientBuildManifest };