@timber-js/app 0.2.0-alpha.124 → 0.2.0-alpha.125

package/dist/client/segment-outlet.d.ts

@@ -1,27 +1,24 @@
 /**
  * SegmentOutlet — client component boundary at each layout segment.
  *
- * Replaces the post-hoc tree walking in segment-merger.ts with an explicit
- * client component at each segment boundary. Each outlet:
+ * Each layout in the segment tree is wrapped with a SegmentOutlet that:
+ * 1. Knows its segment path (prop from the server)
+ * 2. Reads from SegmentUpdateContext for partial navigation updates
+ * 3. Caches its rendered content in a ref across navigations
  *
- * 1. Knows its own segment path (prop from the server)
- * 2. Caches its children in a ref across navigations
- * 3. When `keepCurrent` is true (partial navigation, this segment skipped),
- *    returns the previously cached children — layout state is preserved
- * 4. When `keepCurrent` is false (full navigation or this segment changed),
- *    stores and renders the new children
+ * On full navigation: receives new children via props, caches and renders them.
+ * On partial navigation (this segment skipped): the context map has no entry
+ * for this path, so the outlet returns cached content — preserving layout state.
+ * On partial navigation (this segment updated): the context map has content
+ * for this path, so the outlet renders the update.
  *
- * This eliminates the need for client-side element tree walking, which
- * breaks on real RSC trees due to opaque client component lazy refs,
- * Suspense thenables, and AccessGate wrappers.
+ * Uses React context instead of useSyncExternalStore to stay compatible
+ * with concurrent rendering (transitions). All outlets re-render when the
+ * context value changes, but each bails out quickly if its segment has
+ * no update — same approach as Next.js LayoutRouter.
  *
- * Architecture is similar to Next.js's `<LayoutRouter>` client component —
- * each layout boundary is an explicit client component that manages its
- * own subtree. See design/19-client-navigation.md.
- *
- * Security: This is a performance optimization only. The server always
- * runs all access.ts files regardless of segment skipping. A fabricated
- * keepCurrent prop can only cause stale layouts — never auth bypass.
+ * Security: performance optimization only. The server always runs all
+ * access.ts files regardless of segment skipping.
  * See design/13-security.md §"State tree manipulation".
  */
 import { type ReactNode } from 'react';
@@ -33,31 +30,20 @@ export interface SegmentOutletProps {
      * the same urlPath. Must match the segmentId used in state-tree-diff.ts.
      */
     segmentPath: string;
-    /**
-     * When true, the outlet returns its previously cached children instead
-     * of rendering the new children prop. Set by the server when this
-     * segment was skipped (the client already has the layout mounted).
-     *
-     * On the first render (SSR/hydration), this is always false — there's
-     * no cached content yet. On subsequent partial navigations, the server
-     * sets this to true for segments it skipped rendering.
-     */
-    keepCurrent?: boolean;
     /** The segment's React subtree (layout + inner content). */
     children: ReactNode;
 }
 /**
  * Client component boundary at each layout segment in the element tree.
  *
- * On full navigation: receives new children, stores them, renders them.
- * On partial navigation (keepCurrent=true): ignores children prop,
- * returns previously stored content — React reconciles the same elements,
- * preserving all client component state in the layout subtree.
+ * On full navigation (context map is empty): renders children, caches in ref.
+ * On partial navigation: checks the context map for an update at segmentPath.
+ *   - Update found → renders update, caches in ref.
+ *   - No update → returns cached content (layout state preserved).
  *
- * React preserves the ref across `reactRoot.render()` calls because:
- * - SegmentOutlet has a stable type (client component module reference)
- * - It appears at the same tree position on every navigation
- * - React reconciles same-type, same-position → instance preserved
+ * React preserves component instances across reactRoot.render() calls
+ * when the same type appears at the same tree position. The ref persists
+ * across navigations because SegmentOutlet is reconciled, not remounted.
  */
-export declare function SegmentOutlet({ segmentPath: _segmentPath, keepCurrent, children, }: SegmentOutletProps): ReactNode;
+export declare function SegmentOutlet({ segmentPath, children }: SegmentOutletProps): ReactNode;
 //# sourceMappingURL=segment-outlet.d.ts.map

package/dist/client/segment-outlet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"segment-outlet.d.ts","sourceRoot":"","sources":["../../src/client/segment-outlet.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH,OAAO,EAAU,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAE/C,MAAM,WAAW,kBAAkB;IACjC;;;;;OAKG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB,4DAA4D;IAC5D,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,EAC5B,WAAW,EAAE,YAAY,EACzB,WAAmB,EACnB,QAAQ,GACT,EAAE,kBAAkB,aAapB"}
+{"version":3,"file":"segment-outlet.d.ts","sourceRoot":"","sources":["../../src/client/segment-outlet.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,OAAO,EAAsB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAG3D,MAAM,WAAW,kBAAkB;IACjC;;;;;OAKG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB,4DAA4D;IAC5D,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,EAAE,WAAW,EAAE,QAAQ,EAAE,EAAE,kBAAkB,aAsB1E"}

package/dist/client/segment-update-context.d.ts

@@ -0,0 +1,21 @@
+/**
+ * SegmentUpdateContext — React context for partial navigation updates.
+ *
+ * During partial navigation (server skips unchanged sync layouts), the
+ * router builds a Map of segment path → ReactNode updates and passes it
+ * as the context value. Mounted SegmentOutlet components read from this
+ * context to decide whether to render the update or their cached content.
+ *
+ * SINGLETON GUARANTEE: Uses globalThis + Symbol.for — same pattern as
+ * NavigationContext. 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 — a bare createContext
+ * at module level would create separate instances per chunk. globalThis
+ * guarantees a single instance regardless of duplication.
+ *
+ * See design/19-client-navigation.md §"Singleton Guarantee via globalThis"
+ */
+import React from 'react';
+export declare const EMPTY_SEGMENT_UPDATES: Map<string, React.ReactNode>;
+export declare const SegmentUpdateContext: React.Context<Map<string, React.ReactNode>>;
+//# sourceMappingURL=segment-update-context.d.ts.map

package/dist/client/segment-update-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment-update-context.d.ts","sourceRoot":"","sources":["../../src/client/segment-update-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,KAAyB,MAAM,OAAO,CAAC;AAE9C,eAAO,MAAM,qBAAqB,8BAA+B,CAAC;AAmBlE,eAAO,MAAM,oBAAoB,6CAAuB,CAAC"}

package/dist/index.js

@@ -7240,6 +7240,6 @@ function timber(config) {
 	];
 }
 //#endregion
-export { timber as default, timber, defineConfig };
+export { timber as default, timber, defineConfig, __exportAll as t };
 
 //# sourceMappingURL=index.js.map

package/dist/server/internal.js

@@ -9,7 +9,7 @@ import { n as toBracketKey } from "../_chunks/resolve-schema-DU2nbVOi.js";
 import "../_chunks/segment-context-Bg0pFbLT.js";
 import { readFile } from "node:fs/promises";
 import "node:crypto";
-import { createElement } from "react";
+import React, { createElement } from "react";
 //#region src/server/server-timing.ts
 /**
 * Server-Timing header — dev-mode timing breakdowns for Chrome DevTools.
@@ -1401,6 +1401,62 @@ async function coerceSegmentParams(match) {
 	}
 }
 //#endregion
+//#region src/client/segment-update-context.ts
+/**
+* SegmentUpdateContext — React context for partial navigation updates.
+*
+* During partial navigation (server skips unchanged sync layouts), the
+* router builds a Map of segment path → ReactNode updates and passes it
+* as the context value. Mounted SegmentOutlet components read from this
+* context to decide whether to render the update or their cached content.
+*
+* SINGLETON GUARANTEE: Uses globalThis + Symbol.for — same pattern as
+* NavigationContext. 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 — a bare createContext
+* at module level would create separate instances per chunk. globalThis
+* guarantees a single instance regardless of duplication.
+*
+* See design/19-client-navigation.md §"Singleton Guarantee via globalThis"
+*/
+var EMPTY_SEGMENT_UPDATES = /* @__PURE__ */ new Map();
+var CTX_KEY = Symbol.for("__timber_segment_update_ctx");
+function getOrCreateContext() {
+	const existing = globalThis[CTX_KEY];
+	if (existing !== void 0) return existing;
+	if (typeof React.createContext === "function") {
+		const ctx = React.createContext(EMPTY_SEGMENT_UPDATES);
+		globalThis[CTX_KEY] = ctx;
+		return ctx;
+	}
+}
+getOrCreateContext();
+//#endregion
+//#region src/client/segment-outlet.tsx
+/**
+* SegmentOutlet — client component boundary at each layout segment.
+*
+* Each layout in the segment tree is wrapped with a SegmentOutlet that:
+* 1. Knows its segment path (prop from the server)
+* 2. Reads from SegmentUpdateContext for partial navigation updates
+* 3. Caches its rendered content in a ref across navigations
+*
+* On full navigation: receives new children via props, caches and renders them.
+* On partial navigation (this segment skipped): the context map has no entry
+* for this path, so the outlet returns cached content — preserving layout state.
+* On partial navigation (this segment updated): the context map has content
+* for this path, so the outlet renders the update.
+*
+* Uses React context instead of useSyncExternalStore to stay compatible
+* with concurrent rendering (transitions). All outlets re-render when the
+* context value changes, but each bails out quickly if its segment has
+* no update — same approach as Next.js LayoutRouter.
+*
+* Security: performance optimization only. The server always runs all
+* access.ts files regardless of segment skipping.
+* See design/13-security.md §"State tree manipulation".
+*/
+//#endregion
 //#region src/server/route-element-builder.ts
 /**
 * Thrown when a defineSegmentParams codec's parse() fails.