@timber-js/app 0.2.0-alpha.179 → 0.2.0-alpha.180

package/dist/server/route-element-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route-element-builder.d.ts","sourceRoot":"","sources":["../../src/server/route-element-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAe9D,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAO1E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,EAAyC,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAyCnG;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,OAAO,GAAG,OAAO,CAM7D;AAID;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAID,+CAA+C;AAC/C,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IAC3C,OAAO,EAAE,mBAAmB,CAAC;CAC9B;AAED,+CAA+C;AAC/C,MAAM,WAAW,kBAAkB;IACjC,wFAAwF;IACxF,OAAO,EAAE,KAAK,CAAC,YAAY,CAAC;IAC5B,wDAAwD;IACxD,gBAAgB,EAAE,oBAAoB,EAAE,CAAC;IACzC,qCAAqC;IACrC,QAAQ,EAAE,mBAAmB,EAAE,CAAC;IAChC,4DAA4D;IAC5D,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B;;;;OAIG;IACH,YAAY,EAAE,aAAa,EAAE,CAAC;CAC/B;AA8DD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,UAAU,EACjB,YAAY,CAAC,EAAE,mBAAmB,EAClC,eAAe,CAAC,EAAE,eAAe,GAAG,IAAI,EACxC,mBAAmB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3C,OAAO,CAAC,kBAAkB,CAAC,CAsgB7B"}
+{"version":3,"file":"route-element-builder.d.ts","sourceRoot":"","sources":["../../src/server/route-element-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAe9D,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAO3F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,EAKL,KAAK,eAAe,EACrB,MAAM,sBAAsB,CAAC;AAsH9B;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,OAAO,GAAG,OAAO,CAM7D;AAID;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAID,+CAA+C;AAC/C,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IAC3C,OAAO,EAAE,mBAAmB,CAAC;CAC9B;AAED,+CAA+C;AAC/C,MAAM,WAAW,kBAAkB;IACjC,wFAAwF;IACxF,OAAO,EAAE,KAAK,CAAC,YAAY,CAAC;IAC5B,wDAAwD;IACxD,gBAAgB,EAAE,oBAAoB,EAAE,CAAC;IACzC,qCAAqC;IACrC,QAAQ,EAAE,mBAAmB,EAAE,CAAC;IAChC,4DAA4D;IAC5D,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B;;;;OAIG;IACH,YAAY,EAAE,aAAa,EAAE,CAAC;CAC/B;AA8DD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,UAAU,EACjB,YAAY,CAAC,EAAE,mBAAmB,EAClC,eAAe,CAAC,EAAE,eAAe,GAAG,IAAI,EACxC,mBAAmB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3C,OAAO,CAAC,kBAAkB,CAAC,CAohB7B"}

package/dist/server/slot-resolver.d.ts

@@ -34,6 +34,18 @@ type CreateElementFn = (...args: unknown[]) => React.ReactElement;
  *    so a denied layout never executes — see TIM-1074)
  */
 export declare function resolveSlotElement(slotNode: ManifestSegmentNode, match: RouteMatch, h: CreateElementFn, interception?: InterceptionContext, parentTreePath?: string, accessVerdicts?: SlotAccessVerdict[]): Promise<React.ReactElement | null>;
+/**
+ * Extract raw URL path parts from a main-route segment chain.
+ *
+ * Each dynamic segment consumed one URL part (its param value).
+ * Static segments consumed their own name. Groups are transparent.
+ * Catch-all segments consumed multiple parts (their param value is string[]).
+ *
+ * Uses rawSegmentParams (pre-coercion) to get actual URL strings.
+ * Values are coerced to String() defensively in case a codec leaked
+ * a non-string value into the params map.
+ */
+export declare function extractUrlParts(segments: ManifestSegmentNode[], mainParams: Record<string, string | string[]>): string[];
 /** Result of eagerly evaluating one segment's access.ts. */
 export interface SlotAccessVerdict {
     node: ManifestSegmentNode;

package/dist/server/slot-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slot-resolver.d.ts","sourceRoot":"","sources":["../../src/server/slot-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH,OAAO,KAAK,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAK9D,OAAO,EAAkC,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG5F,KAAK,eAAe,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,KAAK,CAAC,YAAY,CAAC;AAgClE;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,mBAAmB,EAC7B,KAAK,EAAE,UAAU,EACjB,CAAC,EAAE,eAAe,EAClB,YAAY,CAAC,EAAE,mBAAmB,EAClC,cAAc,CAAC,EAAE,MAAM,EACvB,cAAc,CAAC,EAAE,iBAAiB,EAAE,GACnC,OAAO,CAAC,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC,CAwHpC;AA8PD,4DAA4D;AAC5D,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,mBAAmB,CAAC;IAC1B;;;;;;OAMG;IACH,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,UAAU,GAAG,cAAc,CAAC;CACzD;AAwDD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,kBAAkB,EAAE,OAAO,CAAC;IAC5B,0DAA0D;IAC1D,MAAM,EAAE,OAAO,CAAC;IAChB,gFAAgF;IAChF,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,UAAU,oBAAoB;IAC5B,OAAO,EAAE,mBAAmB,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,UAAU,CAAC;IAClB,CAAC,EAAE,eAAe,CAAC;IACnB,YAAY,CAAC,EAAE,mBAAmB,CAAC;IACnC,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IACxC,YAAY,EAAE,aAAa,EAAE,CAAC;CAC/B;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,OAAO,EACP,SAAS,EACT,KAAK,EACL,CAAC,EACD,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,cAAc,EACd,eAAe,EACf,YAAY,GACb,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAwLzD"}
+{"version":3,"file":"slot-resolver.d.ts","sourceRoot":"","sources":["../../src/server/slot-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH,OAAO,KAAK,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAK9D,OAAO,EAAkC,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG5F,KAAK,eAAe,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,KAAK,CAAC,YAAY,CAAC;AAgClE;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,mBAAmB,EAC7B,KAAK,EAAE,UAAU,EACjB,CAAC,EAAE,eAAe,EAClB,YAAY,CAAC,EAAE,mBAAmB,EAClC,cAAc,CAAC,EAAE,MAAM,EACvB,cAAc,CAAC,EAAE,iBAAiB,EAAE,GACnC,OAAO,CAAC,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC,CAwHpC;AAkKD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,GAC5C,MAAM,EAAE,CAsBV;AAwDD,4DAA4D;AAC5D,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,mBAAmB,CAAC;IAC1B;;;;;;OAMG;IACH,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,UAAU,GAAG,cAAc,CAAC;CACzD;AAwDD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,kBAAkB,EAAE,OAAO,CAAC;IAC5B,0DAA0D;IAC1D,MAAM,EAAE,OAAO,CAAC;IAChB,gFAAgF;IAChF,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,UAAU,oBAAoB;IAC5B,OAAO,EAAE,mBAAmB,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,UAAU,CAAC;IAClB,CAAC,EAAE,eAAe,CAAC;IACnB,YAAY,CAAC,EAAE,mBAAmB,CAAC;IACnC,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IACxC,YAAY,EAAE,aAAa,EAAE,CAAC;CAC/B;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,OAAO,EACP,SAAS,EACT,KAAK,EACL,CAAC,EACD,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,cAAc,EACd,eAAe,EACf,YAAY,GACb,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAwLzD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timber-js/app",
-  "version": "0.2.0-alpha.179",
+  "version": "0.2.0-alpha.180",
   "description": "Vite-native React framework built for Servers and Serverless Platforms — correct HTTP semantics, real status codes, pages that work without JavaScript",
   "keywords": [
     "cloudflare-workers",

package/src/client/browser-entry/router-init.ts

@@ -255,16 +255,13 @@ export function createTimberRouter(options?: RouterInitOptions): RouterInitResul
   let navApiController: NavigationApiController | null = null;
   if (useNavApi) {
     navApiController = setupNavigationApi({
-      onExternalNavigate: async (url, { replace, signal, scroll }) => {
-        // Navigation intercepted by the Navigation API. Covers both
-        // Link <a> clicks (user-initiated) and external navigations.
-        // The Navigation API handles the URL update via intercept(),
-        // so pass _skipHistory to avoid double pushState.
+      onExternalNavigate: async (url, { replace, signal, scroll, departingUrl }) => {
         await router.navigate(url, {
           replace,
           scroll,
           _signal: signal,
           _skipHistory: true,
+          _departingUrl: departingUrl,
         });
       },
       onTraverse: async (url, scrollY, signal) => {

package/src/client/navigation-api.ts

@@ -54,7 +54,7 @@ export interface NavigationApiCallbacks {
    */
   onExternalNavigate: (
     url: string,
-    options: { replace: boolean; signal: AbortSignal; scroll?: boolean }
+    options: { replace: boolean; signal: AbortSignal; scroll?: boolean; departingUrl?: string }
   ) => Promise<void>;
 
   /**
@@ -261,18 +261,22 @@ export function setupNavigationApi(callbacks: NavigationApiCallbacks): Navigatio
         // Ignore — entry may be disposed
       }
 
+      // Capture the departing URL BEFORE event.intercept() commits the
+      // destination. Once intercept() is called, currentEntry switches and
+      // getCurrentUrl() returns the destination (TIM-1232).
+      const departingUrl = nav.currentEntry?.url
+        ? new URL(nav.currentEntry.url).pathname + new URL(nav.currentEntry.url).search
+        : undefined;
+
       event.intercept({
         scroll: 'manual',
         focusReset: 'manual',
         async handler() {
-          // Keep the #fragment — router.navigate splits it back off for the
-          // RSC fetch and scrolls to the matching element after render
-          // (TIM-1035). Traversals above stay hash-less: history-stack keys
-          // use pathname + search.
           await callbacks.onExternalNavigate(url + destUrl.hash, {
             replace: event.navigationType === 'replace',
             signal: event.signal,
             scroll: undefined,
+            departingUrl,
           });
         },
       });

package/src/client/router.ts

@@ -40,6 +40,12 @@ export interface NavigationOptions {
    * intercepted by the navigate event handler.
    */
   _skipHistory?: boolean;
+  /**
+   * @internal The URL the user is navigating FROM, captured before the
+   * Navigation API commits the destination. Sent as X-Timber-URL for
+   * slot skip comparison on the server (TIM-1232).
+   */
+  _departingUrl?: string;
 }
 
 /**
@@ -412,8 +418,6 @@ export function createRouter(deps: RouterDeps): RouterInstance {
     if (segmentInfo) {
       for (const info of segmentInfo) {
         if (!skipped.has(info.segmentId ?? info.path)) {
-          // Use segmentId (outlet key) when available — route groups
-          // use a disambiguated key like "/(marketing)" instead of "/".
           updates.set(info.segmentId ?? info.path, result.payload);
           break;
         }
@@ -530,7 +534,13 @@ export function createRouter(deps: RouterDeps): RouterInstance {
    */
   async function performNavigationFetch(
     url: string,
-    options: { replace: boolean; commitUrl?: string; signal?: AbortSignal; skipHistory?: boolean }
+    options: {
+      replace: boolean;
+      commitUrl?: string;
+      signal?: AbortSignal;
+      skipHistory?: boolean;
+      departingUrl?: string;
+    }
   ): Promise<FetchResult & { navState: NavigationState }> {
     // Check prefetch cache first. PrefetchResult has optional segmentInfo/params
     // fields — normalize to null for FetchResult compatibility.
@@ -547,12 +557,14 @@ export function createRouter(deps: RouterDeps): RouterInstance {
 
     if (result === undefined) {
       // Fetch RSC payload with state tree for partial rendering.
-      // Send current URL for intercepting route resolution (modal pattern).
+      // Send departing URL (pre-navigation) for slot skip comparison.
+      // getCurrentUrl() can't be used here because the Navigation API
+      // may have already committed the destination URL (TIM-1232).
       const stateTree = deps.clientSegmentCache ? segmentCache.serializeStateTree() : undefined;
-      const rawCurrentUrl = deps.getCurrentUrl();
-      const currentUrl = rawCurrentUrl.startsWith('http')
-        ? new URL(rawCurrentUrl).pathname
-        : new URL(rawCurrentUrl, 'http://localhost').pathname;
+      const rawDepartingUrl = options.departingUrl ?? deps.getCurrentUrl();
+      const currentUrl = rawDepartingUrl.startsWith('http')
+        ? new URL(rawDepartingUrl).pathname
+        : new URL(rawDepartingUrl, 'http://localhost').pathname;
       result = await fetchRscPayload(url, deps, stateTree, currentUrl, options.signal);
     }
 
@@ -607,6 +619,12 @@ export function createRouter(deps: RouterDeps): RouterInstance {
     const hash = hashIndex === -1 ? '' : url.slice(hashIndex);
     const fetchUrl = hashIndex === -1 ? url : url.slice(0, hashIndex);
 
+    // Use the pre-intercept departing URL when the Navigation API has already
+    // committed the destination (_departingUrl from navigation-api.ts). Otherwise
+    // capture it now — getCurrentUrl() is still the departing URL at this point
+    // for non-Navigation-API navigations (TIM-1232).
+    const departingUrl = options._departingUrl ?? deps.getCurrentUrl();
+
     // Capture the departing page's scroll position for scroll={false} preservation.
     const currentScrollY = deps.getScrollY();
 
@@ -641,6 +659,7 @@ export function createRouter(deps: RouterDeps): RouterInstance {
               commitUrl: url,
               signal: navAbort.signal,
               skipHistory: effectiveSkipHistory,
+              departingUrl,
             })
           );
 

package/src/client/segment-outlet.tsx

@@ -49,6 +49,37 @@ export interface SegmentOutletProps {
   skip?: boolean;
 }
 
+// ─── Slot Content Cache ──────────────────────────────────────────
+// Persists slot content across SegmentOutlet fiber lifecycles.
+// When React creates new fibers during full navigation (e.g., the
+// server sends a complete new tree and React remounts the subtree),
+// useRef starts fresh with null. Skipped slots (skip=true, children=null)
+// would lose their cached content because contentRef.current is null.
+//
+// This globalThis-backed Map provides a fallback: SegmentOutlet stores
+// rendered content here whenever it renders non-null slot content, and
+// reads from it when skip=true but contentRef.current is null.
+//
+// Uses globalThis + Symbol.for for singleton guarantee across chunks —
+// same pattern as NavigationContext and SegmentUpdateContext.
+//
+// SSR safety: SegmentOutlet is 'use client' — during RSC rendering it's
+// serialized as a client reference and never executed. During SSR
+// (renderToReadableStream), the component IS executed but skip=true is
+// never sent (the server always renders full content). The cache may
+// accumulate entries during SSR but they're harmless — the skip=true
+// fallback path only activates on the client during SPA navigation.
+
+const SLOT_CACHE_KEY = Symbol.for('__timber_slot_content_cache');
+
+function getSlotContentCache(): Map<string, ReactNode> {
+  const g = globalThis as Record<symbol, unknown>;
+  if (!g[SLOT_CACHE_KEY]) {
+    g[SLOT_CACHE_KEY] = new Map<string, ReactNode>();
+  }
+  return g[SLOT_CACHE_KEY] as Map<string, ReactNode>;
+}
+
 /**
  * Client component boundary at each layout segment in the element tree.
  *
@@ -64,11 +95,13 @@ export interface SegmentOutletProps {
 export function SegmentOutlet({ segmentPath, children, skip }: SegmentOutletProps) {
   const updates = useContext(SegmentUpdateContext);
   const contentRef = useRef<ReactNode>(null);
+  const slotCache = getSlotContentCache();
 
   const update = updates.get(segmentPath);
 
   if (update !== undefined) {
     contentRef.current = update;
+    slotCache.set(segmentPath, update);
     return update;
   }
 
@@ -80,18 +113,27 @@ export function SegmentOutlet({ segmentPath, children, skip }: SegmentOutletProp
     if (contentRef.current !== null) {
       return contentRef.current;
     }
-    // No cached content — the SegmentOutlet instance is fresh (not
-    // reconciled from a previous render). Fall through to render
+    // Fiber was remounted (contentRef is fresh null). Fall back to the
+    // globalThis-backed cache which persists across fiber lifecycles.
+    if (slotCache.has(segmentPath)) {
+      const cached = slotCache.get(segmentPath)!;
+      contentRef.current = cached;
+      return cached;
+    }
+    // No cached content anywhere — the SegmentOutlet instance is fresh
+    // and no prior render has populated the cache. Fall through to render
     // children (null). The slot will be fully rendered next navigation.
   }
 
   if (contentRef.current === null) {
     contentRef.current = children;
+    slotCache.set(segmentPath, children);
     return children;
   }
 
   if (children !== contentRef.current) {
     contentRef.current = children;
+    slotCache.set(segmentPath, children);
     return children;
   }
 

package/src/server/route-element-builder.ts

@@ -34,7 +34,7 @@ import {
 } from './deny-boundary.js';
 import type { DenyPageEntry } from './deny-boundary.js';
 import { LAYOUT_CHILDREN_SLOT } from './prebuilt/slots.js';
-import { resolveSlotProps, type SlotSkipEntry } from './slot-resolver.js';
+import { resolveSlotProps, extractUrlParts, type SlotSkipEntry } from './slot-resolver.js';
 import { SegmentProvider } from '../client/segment-context.js';
 import { SegmentOutlet } from '../client/segment-outlet.js';
 import { SlotOutlet } from '../client/slot-outlet.js';
@@ -42,10 +42,93 @@ import { SlotsProvider } from '../client/slot-provider.js';
 
 import { wrapSegmentWithErrorBoundaries } from './error-boundary-wrapper.js';
 import type { InterceptionContext } from './pipeline.js';
-import { shouldSkipSegment, computeSegmentKeys, type ClientStateTree } from './state-tree-diff.js';
+import {
+  shouldSkipSegment,
+  shouldSkipSlot,
+  computeSegmentKeys,
+  computeSlotKey,
+  type ClientStateTree,
+} from './state-tree-diff.js';
 import { headElementsToReact } from './metadata.js';
 import { loadModule } from './safe-load.js';
 
+/**
+ * Truncate the skippable prefix when a skippable layout has slots whose
+ * content changed between the departing and destination URLs (TIM-1232).
+ *
+ * Without this, changed slots at skipped layouts are never sent to the
+ * client — the `continue` in the main loop skips slot resolution entirely.
+ * Removing the segment from the skippable set forces it to render with
+ * its slots. The prefix must stay contiguous, so all segments after the
+ * first changed-slot segment are also removed.
+ */
+function truncateSkippableForChangedSlots(
+  skippableSet: Set<number>,
+  segments: ManifestSegmentNode[],
+  segmentKeys: string[],
+  match: RouteMatch,
+  clientStateTree: ClientStateTree,
+  req: Request
+): void {
+  const departingUrl = req.headers.get('X-Timber-URL');
+  let depParsed: URL | null = null;
+  if (departingUrl) {
+    try {
+      depParsed = new URL(departingUrl, 'http://localhost');
+    } catch {
+      skippableSet.clear();
+      return;
+    }
+  }
+  const destPathname = new URL(req.url, 'http://localhost').pathname;
+  const depPathname = depParsed?.pathname ?? null;
+  const split = (p: string) => (p === '/' ? [] : p.slice(1).split('/'));
+  const destAll = split(destPathname);
+  const depAll = depPathname ? split(depPathname) : null;
+  const clientSlots = clientStateTree.slots ?? null;
+  const rawParams = match.rawSegmentParams ?? match.segmentParams ?? {};
+
+  for (let i = 0; i < segments.length; i++) {
+    if (!skippableSet.has(i)) continue;
+    const segment = segments[i];
+    const slotEntries = Object.entries(segment.slots ?? {});
+    if (slotEntries.length === 0) continue;
+
+    const segIdx = match.segments.indexOf(segment);
+    const parents =
+      segIdx >= 0 ? match.segments.slice(0, segIdx + 1).filter((s) => s.segmentName !== '') : [];
+    const sliceAt = extractUrlParts(parents, rawParams).length;
+    const destParts = destAll.slice(sliceAt);
+    const depParts = depAll ? depAll.slice(sliceAt) : null;
+    let parentChanged = false;
+    if (depAll) {
+      const dp = depAll.slice(0, sliceAt),
+        dd = destAll.slice(0, sliceAt);
+      parentChanged = dp.length !== dd.length || dp.some((p, j) => p !== dd[j]);
+    }
+
+    for (const [slotName, slotNode] of slotEntries) {
+      const m = slotNode as ManifestSegmentNode;
+      const k = computeSlotKey(segmentKeys[i], `@${slotName}`);
+      if (
+        m.children.some((c) => c.segmentType === 'intercepting') ||
+        parentChanged ||
+        depParts === null ||
+        !shouldSkipSlot({
+          slotKey: k,
+          clientSlots,
+          slotNode: m,
+          departingUrlParts: depParts,
+          destinationUrlParts: destParts,
+        })
+      ) {
+        for (let j = i; j < segments.length; j++) skippableSet.delete(j);
+        return;
+      }
+    }
+  }
+}
+
 /**
  * Replace the outermost SegmentOutlet in a partial payload with its
  * SegmentProvider child. Walks through AccessGate wrappers (which sit
@@ -544,6 +627,20 @@ export async function buildRouteElement(
     }
   }
 
+  // Slot-change guard (TIM-1232): if a skippable layout has parallel
+  // slots whose content changed, the layout cannot be skipped — it must
+  // render so its slots are included in the payload.
+  if (skippableSet.size > 0 && clientStateTree) {
+    truncateSkippableForChangedSlots(
+      skippableSet,
+      segments,
+      segmentKeys,
+      match,
+      clientStateTree,
+      req
+    );
+  }
+
   let outermostSegmentProvider: React.ReactElement | null = null;
 
   // Slot caching: the departing URL (X-Timber-URL header) and the

package/src/server/slot-resolver.ts

@@ -378,7 +378,7 @@ function findSlotMatch(slotNode: ManifestSegmentNode, match: RouteMatch): SlotMa
  * Values are coerced to String() defensively in case a codec leaked
  * a non-string value into the params map.
  */
-function extractUrlParts(
+export function extractUrlParts(
   segments: ManifestSegmentNode[],
   mainParams: Record<string, string | string[]>
 ): string[] {