@timber-js/app 0.2.0-alpha.207 → 0.2.0-alpha.209

package/dist/client/internal.js

@@ -1,11 +1,10 @@
-import { t as SingleflightTimeoutError } from "../_chunks/singleflight-2lUWfcAk.js";
-import { a as SegmentCache, i as PrefetchCache, n as createNavigationCommitter, o as prefetchScopeOf, r as isPartialNavigation } from "../_chunks/status-page-marker-DwQBrLBz.js";
-import { i as useNavigationContext, n as getNavigationState, r as setNavigationState, t as NavigationProvider } from "../_chunks/navigation-context-D0TU0Jog.js";
-import { c as cachedSearchParams, s as cachedSearch, t as _setCachedSearch } from "../_chunks/state-FippDgxN.js";
-import { a as setGlobalRouter, i as getRouterOrNull, r as getRouter } from "../_chunks/navigation-root-mHSK9psY.js";
-import { n as getSsrData, r as setSsrData, t as clearSsrData } from "../_chunks/ssr-data-D6T6Y3ef.js";
-import { n as useSegmentContext, t as SegmentProvider } from "../_chunks/segment-context-D9_89u34.js";
-import { a as createSpaExits, c as NonRscResponse, d as readPublishedParams, i as createScrollEffects, l as fetchRscPayload, n as TimberErrorBoundary, o as recordSkew, r as createNavigationRecovery, s as isClientStale, u as readPayloadTree } from "../_chunks/error-boundary-BndF-3Td.js";
+import { t as SingleflightTimeoutError } from "../_chunks/singleflight-BeVMMKi0.js";
+import { a as routerUrlKey, c as prefetchScopeOf, i as parseRouterUrl, n as createNavigationCommitter, o as PrefetchCache, r as isPartialNavigation, s as SegmentCache } from "../_chunks/status-page-marker-gaihi0KZ.js";
+import { c as cachedSearchParams, s as cachedSearch, t as _setCachedSearch } from "../_chunks/state-BhNGPsdi.js";
+import { a as setGlobalRouter, i as getRouterOrNull, r as getRouter } from "../_chunks/navigation-root-BQfo1-kG.js";
+import { n as registerSsrDataProvider, t as getSsrData } from "../_chunks/ssr-data-nA3I70_n.js";
+import { i as useNavigationContext, n as useSegmentContext, r as NavigationProvider, t as SegmentProvider } from "../_chunks/segment-context-xtPUGfdq.js";
+import { a as createSpaExits, c as NonRscResponse, d as readPublishedParams, i as createScrollEffects, l as fetchRscPayload, n as TimberErrorBoundary, o as recordSkew, r as createNavigationRecovery, s as isClientStale, u as readPayloadTree } from "../_chunks/error-boundary-tA7kVfs4.js";
 import { t as bindUseQueryStates } from "../_chunks/use-query-states-I3JMng6J.js";
 //#region src/client/history.ts
 /**
@@ -15,7 +14,10 @@ import { t as bindUseQueryStates } from "../_chunks/use-query-states-I3JMng6J.js
 * On forward navigation, the new page's payload is pushed onto the stack.
 * On popstate, the cached payload is replayed instantly.
 *
-* Entries are keyed by pathname + search. Used with the History API
+* Entries are keyed by pathname + search in the browser's own spelling
+* (`routerUrlKey`), whatever spelling a caller passes: an entry stored by
+* `navigate('/café')` is found by a traversal that reads `/caf%C3%A9` off
+* the address bar, and `/a?` is `/a` (TIM-1541). Used with the History API
 * fallback and the Navigation API.
 *
 * Scroll positions are stored in history.state or Navigation API entry
@@ -32,6 +34,7 @@ var HistoryStack = class {
 		this.maxEntries = maxEntries;
 	}
 	push(url, entry) {
+		url = routerUrlKey(url);
 		this.entries.delete(url);
 		this.entries.set(url, entry);
 		if (this.entries.size > this.maxEntries) {
@@ -40,6 +43,7 @@ var HistoryStack = class {
 		}
 	}
 	get(url) {
+		url = routerUrlKey(url);
 		const entry = this.entries.get(url);
 		if (entry) {
 			this.entries.delete(url);
@@ -49,31 +53,37 @@ var HistoryStack = class {
 	}
 	/** Presence checks (such as hover prefetch probes) do not promote entries. */
 	has(url) {
-		return this.entries.has(url);
+		return this.entries.has(routerUrlKey(url));
 	}
 	delete(url) {
-		return this.entries.delete(url);
+		return this.entries.delete(routerUrlKey(url));
 	}
 	/**
-	* Evict all cached payloads (TIM-1476). Called after a server action
-	* that revalidated data — history entries are equally stale since they
-	* replay on back/forward without a server check. Clearing forces a
-	* fresh fetch on the next traversal.
+	* Delete all entries whose pathname matches `pathname` (TIM-1465).
+	* Used by `invalidatePath` when the invalidation target has no search
+	* string — `/products` should evict `/products?page=1` too, because
+	* `revalidatePath('/products')` invalidates the route regardless of
+	* query.
+	*/
+	deleteByPathname(pathname) {
+		pathname = routerUrlKey(pathname);
+		for (const url of this.entries.keys()) {
+			const qIndex = url.indexOf("?");
+			if ((qIndex === -1 ? url : url.slice(0, qIndex)) === pathname) this.entries.delete(url);
+		}
+	}
+	/**
+	* Evict every entry (TIM-1476). Called after a server action that
+	* revalidated data — history entries are equally stale since they replay
+	* on back/forward without a server check. Clearing forces a fresh fetch on
+	* the next traversal.
 	*
-	* The current URL's `segmentInfo` is preserved (payload nulled) so
-	* `applyActionResult` can read it to maintain the segment cache
-	* across the piggybacked revalidation. Other branches (reval.paths-
-	* only, redirect) do not call `applyActionResult`, so their entries
-	* are fully removed (codex on #1131 round 2).
+	* The current page's entry goes too. Nothing reads it for anything but a
+	* replay: the segment metadata a revalidation needs is the committer's
+	* record of the current page, not this stack's (TIM-1541).
 	*/
-	clearExcept(currentUrl) {
-		const currentEntry = this.entries.get(currentUrl);
+	clear() {
 		this.entries.clear();
-		if (currentEntry) this.entries.set(currentUrl, {
-			payload: null,
-			params: currentEntry.params,
-			segmentInfo: currentEntry.segmentInfo
-		});
 	}
 };
 //#endregion
@@ -324,7 +334,7 @@ function raceAbort(promise, signal) {
 * both `location.href` and a bare pathname.
 */
 function departingPathname(raw) {
-	return new URL(raw, "http://localhost").pathname;
+	return parseRouterUrl(raw).pathname;
 }
 /**
 * The prefetch cache key for a destination.
@@ -352,13 +362,13 @@ function prefetchKeyFor(url, departingUrl, stateTree) {
 * Build a segment updates map for partial navigation. Identifies the
 * first non-skipped segment and maps it to the payload content.
 */
-function buildSegmentUpdates(result) {
+function buildSegmentUpdates(result, payload) {
 	const skipped = new Set(result.skippedSegments);
 	const segmentInfo = result.segmentInfo;
 	const updates = /* @__PURE__ */ new Map();
 	if (segmentInfo) {
 		for (const info of segmentInfo) if (!skipped.has(info.segmentId ?? info.path)) {
-			updates.set(info.segmentId ?? info.path, result.payload);
+			updates.set(info.segmentId ?? info.path, payload);
 			break;
 		}
 	}
@@ -378,35 +388,15 @@ function observeSkew(decodePromise) {
 	decodePromise?.catch((error) => void recordSkew(error));
 	return decodePromise;
 }
-function createNavigationPipeline({ deps, prefetchCache, currentStateTree, prepareNavigation, markHandedOff, forgetOlderHandoffs }) {
-	/**
-	* Render a decoded RSC payload into the DOM, publishing `commit` when the
-	* tree is current. The renderer owns that moment (see `RootRenderer`);
-	* with no renderer there is no tree to wait for, so it publishes now.
-	*/
-	function renderPayload(payload, navState, params, commit) {
-		if (deps.renderRoot) deps.renderRoot(payload, navState, params, commit);
-		else commit();
-	}
+function createNavigationPipeline({ deps, prefetchCache, currentStateTree, prepareNavigation, isSegmentReuseSuppressed, restoreSegmentReuse, markHandedOff, forgetOlderHandoffs }) {
 	/**
-	* Resolve thenable payloads in the test/fallback path (no navigateTransition).
-	* In production, React handles thenables from createFromFetch directly via
-	* Suspense. In tests, renderRoot is a plain mock that expects resolved values.
-	*/
-	async function resolveForFallback(payload) {
-		if (!deps.navigateTransition && payload != null && typeof payload === "object" && "then" in payload) return await payload;
-		return payload;
-	}
-	/**
-	* Render a payload via navigateTransition (production) or renderRoot (tests).
-	* The perform callback should fetch data, prepare the commit, and return the
+	* Hand a payload to React via navigateTransition. The perform callback should fetch data, prepare the commit, and return the
 	* FetchResult plus the NavigationState and the commit thunk.
 	*
 	* The thunk is handed *through* to NavigationRoot rather than called here:
-	* state management (segmentCache, navState, historyStack) has to happen on
+	* state management (segment cache, history stack, address bar) has to happen on
 	* the far side of the supersession check, which only NavigationRoot can
-	* make (TIM-1301). The fallback path below has no transition to be
-	* superseded by, so it commits directly.
+	* make (TIM-1301).
 	*/
 	async function renderViaTransition(url, owner, perform, onCommit) {
 		const handOff = () => markHandedOff(owner);
@@ -414,50 +404,36 @@ function createNavigationPipeline({ deps, prefetchCache, currentStateTree, prepa
 			forgetOlderHandoffs(owner);
 			commit();
 		};
-		if (deps.navigateTransition) {
-			await deps.navigateTransition(url, owner, async (wrapPayload) => {
-				const result = await perform();
-				const params = await result.params;
-				if (isPartialNavigation(result.skippedSegments)) {
-					const segmentUpdates = buildSegmentUpdates(result);
-					const element = wrapPayload(deps._getCurrentPayload?.() ?? result.payload, result.navState, params, segmentUpdates);
-					handOff();
-					return {
-						element,
-						decodePromise: observeSkew(result.decodePromise),
-						commit: commitAndForget(result.commit)
-					};
-				}
-				const element = wrapPayload(result.payload, result.navState, params);
+		await deps.navigateTransition(url, owner, async (wrapPayload) => {
+			const result = await perform();
+			const params = await result.params;
+			const payload = await result.payload;
+			if (isPartialNavigation(result.skippedSegments)) {
+				const segmentUpdates = buildSegmentUpdates(result, payload);
+				const element = wrapPayload(deps._getCurrentPayload?.() ?? payload, result.navState, params, segmentUpdates);
 				handOff();
 				return {
 					element,
 					decodePromise: observeSkew(result.decodePromise),
 					commit: commitAndForget(result.commit)
 				};
-			}, onCommit);
-			return;
-		}
-		let fallbackOutcome = "committed";
-		try {
-			const result = await perform();
+			}
+			const element = wrapPayload(payload, result.navState, params);
 			handOff();
-			const commit = commitAndForget(result.commit);
-			if (isPartialNavigation(result.skippedSegments)) commit();
-			else renderPayload(result.payload, result.navState, await result.params, commit);
-		} catch (error) {
-			fallbackOutcome = "failed";
-			throw error;
-		} finally {
-			onCommit?.(fallbackOutcome);
-		}
+			return {
+				element,
+				decodePromise: observeSkew(result.decodePromise),
+				commit: commitAndForget(result.commit)
+			};
+		}, onCommit);
 	}
 	/**
-	* Core navigation logic shared between the transition and fallback paths.
-	* Fetches the RSC payload, updates all state, and returns the result.
+	* Fetch (or take from the prefetch cache) a navigation's payload and
+	* prepare — without publishing — the commit that makes it current.
 	*/
 	async function performNavigationFetch(url, options) {
 		const stateTree = currentStateTree();
+		let reuseSuppressedAtFetch = isSegmentReuseSuppressed();
 		const cacheKey = prefetchKeyFor(url, options.departingUrl ?? deps.getCurrentUrl(), stateTree);
 		const currentUrl = cacheKey.from;
 		if (prefetchCache.isNegative(cacheKey)) {
@@ -478,7 +454,7 @@ function createNavigationPipeline({ deps, prefetchCache, currentStateTree, prepa
 				const genBefore = prefetchCache.getEvictionGen();
 				try {
 					const outcome = await raceAbort(inflight, options.signal);
-					if (prefetchCache.getEvictionGen() !== genBefore) {} else if (outcome.kind === "non-route") throw new NonRscResponse(url);
+					if (prefetchCache.getEvictionGen() !== genBefore || outcome.startGen !== genBefore) {} else if (outcome.kind === "non-route") throw new NonRscResponse(url);
 					else {
 						prefetchCache.consume(cacheKey);
 						result = {
@@ -496,7 +472,11 @@ function createNavigationPipeline({ deps, prefetchCache, currentStateTree, prepa
 				}
 			}
 		}
-		if (result === void 0) result = await fetchRscPayload(url, deps, stateTree, currentUrl, options.signal);
+		if (result === void 0) {
+			reuseSuppressedAtFetch = isSegmentReuseSuppressed();
+			const freshStateTree = currentStateTree();
+			result = await fetchRscPayload(url, deps, freshStateTree, currentUrl, options.signal);
+		}
 		const commitHistoryUrl = () => {
 			if (options.skipHistory) return;
 			const commitUrl = options.commitUrl ?? url;
@@ -511,17 +491,16 @@ function createNavigationPipeline({ deps, prefetchCache, currentStateTree, prepa
 			}, "", commitUrl);
 			deps.setRouterNavigating?.(false);
 		};
-		const payload = await resolveForFallback(result.payload);
 		const params = await result.params;
 		const { navState, commit } = prepareNavigation(url, {
-			payload,
+			payload: result.payload,
 			params,
 			segmentInfo: result.segmentInfo,
 			skippedSegments: result.skippedSegments
 		});
+		if (reuseSuppressedAtFetch) restoreSegmentReuse();
 		return {
 			...result,
-			payload,
 			params,
 			navState,
 			commit: () => {
@@ -533,9 +512,7 @@ function createNavigationPipeline({ deps, prefetchCache, currentStateTree, prepa
 	}
 	return {
 		performNavigationFetch,
-		renderViaTransition,
-		renderPayload,
-		resolveForFallback
+		renderViaTransition
 	};
 }
 //#endregion
@@ -548,18 +525,20 @@ function createRouter(deps) {
 	const segmentCache = new SegmentCache();
 	const prefetchCache = new PrefetchCache();
 	const historyStack = new HistoryStack();
-	const { prepareNavigation, currentStateTree, updateSegmentCache } = createNavigationCommitter({
+	const { prepareNavigation, currentStateTree, committedSegmentInfo, isSegmentReuseSuppressed, restoreSegmentReuse } = createNavigationCommitter({
 		segmentCache,
 		historyStack,
 		clientSegmentCache: () => deps.clientSegmentCache
 	});
 	const lifecycle = createNavigationLifecycle(deps);
 	const { currentOwner, createNavOwner, runNavigation, markHandedOff, forgetOlderHandoffs, isPending, getPendingUrl, onPendingChange } = lifecycle;
-	const { performNavigationFetch, renderViaTransition, resolveForFallback } = createNavigationPipeline({
+	const { performNavigationFetch, renderViaTransition } = createNavigationPipeline({
 		deps,
 		prefetchCache,
 		currentStateTree,
 		prepareNavigation,
+		isSegmentReuseSuppressed,
+		restoreSegmentReuse,
 		markHandedOff,
 		forgetOlderHandoffs
 	});
@@ -627,17 +606,15 @@ function createRouter(deps) {
 			try {
 				await renderViaTransition(url, owner, async () => {
 					const result = await fetchRscPayload(url, deps, opts.stateTree, void 0, owner.fetchAbort.signal);
-					const payload = await resolveForFallback(result.payload);
 					const params = await result.params;
 					const { navState, commit } = prepareNavigation(url, {
-						payload,
+						payload: result.payload,
 						params,
 						segmentInfo: result.segmentInfo,
 						skippedSegments: result.skippedSegments
 					});
 					return {
 						...result,
-						payload,
 						params,
 						navState,
 						commit
@@ -714,6 +691,7 @@ function createRouter(deps) {
 		onPendingChange,
 		prefetch,
 		epoch: () => lifecycle.epoch(),
+		isEpochCurrent: (epoch) => lifecycle.isEpochCurrent(epoch),
 		async applyActionResult(epoch, tree) {
 			if (!lifecycle.isEpochCurrent(epoch)) return false;
 			if (tree === void 0) {
@@ -725,7 +703,7 @@ function createRouter(deps) {
 			const currentUrl = deps.getCurrentUrl();
 			const payloadTree = readPayloadTree(tree);
 			const params = readPublishedParams(tree);
-			const existingEntry = historyStack.get(currentUrl);
+			const segmentInfo = committedSegmentInfo();
 			let outcomeResolve;
 			const outcomePromise = new Promise((r) => outcomeResolve = r);
 			const owner = createRenderOwner("revalidation");
@@ -734,7 +712,7 @@ function createRouter(deps) {
 				const { navState, commit } = prepareNavigation(currentUrl, {
 					payload: payloadTree,
 					params,
-					segmentInfo: existingEntry?.segmentInfo
+					segmentInfo
 				});
 				return {
 					payload: payloadTree,
@@ -742,7 +720,7 @@ function createRouter(deps) {
 					navState,
 					commit,
 					decodePromise: null,
-					segmentInfo: existingEntry?.segmentInfo ?? null,
+					segmentInfo,
 					skippedSegments: null
 				};
 			}, outcomeResolve).catch(() => {}), outcomePromise]);
@@ -751,17 +729,26 @@ function createRouter(deps) {
 		runWhenIdle: (task) => lifecycle.runWhenIdle(task),
 		settleHandoffs: () => lifecycle.settleHandoffs(),
 		invalidatePath(path) {
-			historyStack.delete(path);
+			if (path.includes("?")) historyStack.delete(path);
+			else historyStack.deleteByPathname(path);
 			prefetchCache.invalidateUrl(path);
+			segmentCache.invalidateReuse();
 		},
 		evictStaleCaches() {
 			prefetchCache.clearReady();
-			historyStack.clearExcept(deps.getCurrentUrl());
+			historyStack.clear();
+		},
+		hydrate(page) {
+			const { navState, commit } = prepareNavigation(deps.getCurrentUrl(), {
+				payload: page.payload,
+				params: page.params,
+				segmentInfo: page.segmentInfo
+			});
+			commit();
+			return navState;
 		},
-		initSegmentCache: (segments) => updateSegmentCache(segments),
 		segmentCache,
-		prefetchCache,
-		historyStack
+		prefetchCache
 	};
 }
 //#endregion
@@ -813,6 +800,6 @@ function useSearchParams() {
 	return getSearchParams(nav.search);
 }
 //#endregion
-export { HistoryStack, NavigationProvider, PrefetchCache, SegmentCache, SegmentProvider, TimberErrorBoundary, bindUseQueryStates, clearSsrData, createRouter, getNavigationState, getRouter, getRouterOrNull, getSsrData, setGlobalRouter, setNavigationState, setSsrData, useSearchParams, useSegmentContext };
+export { HistoryStack, NavigationProvider, PrefetchCache, SegmentCache, SegmentProvider, TimberErrorBoundary, bindUseQueryStates, createRouter, getRouter, getRouterOrNull, getSsrData, registerSsrDataProvider, setGlobalRouter, useSearchParams, useSegmentContext };
 
 //# sourceMappingURL=internal.js.map