@timber-js/app 0.2.0-alpha.196 → 0.2.0-alpha.198

package/dist/_chunks/slot-params-BCTmZkQB.js

@@ -1,76 +0,0 @@
-//#region src/shared/slot-params.ts
-/**
-* The params a slot sees: the main route's as a base, the slot's own on top.
-*
-* Params from segments *above* the slot are not re-derived by the slot's own
-* chain, so they have to come from the main route; params the slot does
-* re-derive may have a different type than the main route gave them, so the
-* slot's win.
-*
-* Null-prototype, like every other param record the framework hands out
-* (`coerceSegmentParams` installs one unconditionally). A spread literal would
-* inherit `Object.prototype`, so a lookup for a param the route does not
-* define would resolve to an inherited member — `params.constructor` returning
-* a function instead of `undefined` — in the one param record that was built
-* by merging. See design/13-security.md #36c.
-*/
-function mergeSlotParams(mainParams, slotParams) {
-	return Object.assign(Object.create(null), mainParams, slotParams);
-}
-/**
-* Resolve the params for a segment path against a published slot map.
-*
-* Returns the merge when `segmentPath` names a slot that published params,
-* and the main route's record otherwise — an ordinary (non-slot) segment
-* path, an unknown path, or a request with no slots at all. Mirrors the
-* server's `getSegmentParams(segmentPath)` branch exactly.
-*
-* `Object.hasOwn` rather than `in` or a truthiness test: the map arrives from
-* JSON, so a segment path of `constructor` or `toString` would otherwise
-* resolve to an inherited member of `Object.prototype`.
-*/
-function resolveSegmentParams(mainParams, slotParams, segmentPath) {
-	if (!segmentPath || !slotParams || !Object.hasOwn(slotParams, segmentPath)) return mainParams;
-	return cachedMerge(mainParams, slotParams, segmentPath);
-}
-/**
-* The merged record for one (main record, slot map, path) triple, reused until
-* one of the three changes.
-*
-* `useSegmentParams(slotPath)` calls this on every render. Returning a fresh
-* object each time makes the hook's result change by reference on renders where
-* nothing navigated, so a component using it as a `useEffect` dependency
-* re-runs the effect — and re-renders in a loop if that effect sets state —
-* while memoized children below it lose their memoization.
-*
-* Keyed on the *identities* of the two records, not their contents: both are
-* replaced rather than mutated on every navigation (`setCurrentParams`,
-* `setCurrentSlotParams`, and the server's per-request store), so identity is
-* the correct equality here and a deep comparison would be slower and no more
-* accurate.
-*
-* A `WeakMap` chain rather than a `Map`, so a superseded navigation's records
-* and their merges become collectable as soon as nothing else holds them.
-*/
-var mergeCache = /* @__PURE__ */ new WeakMap();
-function cachedMerge(mainParams, slotParams, segmentPath) {
-	let bySlotMap = mergeCache.get(mainParams);
-	if (!bySlotMap) {
-		bySlotMap = /* @__PURE__ */ new WeakMap();
-		mergeCache.set(mainParams, bySlotMap);
-	}
-	let byPath = bySlotMap.get(slotParams);
-	if (!byPath) {
-		byPath = /* @__PURE__ */ new Map();
-		bySlotMap.set(slotParams, byPath);
-	}
-	const cached = byPath.get(segmentPath);
-	if (cached) return cached;
-	const merged = mergeSlotParams(mainParams, slotParams[segmentPath]);
-	byPath.set(segmentPath, merged);
-	return merged;
-}
-//#endregion
-export { resolveSegmentParams as t };
-
-//# sourceMappingURL=slot-params-BCTmZkQB.js.map

package/dist/_chunks/slot-params-BCTmZkQB.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"slot-params-BCTmZkQB.js","names":[],"sources":["../../src/shared/slot-params.ts"],"sourcesContent":["/**\n * Per-slot segment params — the one definition both halves of the API read.\n *\n * A parallel slot matches the URL through its *own* sub-tree, so it can derive\n * a param the main route never had, or derive the same name with a different\n * type (`[...year]` → `string[]` where the main route's `[year]` gave\n * `string`). The server answers `getSegmentParams(slotPath)` from a per-slot\n * map; the client answers `useSegmentParams(slotPath)` from the same map,\n * published on the RSC payload (TIM-1285).\n *\n * The merge lives here rather than in either half because the two must agree\n * about what \"the slot's params\" are — a divergence is invisible until\n * somebody reads a param of the wrong type, which is exactly the class of bug\n * this module closes.\n *\n * Isomorphic: no server or client imports.\n *\n * See design/41-global-params.md §\"Params in a parallel slot\".\n */\n\nimport type { CoercedParams } from './param-value.ts';\n\n/** Slot tree path → that slot's own coerced params. */\nexport type SlotParamsRecord = Record<string, CoercedParams>;\n\n/**\n * The params a slot sees: the main route's as a base, the slot's own on top.\n *\n * Params from segments *above* the slot are not re-derived by the slot's own\n * chain, so they have to come from the main route; params the slot does\n * re-derive may have a different type than the main route gave them, so the\n * slot's win.\n *\n * Null-prototype, like every other param record the framework hands out\n * (`coerceSegmentParams` installs one unconditionally). A spread literal would\n * inherit `Object.prototype`, so a lookup for a param the route does not\n * define would resolve to an inherited member — `params.constructor` returning\n * a function instead of `undefined` — in the one param record that was built\n * by merging. See design/13-security.md #36c.\n */\nexport function mergeSlotParams(\n  mainParams: CoercedParams,\n  slotParams: CoercedParams\n): CoercedParams {\n  return Object.assign(Object.create(null), mainParams, slotParams);\n}\n\n/**\n * Resolve the params for a segment path against a published slot map.\n *\n * Returns the merge when `segmentPath` names a slot that published params,\n * and the main route's record otherwise — an ordinary (non-slot) segment\n * path, an unknown path, or a request with no slots at all. Mirrors the\n * server's `getSegmentParams(segmentPath)` branch exactly.\n *\n * `Object.hasOwn` rather than `in` or a truthiness test: the map arrives from\n * JSON, so a segment path of `constructor` or `toString` would otherwise\n * resolve to an inherited member of `Object.prototype`.\n */\nexport function resolveSegmentParams(\n  mainParams: CoercedParams,\n  slotParams: SlotParamsRecord | null | undefined,\n  segmentPath: string | undefined\n): CoercedParams {\n  if (!segmentPath || !slotParams || !Object.hasOwn(slotParams, segmentPath)) return mainParams;\n  return cachedMerge(mainParams, slotParams, segmentPath);\n}\n\n/**\n * The merged record for one (main record, slot map, path) triple, reused until\n * one of the three changes.\n *\n * `useSegmentParams(slotPath)` calls this on every render. Returning a fresh\n * object each time makes the hook's result change by reference on renders where\n * nothing navigated, so a component using it as a `useEffect` dependency\n * re-runs the effect — and re-renders in a loop if that effect sets state —\n * while memoized children below it lose their memoization.\n *\n * Keyed on the *identities* of the two records, not their contents: both are\n * replaced rather than mutated on every navigation (`setCurrentParams`,\n * `setCurrentSlotParams`, and the server's per-request store), so identity is\n * the correct equality here and a deep comparison would be slower and no more\n * accurate.\n *\n * A `WeakMap` chain rather than a `Map`, so a superseded navigation's records\n * and their merges become collectable as soon as nothing else holds them.\n */\nconst mergeCache = new WeakMap<object, WeakMap<object, Map<string, CoercedParams>>>();\n\nfunction cachedMerge(\n  mainParams: CoercedParams,\n  slotParams: SlotParamsRecord,\n  segmentPath: string\n): CoercedParams {\n  let bySlotMap = mergeCache.get(mainParams);\n  if (!bySlotMap) {\n    bySlotMap = new WeakMap();\n    mergeCache.set(mainParams, bySlotMap);\n  }\n  let byPath = bySlotMap.get(slotParams);\n  if (!byPath) {\n    byPath = new Map();\n    bySlotMap.set(slotParams, byPath);\n  }\n  const cached = byPath.get(segmentPath);\n  if (cached) return cached;\n  const merged = mergeSlotParams(mainParams, slotParams[segmentPath]);\n  byPath.set(segmentPath, merged);\n  return merged;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAwCA,SAAgB,gBACd,YACA,YACe;CACf,OAAO,OAAO,OAAO,OAAO,OAAO,IAAI,GAAG,YAAY,UAAU;AAClE;;;;;;;;;;;;;AAcA,SAAgB,qBACd,YACA,YACA,aACe;CACf,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,OAAO,OAAO,YAAY,WAAW,GAAG,OAAO;CACnF,OAAO,YAAY,YAAY,YAAY,WAAW;AACxD;;;;;;;;;;;;;;;;;;;;AAqBA,IAAM,6BAAa,IAAI,QAA6D;AAEpF,SAAS,YACP,YACA,YACA,aACe;CACf,IAAI,YAAY,WAAW,IAAI,UAAU;CACzC,IAAI,CAAC,WAAW;EACd,4BAAY,IAAI,QAAQ;EACxB,WAAW,IAAI,YAAY,SAAS;CACtC;CACA,IAAI,SAAS,UAAU,IAAI,UAAU;CACrC,IAAI,CAAC,QAAQ;EACX,yBAAS,IAAI,IAAI;EACjB,UAAU,IAAI,YAAY,MAAM;CAClC;CACA,MAAM,SAAS,OAAO,IAAI,WAAW;CACrC,IAAI,QAAQ,OAAO;CACnB,MAAM,SAAS,gBAAgB,YAAY,WAAW,YAAY;CAClE,OAAO,IAAI,aAAa,MAAM;CAC9B,OAAO;AACT"}

package/dist/_chunks/ssr-data-Ya2HJPFp.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ssr-data-Ya2HJPFp.js","names":[],"sources":["../../src/client/state.ts","../../src/client/ssr-data.ts"],"sourcesContent":["/**\n * Centralized client singleton state registry.\n *\n * ALL mutable module-level state that must have singleton semantics across\n * the client bundle lives here. Individual modules (router-ref.ts, ssr-data.ts,\n * use-segment-params.ts, use-search-params.ts, unload-guard.ts) import from this file\n * and re-export thin wrapper functions.\n *\n * Why: In Vite dev, a module is instantiated separately if reached via different\n * import paths (e.g., relative `./foo.js` vs barrel `@timber-js/app/client`).\n * By centralizing all mutable state in a single module that is always reached\n * through the same dependency chain (barrel → wrapper → state.ts), we guarantee\n * a single instance of every piece of shared state.\n *\n * DO NOT import this file from outside client/. Server code must never depend\n * on client state. The barrel (client/index.ts) is the public entry point.\n *\n * See design/18-build-system.md §\"Module Singleton Strategy\" and\n * §\"Singleton State Registry\".\n */\n\nimport type { CoercedParams } from '../shared/param-value.ts';\nimport type { SlotParamsRecord } from '../shared/slot-params.ts';\nimport type { RouterInstance } from './router-types.ts';\nimport type { SsrData } from './ssr-data.ts';\n\n// ─── Router (from router-ref.ts) ──────────────────────────────────────────\n\n/** The global router singleton — set once during bootstrap. */\nexport let globalRouter: RouterInstance | null = null;\n\nexport function _setGlobalRouter(router: RouterInstance | null): void {\n  globalRouter = router;\n}\n\n// ─── SSR Data Provider (from ssr-data.ts) ──────────────────────────────────\n\n/**\n * ALS-backed SSR data provider. When registered, getSsrData() reads from\n * this function (ALS store) instead of module-level currentSsrData.\n */\nexport let ssrDataProvider: (() => SsrData | undefined) | undefined;\n\nexport function _setSsrDataProvider(provider: (() => SsrData | undefined) | undefined): void {\n  ssrDataProvider = provider;\n}\n\n/** Fallback SSR data for tests and environments without ALS. */\nexport let currentSsrData: SsrData | undefined;\n\nexport function _setCurrentSsrData(data: SsrData | undefined): void {\n  currentSsrData = data;\n}\n\n// ─── Route Params (from use-segment-params.ts) ──────────────────────────────────────\n\n/** Current route params snapshot — replaced (not mutated) on each navigation. */\nexport let currentParams: CoercedParams = {};\n\nexport function _setCurrentParams(params: CoercedParams): void {\n  currentParams = params;\n}\n\n/**\n * Per-slot params snapshot, keyed by slot tree path — the module-level\n * fallback behind `useSegmentParams(slotPath)` when no NavigationContext is\n * mounted (tests, calls outside a component). Replaced, never mutated, on\n * each navigation. See TIM-1285.\n */\nexport let currentSlotParams: SlotParamsRecord | null = null;\n\nexport function _setCurrentSlotParams(slotParams: SlotParamsRecord | null): void {\n  currentSlotParams = slotParams;\n}\n\n/** Listeners notified when currentParams changes. */\nexport const paramsListeners = new Set<() => void>();\n\n// ─── Search Params Cache (from use-search-params.ts) ────────────────────────\n\n/** Cached search string — avoids reparsing when URL hasn't changed. */\nexport let cachedSearch = '';\nexport let cachedSearchParams = new URLSearchParams();\n\nexport function _setCachedSearch(search: string, params: URLSearchParams): void {\n  cachedSearch = search;\n  cachedSearchParams = params;\n}\n\n// ─── Unload Guard (from unload-guard.ts) ─────────────────────────────────────\n\n/** Whether the page is currently being unloaded. */\nexport let unloading = false;\n\nexport function _setUnloading(value: boolean): void {\n  unloading = value;\n}\n","/**\n * SSR Data — per-request state for client hooks during server-side rendering.\n *\n * RSC and SSR are separate Vite module graphs (see design/18-build-system.md),\n * so the RSC environment's request-context ALS is not visible to SSR modules.\n * This module provides getter/setter functions that ssr-entry.ts uses to\n * populate per-request data for React's render.\n *\n * Request isolation: On the server, ssr-entry.ts registers an ALS-backed\n * provider via registerSsrDataProvider(). getSsrData() reads from the ALS\n * store, ensuring correct per-request data even when Suspense boundaries\n * resolve asynchronously across concurrent requests. The module-level\n * setSsrData/clearSsrData functions are kept as a fallback for tests\n * and environments without ALS.\n *\n * IMPORTANT: This module must NOT import node:async_hooks or any Node.js-only\n * APIs, as it's imported by 'use client' hooks that are bundled for the browser.\n * The ALS instance lives in ssr-entry.ts (server-only); this module only holds\n * a reference to the provider function.\n *\n * All mutable state is delegated to client/state.ts for singleton guarantees.\n * See design/18-build-system.md §\"Singleton State Registry\"\n */\n\nimport {\n  ssrDataProvider,\n  currentSsrData,\n  _setSsrDataProvider,\n  _setCurrentSsrData,\n} from './state.ts';\nimport type { CoercedParams } from '../shared/param-value.ts';\nimport type { SlotParamsRecord } from '../shared/slot-params.ts';\n\n// ─── Types ────────────────────────────────────────────────────────\n\nexport interface SsrData {\n  /** The request's URL pathname (e.g. '/dashboard/settings') */\n  pathname: string;\n  /** The request's search params as a plain record */\n  searchParams: Record<string, string>;\n  /** The request's cookies as name→value pairs */\n  cookies: Map<string, string>;\n  /** The request's route params (e.g. { id: '123' }) */\n  params: CoercedParams;\n  /**\n   * Per-slot params keyed by slot tree path, absent when the request rendered\n   * no slot with params of its own (TIM-1285).\n   */\n  slotParams?: SlotParamsRecord;\n  /**\n   * Mutable reference to NavContext for error boundary → pipeline communication.\n   *\n   * When TimberErrorBoundary catches a DenySignal during SSR, it:\n   * 1. Sets `statusCode` to the deny status (e.g., 403) — so the HTTP\n   *    Response has the correct status code without a re-render.\n   * 2. Sets `_denyHandledByBoundary = true` — so the pipeline skips\n   *    the redundant renderDenyPage() re-render.\n   *\n   * This runs synchronously during Fizz rendering, BEFORE onShellReady,\n   * so the status code is committed before any bytes are sent.\n   *\n   * See TIM-664, design/04-authorization.md §\"React.cache Scope in Deny/Error Re-renders\"\n   */\n  _navContext?: { statusCode?: number; _denyHandledByBoundary?: boolean };\n}\n\n// ─── ALS-Backed Provider ─────────────────────────────────────────\n//\n// Server-side code (ssr-entry.ts) registers a provider that reads\n// from AsyncLocalStorage. This avoids importing node:async_hooks\n// in this browser-bundled module.\n//\n// Module singleton guarantee: In Vite's SSR environment, both\n// ssr-entry.ts (via #/client/ssr-data.js) and client component hooks\n// (via @timber-js/app/client) must resolve to the SAME module instance\n// of this file. The timber-shims plugin ensures this by remapping\n// @timber-js/app/client → src/client/index.ts in the SSR environment.\n// Without this remap, @timber-js/app/client resolves to dist/ (via\n// package.json exports), creating a split where registerSsrDataProvider\n// writes to one instance but getSsrData reads from another.\n// See timber-shims plugin resolveId for details.\n\n/**\n * Register an ALS-backed SSR data provider. Called once at module load\n * by ssr-entry.ts to wire up per-request data via AsyncLocalStorage.\n *\n * When registered, getSsrData() reads from the provider (ALS store)\n * instead of module-level state, ensuring correct isolation for\n * concurrent requests with streaming Suspense.\n */\nexport function registerSsrDataProvider(provider: () => SsrData | undefined): void {\n  _setSsrDataProvider(provider);\n}\n\n// ─── Module-Level Fallback ────────────────────────────────────────\n//\n// Used by tests and as a fallback when no ALS provider is registered.\n\n/**\n * Set the SSR data for the current request via module-level state.\n *\n * In production, ssr-entry.ts uses ALS (runWithSsrData) instead.\n * This function is retained for tests and as a fallback.\n */\nexport function setSsrData(data: SsrData): void {\n  _setCurrentSsrData(data);\n}\n\n/**\n * Clear the SSR data after rendering completes.\n *\n * In production, ALS scope handles cleanup automatically.\n * This function is retained for tests and as a fallback.\n */\nexport function clearSsrData(): void {\n  _setCurrentSsrData(undefined);\n}\n\n/**\n * Read the current request's SSR data. Returns undefined when called\n * outside an SSR render (i.e. on the client after hydration).\n *\n * Prefers the ALS-backed provider when registered (server-side),\n * falling back to module-level state (tests, legacy).\n *\n * Used by client hooks' server snapshot functions.\n */\nexport function getSsrData(): SsrData | undefined {\n  if (ssrDataProvider) {\n    return ssrDataProvider();\n  }\n  return currentSsrData;\n}\n"],"mappings":";;AA6BA,IAAW,eAAsC;AAEjD,SAAgB,iBAAiB,QAAqC;CACpE,eAAe;AACjB;;AAeA,IAAW;AAEX,SAAgB,mBAAmB,MAAiC;CAClE,iBAAiB;AACnB;;AAKA,IAAW,gBAA+B,CAAC;AAE3C,SAAgB,kBAAkB,QAA6B;CAC7D,gBAAgB;AAClB;;;;;;;AAQA,IAAW,oBAA6C;AAExD,SAAgB,sBAAsB,YAA2C;CAC/E,oBAAoB;AACtB;;AAQA,IAAW,eAAe;AAC1B,IAAW,qBAAqB,IAAI,gBAAgB;AAEpD,SAAgB,iBAAiB,QAAgB,QAA+B;CAC9E,eAAe;CACf,qBAAqB;AACvB;;AAKA,IAAW,YAAY;AAEvB,SAAgB,cAAc,OAAsB;CAClD,YAAY;AACd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACQA,SAAgB,WAAW,MAAqB;CAC9C,mBAAmB,IAAI;AACzB;;;;;;;AAQA,SAAgB,eAAqB;CACnC,mBAAmB,KAAA,CAAS;AAC9B;;;;;;;;;;AAWA,SAAgB,aAAkC;CAIhD,OAAO;AACT"}

package/dist/_chunks/use-segment-params-DzTBpkvj.js

@@ -1,398 +0,0 @@
-import { t as resolveSegmentParams } from "./slot-params-BCTmZkQB.js";
-import { a as _setCurrentParams, d as currentParams, f as currentSlotParams, n as getSsrData, o as _setCurrentSlotParams } from "./ssr-data-Ya2HJPFp.js";
-import { n as getRouterOrNull } from "./router-ref-BzqbPwYC.js";
-import "./segment-context-CjOlyB8Y.js";
-import React, { createElement, useSyncExternalStore } from "react";
-//#region src/client/use-pending-navigation.ts
-function subscribe(onStoreChange) {
-	const router = getRouterOrNull();
-	if (!router) return () => {};
-	return router.onPendingChange(onStoreChange);
-}
-function getSnapshot() {
-	const router = getRouterOrNull();
-	return router ? router.isPending() : false;
-}
-var getServerSnapshot = getSnapshot;
-/**
-* Returns true while an RSC navigation is in flight.
-*
-* Reads from the router's external pending store via useSyncExternalStore.
-* Only components that call this hook re-render when pending state
-* changes — no full-tree re-render.
-*
-* ```tsx
-* 'use client'
-* import { usePendingNavigation } from '@timber-js/app/client'
-*
-* export function NavBar() {
-*   const isPending = usePendingNavigation()
-*   return (
-*     <nav className={isPending ? 'opacity-50' : ''}>
-*       <Link href="/dashboard">Dashboard</Link>
-*     </nav>
-*   )
-* }
-* ```
-*/
-function usePendingNavigation() {
-	return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-}
-//#endregion
-//#region src/client/navigation-context.ts
-/**
-* NavigationContext — React context for navigation state.
-*
-* Holds the current pathname and search, updated atomically with the RSC
-* tree on each navigation. This replaces the previous useSyncExternalStore
-* approach for usePathname() and useSearchParams(), which suffered from a
-* timing gap: the new tree could commit before the external store
-* re-renders fired, causing a frame where both old and new active states
-* were visible simultaneously.
-*
-* Segment params are NOT here — see the note on NavigationState below.
-*
-* By wrapping the RSC payload element in NavigationProvider inside
-* renderRoot(), the context value and the element tree are passed to
-* reactRoot.render() in the same call — atomic by construction.
-* All consumers (usePathname, useSearchParams) see the new values in the
-* same render pass as the new tree.
-*
-* During SSR, no NavigationProvider is mounted. Hooks fall back to
-* the ALS-backed getSsrData() for per-request isolation.
-*
-* IMPORTANT: createContext and useContext are NOT available in the RSC
-* environment (React Server Components use a stripped-down React).
-* The context is lazily initialized on first access, and all functions
-* that depend on these APIs are safe to call from any environment —
-* they return null or no-op when the APIs aren't available.
-*
-* SINGLETON GUARANTEE: All shared mutable state uses globalThis via
-* Symbol.for keys. The RSC client bundler can duplicate this module
-* across chunks (browser-entry graph + client-reference graph). With
-* ESM output, each chunk gets its own module scope — module-level
-* variables would create separate singleton instances per chunk.
-* globalThis guarantees a single instance regardless of duplication.
-*
-* This workaround will be removed when Rolldown ships `format: 'app'`
-* (module registry format that deduplicates like webpack/Turbopack).
-* See design/27-chunking-strategy.md.
-*
-* See design/19-client-navigation.md §"NavigationContext"
-*/
-/**
-* The context is created lazily to avoid calling createContext at module
-* level. In the RSC environment, React.createContext doesn't exist —
-* calling it at import time would crash the server.
-*
-* Context instances are stored on globalThis (NOT in module-level
-* variables) because the ESM bundler can duplicate this module across
-* chunks. Module-level variables would create separate instances per
-* chunk — the provider in NavigationRoot (index chunk) would use
-* context A while the consumer in usePendingNavigation (shared chunk)
-* reads from context B. globalThis guarantees a single instance.
-*
-* See design/27-chunking-strategy.md §"Singleton Safety"
-*/
-var NAV_CTX_KEY = Symbol.for("__timber_nav_ctx");
-function getOrCreateContext$1() {
-	const existing = globalThis[NAV_CTX_KEY];
-	if (existing !== void 0) return existing;
-	if (typeof React.createContext === "function") {
-		const ctx = React.createContext(null);
-		globalThis[NAV_CTX_KEY] = ctx;
-		return ctx;
-	}
-}
-/**
-* Read the navigation context. Returns null during SSR (no provider)
-* or in the RSC environment (no context available).
-* Internal — used by usePathname() and useSearchParams().
-*/
-function useNavigationContext() {
-	const ctx = getOrCreateContext$1();
-	if (!ctx) return null;
-	if (typeof React.useContext !== "function") return null;
-	return React.useContext(ctx);
-}
-/**
-* Wraps children with NavigationContext.Provider.
-*
-* Used in browser-entry.ts renderRoot to wrap the RSC payload element
-* so that navigation state updates atomically with the tree render.
-*/
-function NavigationProvider({ value, children }) {
-	const ctx = getOrCreateContext$1();
-	if (!ctx) return children;
-	return createElement(ctx.Provider, { value }, children);
-}
-/**
-* Navigation state communicated between the router and renderRoot.
-*
-* The router calls setNavigationState() before renderRoot(). The
-* renderRoot callback reads via getNavigationState() to create the
-* NavigationProvider with the correct params/pathname.
-*
-* This is NOT used by hooks directly — hooks read from React context.
-*
-* Stored on globalThis (like the context instances above) because the
-* router lives in one chunk while renderRoot lives in another. Module-
-* level variables would be separate per chunk.
-*/
-var NAV_STATE_KEY = Symbol.for("__timber_nav_state");
-function _getNavStateStore() {
-	const g = globalThis;
-	if (!g[NAV_STATE_KEY]) g[NAV_STATE_KEY] = { current: {
-		pathname: "/",
-		search: ""
-	} };
-	return g[NAV_STATE_KEY];
-}
-function setNavigationState(state) {
-	_getNavStateStore().current = state;
-}
-function getNavigationState() {
-	return _getNavStateStore().current;
-}
-/**
-* There was a second React context here — `PendingNavigationContext`, holding
-* the in-flight navigation URL, provided by `NavigationRoot` out of a
-* `useState` — plus a `usePendingNavigationUrl()` reader for it. Both are gone
-* (TIM-1307).
-*
-* Nothing read them. `usePendingNavigation()` (use-pending-navigation.ts) and
-* `TopLoader` both subscribe to the router's external pending store via
-* `useSyncExternalStore`: sync priority, immune to transition entanglement,
-* and cleared by `runNavigation`'s supersession-guarded `finally` (TIM-1034).
-* The context was a parallel representation of the same fact that no consumer
-* ever migrated to, and one that could not even agree with the store — a
-* navigation superseded by a cached popstate replay left its URL set until the
-* next full navigation, because the staleness guard skipped the clear and no
-* other path touched it.
-*
-* One representation, and it is the router's. See
-* design/19-client-navigation.md §"How Pending State Works".
-*/
-//#endregion
-//#region src/client/top-loader.tsx
-/**
-* TopLoader — Built-in progress bar for client navigations.
-*
-* Shows an animated progress bar at the top of the viewport while an RSC
-* navigation is in flight. Injected automatically by the framework into
-* NavigationRoot — users never render this component directly.
-*
-* Configuration is via timber.config.ts `topLoader` key. Enabled by default.
-* Users who want a fully custom progress indicator disable the built-in one
-* (`topLoader: { enabled: false }`) and use `usePendingNavigation()` directly.
-*
-* Animation approach: pure CSS @keyframes. The bar crawls from 0% to ~90%
-* width over ~30s using ease-out timing. When navigation completes, the bar
-* snaps to 100% and fades out over 200ms. No JS animation loops (RAF, setInterval).
-*
-* Phase transitions are derived synchronously during render (React's
-* getDerivedStateFromProps pattern) — no useEffect needed for state tracking.
-* The finishing → hidden cleanup uses onTransitionEnd from the CSS transition.
-*
-* When delay > 0, CSS animation-delay + a visibility keyframe ensure the bar
-* stays invisible during the delay period. If navigation finishes before the
-* delay, the bar was never visible so the finish transition is also invisible.
-*
-* See design/19-client-navigation.md §"usePendingNavigation()"
-* See LOCAL-336 for design decisions.
-*/
-//#endregion
-//#region src/client/navigation-root.tsx
-var NAV_TRANSITION_KEY = Symbol.for("__timber_nav_transition_counter");
-function getTransitionCounter() {
-	const g = globalThis;
-	const existing = g[NAV_TRANSITION_KEY];
-	if (!existing) {
-		const created = {
-			id: 0,
-			waiters: /* @__PURE__ */ new Set()
-		};
-		g[NAV_TRANSITION_KEY] = created;
-		return created;
-	}
-	existing.waiters ??= /* @__PURE__ */ new Set();
-	return existing;
-}
-/** Bump the counter and wake everything waiting on an older transition. */
-function bumpTransitionCounter() {
-	const counter = getTransitionCounter();
-	counter.id += 1;
-	for (const wake of [...counter.waiters]) wake();
-	return counter.id;
-}
-/**
-* Invalidate all in-flight navigation transitions. Any navigateTransition()
-* call whose perform() has not yet committed will reject with AbortError
-* instead of committing its element.
-*
-* Called by the router when a render supersedes in-flight navigations
-* WITHOUT going through navigateTransition() — the cached popstate replay
-* renders via transitionRender(), which doesn't bump the counter, so a
-* stale forward navigation's setElement would otherwise pass the
-* `counter.id !== transId` guard and commit the forward page over the
-* replayed back page (TIM-1022).
-*/
-function supersedeNavigationTransitions() {
-	bumpTransitionCounter();
-}
-/**
-* Module-level flag indicating a hard (MPA) navigation is in progress.
-*
-* When true:
-* - NavigationRoot throws an unresolved thenable to suspend forever,
-*   preventing React from rendering children during page teardown
-*   (avoids "Rendered more hooks" crashes).
-* - The Navigation API handler skips interception, letting the browser
-*   perform a full page load (prevents infinite loops where
-*   window.location.href → navigate event → router.navigate → 500 →
-*   window.location.href → ...).
-*
-* Uses globalThis for singleton guarantee across chunks (same pattern
-* as NavigationContext). See design/19-client-navigation.md §"Singleton
-* Guarantee via globalThis".
-*/
-var HARD_NAV_KEY = Symbol.for("__timber_hard_navigating");
-function getHardNavStore() {
-	const g = globalThis;
-	if (!g[HARD_NAV_KEY]) g[HARD_NAV_KEY] = { value: false };
-	return g[HARD_NAV_KEY];
-}
-/**
-* Set the hard-navigating flag. Call this BEFORE setting
-* window.location.href or window.location.reload() to prevent:
-* 1. React from rendering children during page teardown
-* 2. Navigation API from intercepting the hard navigation
-*/
-function setHardNavigating(value) {
-	getHardNavStore().value = value;
-}
-//#endregion
-//#region src/client/params-context.ts
-/**
-* Segment params context — the one channel params use to reach the browser.
-*
-* Params ride the RSC payload's root row as a sibling of the tree
-* (`{ tree, params, slotParams }`), rather than in four side channels that
-* raced to seed them: a response header, an inline script, and two build-time
-* manifest fields all previously carried the same record, each with its own
-* `JSON.stringify` (TIM-1294).
-*
-* Riding the payload is what makes them *typed*. `defineSchema` takes any
-* `Codec<T>`, so a coerced param is whatever the codec returned — a `Date`, a
-* `bigint` — and `JSON.stringify` either flattened it to a string or threw
-* mid-response. React Flight carries those values natively, so the client
-* reads the value the server produced instead of a lossy copy of it. See
-* design/41-global-params.md §"Transport".
-*
-* **The client owns the provider.** There is exactly one `ParamsProvider` in
-* the browser's tree, rendered by `PayloadRoot` above the point where a
-* partial navigation splices the new payload into the retained tree. It has to
-* be there and it has to be alone: a provider *inside* the payload lands below
-* the retained region, whose own root is the departing route's provider, so
-* every reader in a skipped layout resolves to the departing record and no
-* amount of wrapping above it helps (TIM-1297).
-*
-* Ordering still holds without a bootstrap contract, for the same reason it
-* did when the provider was in the tree: a provider renders before its own
-* descendants by construction, so `useSegmentParams()` is correct during
-* hydration without anything having to run before `hydrateRoot()`.
-*/
-/**
-* SINGLETON GUARANTEE: globalThis + `Symbol.for`, the same pattern as
-* `NavigationContext` and `SegmentUpdateContext`.
-*
-* The RSC client bundler can duplicate a module across chunks, and with ESM
-* output each chunk gets its own module scope — so a bare `createContext` at
-* module level yields one context per chunk. This module is now reached from
-* *both* graphs: `PayloadRoot` is imported by the browser entry, while
-* `useParamsContext()` arrives through the client-reference graph with the
-* app's own components. A duplicate would put the provider on instance A and
-* every reader on instance B, so `useContext` returns `null` and every
-* `useSegmentParams()` call silently falls back to the module snapshot.
-*
-* This module was the one client context without the guard — harmless while
-* the provider travelled inside the payload, in the same graph as its readers,
-* and load-bearing the moment the client started rendering it (TIM-1297).
-*
-* The React APIs are reached through the namespace rather than named imports,
-* for the same reason `segment-update-context.ts` and `navigation-context.ts`
-* do it: React's `react-server` export provides neither `createContext` nor
-* `useContext`, and a *named* ESM import of a missing export fails at module
-* instantiation — before any feature check could run. This module is reachable
-* from every entry a Server Component imports, so the named form crashed
-* those entries outright (codex, PR #992; originally reproduced against
-* `@timber-js/app/segment-params`, an entry point since deleted by TIM-1342 —
-* the hazard is unchanged for the entries that remain).
-*
-* See design/19-client-navigation.md §"Singleton Guarantee via globalThis"
-*/
-var PARAMS_CTX_KEY = Symbol.for("__timber_params_ctx");
-function getOrCreateContext() {
-	const store = globalThis;
-	const existing = store[PARAMS_CTX_KEY];
-	if (existing !== void 0) return existing;
-	if (typeof React.createContext !== "function") return;
-	const ctx = React.createContext(null);
-	store[PARAMS_CTX_KEY] = ctx;
-	return ctx;
-}
-var ParamsContext = getOrCreateContext();
-/**
-* Read the params provided by the tree. Returns null when no provider is
-* above the caller — a component rendered outside a timber route, a
-* `useSegmentParams()` call from outside React entirely, or any component
-* during SSR (where the params reach the hook through the ALS-backed SSR data
-* context instead, and there is no client-owned tree to hold a provider).
-*/
-function useParamsContext() {
-	return React.useContext(ParamsContext);
-}
-//#endregion
-//#region src/client/use-segment-params.ts
-/**
-* Set the current route params in the module-level store.
-*
-* Called by the router on each navigation. This updates the fallback
-* snapshot used by tests and by the hook when called outside a React
-* component (no NavigationContext available).
-*
-* On the client, the primary reactivity path is NavigationContext —
-* the router calls setNavigationState() then renderRoot() which wraps
-* the element in NavigationProvider. setCurrentParams is still called
-* for the module-level fallback.
-*
-* During SSR, params are also available via getSsrData().params
-* (ALS-backed).
-*/
-function setCurrentParams(params) {
-	_setCurrentParams(params);
-}
-/**
-* Set the per-slot params snapshot in the module-level store.
-*
-* Paired with `setCurrentParams`: the router calls both on every navigation,
-* including with `null` when a response carries no slot params, so a slot's
-* params from the *previous* route cannot be read on the next one. Fill and
-* serve are paired; so are fill and clear. See TIM-1285.
-*/
-function setCurrentSlotParams(slotParams) {
-	_setCurrentSlotParams(slotParams);
-}
-function useSegmentParams(segmentPath) {
-	try {
-		const paramsContext = useParamsContext();
-		if (paramsContext !== null) return resolveSegmentParams(paramsContext.params, paramsContext.slotParams, segmentPath);
-	} catch {}
-	const ssrData = getSsrData();
-	if (ssrData) return resolveSegmentParams(ssrData.params, ssrData.slotParams, segmentPath);
-	return resolveSegmentParams(currentParams, currentSlotParams, segmentPath);
-}
-//#endregion
-export { supersedeNavigationTransitions as a, setNavigationState as c, setHardNavigating as i, useNavigationContext as l, setCurrentSlotParams as n, NavigationProvider as o, useSegmentParams as r, getNavigationState as s, setCurrentParams as t, usePendingNavigation as u };
-
-//# sourceMappingURL=use-segment-params-DzTBpkvj.js.map