@timber-js/app 0.1.42 → 0.1.44

package/dist/client/index.js

@@ -99,12 +99,28 @@ function useLinkStatus() {
 * 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.
+*
+* IMPORTANT: Context instances are stored on globalThis, NOT in module-
+* level variables. The RSC client bundler duplicates this module across
+* the browser-entry chunk (index) and client-reference chunk (shared-app)
+* because both entry graphs import it. Module-level variables would create
+* separate singleton instances per chunk — the provider in TransitionRoot
+* (index chunk) would use context A while the consumer in LinkStatusProvider
+* (shared-app chunk) reads from context B. globalThis guarantees a single
+* instance regardless of how many times the module is duplicated.
+*
+* See design/19-client-navigation.md §"Singleton Context Guarantee"
 */
-var _context;
+var NAV_CTX_KEY = Symbol.for("__timber_nav_ctx");
+var PENDING_CTX_KEY = Symbol.for("__timber_pending_nav_ctx");
 function getOrCreateContext() {
-	if (_context !== void 0) return _context;
-	if (typeof React.createContext === "function") _context = React.createContext(null);
-	return _context;
+	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)
@@ -129,40 +145,50 @@ function NavigationProvider({ value, children }) {
 	return createElement(ctx.Provider, { value }, children);
 }
 /**
-* Module-level navigation state. Updated by the router before calling
-* renderRoot(). The renderRoot callback reads this to create the
-* NavigationProvider with the correct values.
+* 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.
-* This exists only as a communication channel between the router
-* (which knows the new nav state) and renderRoot (which wraps the element).
+*
+* Stored on globalThis (like the context instances above) because the
+* router lives in the shared-app chunk while renderRoot lives in the
+* index chunk. Module-level variables would be separate per chunk.
 */
-var _currentNavState = {
-	params: {},
-	pathname: "/"
-};
+var NAV_STATE_KEY = Symbol.for("__timber_nav_state");
+function _getNavStateStore() {
+	const g = globalThis;
+	if (!g[NAV_STATE_KEY]) g[NAV_STATE_KEY] = { current: {
+		params: {},
+		pathname: "/"
+	} };
+	return g[NAV_STATE_KEY];
+}
 function setNavigationState(state) {
-	_currentNavState = state;
+	_getNavStateStore().current = state;
 }
 function getNavigationState() {
-	return _currentNavState;
+	return _getNavStateStore().current;
 }
 /**
 * Separate context for the in-flight navigation URL. Provided by
-* TransitionRoot (useOptimistic state), consumed by LinkStatusProvider
+* TransitionRoot (urgent useState), consumed by LinkStatusProvider
 * and useNavigationPending.
 *
-* Lives in this module (not a separate file) to guarantee singleton
-* identity across chunks. The `'use client'` LinkStatusProvider and
-* the non-directive TransitionRoot both import from this module —
-* if they were in separate files, the bundler could duplicate the
-* module-level context variable across chunks.
+* Uses globalThis via Symbol.for for the same reason as NavigationContext
+* above — the bundler duplicates this module across chunks, and module-
+* level variables would create separate context instances.
 */
-var _pendingContext;
 function getOrCreatePendingContext() {
-	if (_pendingContext !== void 0) return _pendingContext;
-	if (typeof React.createContext === "function") _pendingContext = React.createContext(null);
-	return _pendingContext;
+	const existing = globalThis[PENDING_CTX_KEY];
+	if (existing !== void 0) return existing;
+	if (typeof React.createContext === "function") {
+		const ctx = React.createContext(null);
+		globalThis[PENDING_CTX_KEY] = ctx;
+		return ctx;
+	}
 }
 /**
 * Read the pending navigation URL from context.