@timber-js/app 0.2.0-alpha.20 → 0.2.0-alpha.201

package/dist/_chunks/segment-classify-C539Pa2O.js

@@ -0,0 +1,197 @@
+//#region src/routing/types.ts
+/** All recognized interception markers, ordered longest-first for parsing. */
+var INTERCEPTION_MARKERS = [
+	"(..)(..)",
+	"(.)",
+	"(..)",
+	"(...)"
+];
+/** Default page extensions */
+var DEFAULT_PAGE_EXTENSIONS = [
+	"tsx",
+	"ts",
+	"jsx",
+	"js"
+];
+//#endregion
+//#region src/routing/segment-classify.ts
+/**
+* Classify a URL path segment token.
+*
+* Walks the string left-to-right in one pass:
+*   1. Find the first '[' — characters before it are the prefix.
+*   2. Count opening brackets (1 or 2) to detect optional.
+*   3. Check for '...' to detect catch-all.
+*   4. Read the param name up to the closing bracket.
+*   5. Validate the expected closing sequence (']' or ']]').
+*   6. Characters after the close are the suffix.
+*   7. Reject affixes on catch-all/optional-catch-all.
+*   8. Reject affixes that contain '[' or ']' (no multi-param segments).
+*
+* Any structural violation → static (safe default).
+*/
+function classifyUrlSegment(token) {
+	const len = token.length;
+	if (len === 0) return {
+		kind: "static",
+		value: token
+	};
+	const bracketStart = token.indexOf("[");
+	if (bracketStart === -1) return {
+		kind: "static",
+		value: token
+	};
+	const prefix = token.slice(0, bracketStart);
+	let i = bracketStart + 1;
+	const optional = i < len && token[i] === "[";
+	if (optional) i++;
+	const catchAll = i + 2 < len && token[i] === "." && token[i + 1] === "." && token[i + 2] === ".";
+	if (catchAll) i += 3;
+	const nameStart = i;
+	while (i < len && token[i] !== "]") i++;
+	if (i >= len || i === nameStart) return {
+		kind: "static",
+		value: token
+	};
+	const name = token.slice(nameStart, i);
+	i++;
+	if (optional) {
+		if (i >= len || token[i] !== "]") return {
+			kind: "static",
+			value: token
+		};
+		i++;
+	}
+	const suffix = token.slice(i);
+	if (suffix.includes("[") || suffix.includes("]")) return {
+		kind: "static",
+		value: token
+	};
+	if (prefix.includes("]")) return {
+		kind: "static",
+		value: token
+	};
+	const hasAffixes = prefix.length > 0 || suffix.length > 0;
+	if (optional && catchAll) {
+		if (hasAffixes) return {
+			kind: "static",
+			value: token
+		};
+		return {
+			kind: "optional-catch-all",
+			name
+		};
+	}
+	if (catchAll) {
+		if (hasAffixes) return {
+			kind: "static",
+			value: token
+		};
+		return {
+			kind: "catch-all",
+			name
+		};
+	}
+	if (optional) return {
+		kind: "static",
+		value: token
+	};
+	if (hasAffixes) return {
+		kind: "dynamic",
+		name,
+		prefix: prefix || void 0,
+		suffix: suffix || void 0
+	};
+	return {
+		kind: "dynamic",
+		name
+	};
+}
+/**
+* Classify a directory name into its segment type.
+*
+* Recognizes all timber file-system conventions in priority order:
+*   1. Private folders: `_name` (excluded from routing)
+*   2. Parallel route slots: `@name`
+*   3. Intercepting routes: `(.)name`, `(..)name`, `(...)name`, `(..)(..)name`
+*   4. Route groups: `(name)`
+*   5. Bracket syntax: `[id]`, `[...slug]`, `[[...path]]` (delegated to
+*      `classifyUrlSegment`)
+*   6. Static: anything else
+*
+* If you change the bracket syntax, update only `classifyUrlSegment`.
+* If you change the directory-prefix conventions, update this function.
+*/
+function classifySegment(dirName) {
+	if (dirName.startsWith("_")) return { type: "private" };
+	if (dirName.startsWith("@")) return { type: "slot" };
+	const interception = parseInterceptionMarker(dirName);
+	if (interception) return {
+		type: "intercepting",
+		interceptionMarker: interception.marker,
+		interceptedSegmentName: interception.segmentName
+	};
+	if (dirName.startsWith("(") && dirName.endsWith(")")) return { type: "group" };
+	const urlSeg = classifyUrlSegment(dirName);
+	if (urlSeg.kind !== "static") {
+		const result = {
+			type: urlSeg.kind,
+			paramName: urlSeg.name
+		};
+		if (urlSeg.kind === "dynamic") {
+			if (urlSeg.prefix) result.paramPrefix = urlSeg.prefix;
+			if (urlSeg.suffix) result.paramSuffix = urlSeg.suffix;
+		}
+		return result;
+	}
+	return { type: "static" };
+}
+function effectiveUrlSegment(node) {
+	if (node.segmentType !== "intercepting" || !node.interceptedSegmentName) return {
+		segmentName: node.segmentName,
+		segmentType: node.segmentType,
+		paramName: node.paramName,
+		paramPrefix: node.paramPrefix,
+		paramSuffix: node.paramSuffix
+	};
+	const seg = classifyUrlSegment(node.interceptedSegmentName);
+	if (seg.kind === "static") return {
+		segmentName: seg.value,
+		segmentType: "static"
+	};
+	return {
+		segmentName: node.interceptedSegmentName,
+		segmentType: seg.kind,
+		paramName: seg.name,
+		paramPrefix: seg.kind === "dynamic" ? seg.prefix : void 0,
+		paramSuffix: seg.kind === "dynamic" ? seg.suffix : void 0
+	};
+}
+/**
+* Parse an interception marker from a directory name.
+*
+* Returns the marker and the remaining segment name, or null if not an
+* intercepting route. Markers are checked longest-first to avoid `(..)`
+* matching before `(..)(..)`.
+*
+* Examples:
+*   "(.)photo"      → { marker: "(.)", segmentName: "photo" }
+*   "(..)feed"      → { marker: "(..)", segmentName: "feed" }
+*   "(...)photos"   → { marker: "(...)", segmentName: "photos" }
+*   "(..)(..)admin" → { marker: "(..)(..)", segmentName: "admin" }
+*   "(marketing)"   → null (route group, not interception)
+*/
+function parseInterceptionMarker(dirName) {
+	for (const marker of INTERCEPTION_MARKERS) if (dirName.startsWith(marker)) {
+		const rest = dirName.slice(marker.length);
+		if (rest.length > 0 && !rest.endsWith(")")) return {
+			marker,
+			segmentName: rest
+		};
+	}
+	return null;
+}
+//#endregion
+export { INTERCEPTION_MARKERS as a, DEFAULT_PAGE_EXTENSIONS as i, classifyUrlSegment as n, effectiveUrlSegment as r, classifySegment as t };
+
+//# sourceMappingURL=segment-classify-C539Pa2O.js.map

package/dist/_chunks/segment-classify-C539Pa2O.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment-classify-C539Pa2O.js","names":[],"sources":["../../src/routing/types.ts","../../src/routing/segment-classify.ts"],"sourcesContent":["/**\n * Route tree types for timber.js file-system routing.\n *\n * The route tree is built by scanning the app/ directory and recognizing\n * file conventions (page.*, layout.*, middleware.ts, access.ts, route.ts, etc.).\n *\n * **Single shape, two specializations** (TIM-848):\n *\n * `SegmentNode<TFile>` is the one canonical in-memory shape for the\n * timber route tree. The same interface is used at build time (with\n * `TFile = RouteFile`) and at request time (with `TFile = ManifestFile`,\n * see `server/route-matcher.ts`). Walkers parameterized over `TFile`\n * work on either, eliminating the previous duplication between\n * `SegmentNode` (Map-based) and `ManifestSegmentNode` (object-based).\n *\n * Keyed groups (`slots`, `statusFiles`, `jsonStatusFiles`,\n * `metadataRoutes`) are plain `Record<string, …>`\n * objects rather than `Map`s so that the build-time tree can be\n * serialized into the virtual route manifest with no shape transform.\n *\n * See design/07-routing.md §\"Route Tree Shape\" and design/18-build-system.md\n * §\"Route Manifest Shape\".\n */\n\n/** Segment type classification */\nexport type SegmentType =\n  | 'static' // e.g. \"dashboard\"\n  | 'dynamic' // e.g. \"[id]\"\n  | 'catch-all' // e.g. \"[...slug]\"\n  | 'optional-catch-all' // e.g. \"[[...slug]]\"\n  | 'group' // e.g. \"(marketing)\"\n  | 'slot' // e.g. \"@sidebar\"\n  | 'intercepting' // e.g. \"(.)photo\", \"(..)photo\", \"(...)photo\"\n  | 'private'; // e.g. \"_components\", \"_lib\" — excluded from routing\n\n/**\n * Intercepting route marker — indicates how many levels up to resolve the\n * intercepted route from the intercepting route's location.\n *\n * See design/07-routing.md §\"Intercepting Routes\"\n */\nexport type InterceptionMarker = '(.)' | '(..)' | '(...)' | '(..)(..)';\n\n/** All recognized interception markers, ordered longest-first for parsing. */\nexport const INTERCEPTION_MARKERS: InterceptionMarker[] = ['(..)(..)', '(.)', '(..)', '(...)'];\n\n/**\n * A single file discovered in a route segment at build time.\n *\n * The runtime equivalent (`ManifestFile`, defined in\n * `server/route-matcher.ts`) replaces `extension` with a lazy `load`\n * function. Walkers that only need `filePath` are parameterized over\n * `TFile` and accept either.\n */\nexport interface RouteFile {\n  /** Absolute path to the file */\n  filePath: string;\n  /** File extension without leading dot (e.g. \"tsx\", \"ts\", \"mdx\") */\n  extension: string;\n}\n\n/**\n * A node in the segment tree.\n *\n * Generic over `TFile` so the same interface describes both the\n * build-time tree (`SegmentNode<RouteFile>`, the default) and the\n * runtime manifest tree (`SegmentNode<ManifestFile>`, aliased as\n * `ManifestSegmentNode`). All keyed groups use `Record` (not `Map`)\n * so the build-time tree serializes to the virtual route manifest\n * with no shape transform.\n */\nexport interface SegmentNode<TFile = RouteFile> {\n  /** The raw directory name (e.g. \"dashboard\", \"[id]\", \"(auth)\", \"@sidebar\") */\n  segmentName: string;\n  /** Classified segment type */\n  segmentType: SegmentType;\n  /** The dynamic param name, if dynamic (e.g. \"id\" for \"[id]\", \"slug\" for \"[...slug]\") */\n  paramName?: string;\n  /** Literal prefix before the dynamic bracket (e.g. \"img-\" for \"img-[id].png\") */\n  paramPrefix?: string;\n  /** Literal suffix after the dynamic bracket (e.g. \".png\" for \"img-[id].png\") */\n  paramSuffix?: string;\n  /** The URL path prefix at this segment level (e.g. \"/dashboard\") */\n  urlPath: string;\n  /** For intercepting segments: the marker used, e.g. \"(.)\". */\n  interceptionMarker?: InterceptionMarker;\n  /**\n   * For intercepting segments: the segment name after stripping the marker.\n   * E.g., for \"(.)photo\" this is \"photo\".\n   */\n  interceptedSegmentName?: string;\n\n  // --- File conventions ---\n  page?: TFile;\n  layout?: TFile;\n  middleware?: TFile;\n  access?: TFile;\n  route?: TFile;\n  error?: TFile;\n  default?: TFile;\n  /** Status-code files: 4xx.tsx, 5xx.tsx, {status}.tsx (component format) */\n  statusFiles?: Record<string, TFile>;\n  /** JSON status-code files: 4xx.json, 5xx.json, {status}.json */\n  jsonStatusFiles?: Record<string, TFile>;\n  /** denied.tsx — slot-only denial rendering */\n  denied?: TFile;\n\n  /** Metadata route files (sitemap.ts, robots.ts, icon.tsx, etc.) keyed by base name */\n  metadataRoutes?: Record<string, TFile>;\n\n  // --- Children ---\n  children: SegmentNode<TFile>[];\n  /** Parallel route slots (keyed by slot name without @) */\n  slots: Record<string, SegmentNode<TFile>>;\n}\n\n/**\n * The full route tree output from the scanner (or the root of the\n * runtime route manifest, when `TFile = ManifestFile`).\n *\n * Generic so the same wrapper carries app-root metadata for both\n * shapes. The runtime manifest extends this with `viteRoot` (see\n * `ManifestRoot` in `server/route-matcher.ts`).\n */\nexport interface RouteTree<TFile = RouteFile> {\n  /** The root segment node (representing app/) */\n  root: SegmentNode<TFile>;\n  /** All discovered proxy.ts files (should be at most one, in app/) */\n  proxy?: TFile;\n  /**\n   * Global error page: app/global-error.{tsx,ts,jsx,js}\n   *\n   * Rendered as a standalone full-page replacement (no layout wrapping)\n   * when no segment-level error file is found. SSR-only render path.\n   * Must provide its own <html> and <body>.\n   *\n   * See design/10-error-handling.md §\"Tier 2 — Global Error Page\"\n   */\n  globalError?: TFile;\n}\n\n/** Configuration passed to the scanner */\nexport interface ScannerConfig {\n  /** Recognized page/layout extensions (without dots). Default: ['tsx', 'ts', 'jsx', 'js'] */\n  pageExtensions?: string[];\n}\n\n/** Default page extensions */\nexport const DEFAULT_PAGE_EXTENSIONS = ['tsx', 'ts', 'jsx', 'js'];\n","/**\n * Shared segment classifier — both URL tokens and filesystem directory names.\n *\n * `classifyUrlSegment(token)` is a pure single-pass character parser that\n * classifies a route segment token (e.g. \"dashboard\", \"[id]\", \"[...slug]\",\n * \"[[...path]]\") into a typed discriminated union. NO regex, NO Node.js-only\n * APIs — safe to import from browser code (used by `Link` interpolation).\n *\n * `classifySegment(dirName)` is the build-time directory-name classifier\n * used by the scanner. It recognizes timber-only conventions (private\n * `_*`, parallel `@*`, route groups `(name)`, intercepting routes\n * `(.)`/`(..)`/`(...)`/`(..)(..)`) and delegates bracket syntax to\n * `classifyUrlSegment`. It is the **single source of truth** for what\n * counts as a routing segment — there is no separate copy in the\n * scanner. (TIM-848.)\n *\n * Malformed input falls through to `{ kind: 'static' }` — the safe default.\n *\n * If you change the bracket syntax, update ONLY this file. Every\n * consumer imports from here.\n *\n * See design/07-routing.md §\"Route Segments\"\n */\n\nimport type { InterceptionMarker, SegmentType } from './types.ts';\nimport { INTERCEPTION_MARKERS } from './types.ts';\n\nexport type UrlSegment =\n  | { kind: 'static'; value: string }\n  | { kind: 'dynamic'; name: string; prefix?: string; suffix?: string }\n  | { kind: 'catch-all'; name: string }\n  | { kind: 'optional-catch-all'; name: string };\n\n/**\n * Classify a URL path segment token.\n *\n * Walks the string left-to-right in one pass:\n *   1. Find the first '[' — characters before it are the prefix.\n *   2. Count opening brackets (1 or 2) to detect optional.\n *   3. Check for '...' to detect catch-all.\n *   4. Read the param name up to the closing bracket.\n *   5. Validate the expected closing sequence (']' or ']]').\n *   6. Characters after the close are the suffix.\n *   7. Reject affixes on catch-all/optional-catch-all.\n *   8. Reject affixes that contain '[' or ']' (no multi-param segments).\n *\n * Any structural violation → static (safe default).\n */\nexport function classifyUrlSegment(token: string): UrlSegment {\n  const len = token.length;\n  if (len === 0) return { kind: 'static', value: token };\n\n  // Find first '[' — characters before it are the prefix\n  const bracketStart = token.indexOf('[');\n  if (bracketStart === -1) return { kind: 'static', value: token };\n\n  const prefix = token.slice(0, bracketStart);\n\n  let i = bracketStart + 1;\n\n  // Check for optional: '[[...'\n  const optional = i < len && token[i] === '[';\n  if (optional) i++;\n\n  // Check for catch-all: '...'\n  const catchAll = i + 2 < len && token[i] === '.' && token[i + 1] === '.' && token[i + 2] === '.';\n  if (catchAll) i += 3;\n\n  // Read param name — everything up to ']'\n  const nameStart = i;\n  while (i < len && token[i] !== ']') i++;\n\n  // Must have found a ']' and name must be non-empty\n  if (i >= len || i === nameStart) {\n    return { kind: 'static', value: token };\n  }\n\n  const name = token.slice(nameStart, i);\n  i++; // skip first ']'\n\n  // Optional requires a second ']'\n  if (optional) {\n    if (i >= len || token[i] !== ']') {\n      return { kind: 'static', value: token };\n    }\n    i++;\n  }\n\n  const suffix = token.slice(i);\n\n  // Reject affixes containing brackets (no multi-param segments like [foo]-[bar])\n  if (suffix.includes('[') || suffix.includes(']')) {\n    return { kind: 'static', value: token };\n  }\n  if (prefix.includes(']')) {\n    return { kind: 'static', value: token };\n  }\n\n  const hasAffixes = prefix.length > 0 || suffix.length > 0;\n\n  if (optional && catchAll) {\n    // No affixes on optional catch-all\n    if (hasAffixes) return { kind: 'static', value: token };\n    return { kind: 'optional-catch-all', name };\n  }\n  if (catchAll) {\n    // No affixes on catch-all\n    if (hasAffixes) return { kind: 'static', value: token };\n    return { kind: 'catch-all', name };\n  }\n  if (optional) {\n    // '[[name]]' without '...' is malformed — not a valid segment syntax\n    return { kind: 'static', value: token };\n  }\n\n  if (hasAffixes) {\n    return {\n      kind: 'dynamic',\n      name,\n      prefix: prefix || undefined,\n      suffix: suffix || undefined,\n    };\n  }\n  return { kind: 'dynamic', name };\n}\n\n// ─── Directory-name classifier (build-time scanner) ─────────────────────────\n\n/** Result of classifying a filesystem directory name. */\nexport interface SegmentClassification {\n  type: SegmentType;\n  paramName?: string;\n  paramPrefix?: string;\n  paramSuffix?: string;\n  interceptionMarker?: InterceptionMarker;\n  interceptedSegmentName?: string;\n}\n\n/**\n * Classify a directory name into its segment type.\n *\n * Recognizes all timber file-system conventions in priority order:\n *   1. Private folders: `_name` (excluded from routing)\n *   2. Parallel route slots: `@name`\n *   3. Intercepting routes: `(.)name`, `(..)name`, `(...)name`, `(..)(..)name`\n *   4. Route groups: `(name)`\n *   5. Bracket syntax: `[id]`, `[...slug]`, `[[...path]]` (delegated to\n *      `classifyUrlSegment`)\n *   6. Static: anything else\n *\n * If you change the bracket syntax, update only `classifyUrlSegment`.\n * If you change the directory-prefix conventions, update this function.\n */\nexport function classifySegment(dirName: string): SegmentClassification {\n  // Private folder: _name (excluded from routing)\n  if (dirName.startsWith('_')) {\n    return { type: 'private' };\n  }\n\n  // Parallel route slot: @name\n  if (dirName.startsWith('@')) {\n    return { type: 'slot' };\n  }\n\n  // Intercepting routes: (.)name, (..)name, (...)name, (..)(..)name\n  // Check before route groups since intercepting markers also start with (\n  const interception = parseInterceptionMarker(dirName);\n  if (interception) {\n    return {\n      type: 'intercepting',\n      interceptionMarker: interception.marker,\n      interceptedSegmentName: interception.segmentName,\n    };\n  }\n\n  // Route group: (name)\n  if (dirName.startsWith('(') && dirName.endsWith(')')) {\n    return { type: 'group' };\n  }\n\n  // Bracket-syntax segments: [param], [...param], [[...param]]\n  const urlSeg = classifyUrlSegment(dirName);\n  if (urlSeg.kind !== 'static') {\n    const result: SegmentClassification = { type: urlSeg.kind, paramName: urlSeg.name };\n    if (urlSeg.kind === 'dynamic') {\n      if (urlSeg.prefix) result.paramPrefix = urlSeg.prefix;\n      if (urlSeg.suffix) result.paramSuffix = urlSeg.suffix;\n    }\n    return result;\n  }\n\n  return { type: 'static' };\n}\n\n/**\n * The URL-matching identity of a segment node.\n *\n * For every node except an intercepting one this is the node itself. An\n * intercepting node is different: its directory name carries a marker\n * (`(.)photo`, `(.)[id]`), so the node's own `segmentType` is\n * `'intercepting'` and the bracket syntax of the segment it intercepts was\n * never classified. Everything that has to reason about *the URL part this\n * node stands for* — matching it, and keying its param for codec coercion —\n * needs that classification.\n *\n * Deriving it here, from `interceptedSegmentName`, keeps interception out\n * of `classifySegment`'s output and out of the serialized manifest: there\n * is no second copy of the classification to drift from this one. The\n * returned `segmentName` is the intercepted name (`photo`, `[id]`), NOT the\n * node's directory name — callers that need the directory name for tree\n * paths must keep reading the node. See TIM-1281.\n */\nexport interface UrlSegmentIdentity {\n  segmentName: string;\n  segmentType: SegmentType;\n  paramName?: string;\n  paramPrefix?: string;\n  paramSuffix?: string;\n}\n\nexport function effectiveUrlSegment(node: {\n  segmentName: string;\n  segmentType: SegmentType;\n  paramName?: string;\n  paramPrefix?: string;\n  paramSuffix?: string;\n  interceptedSegmentName?: string;\n}): UrlSegmentIdentity {\n  if (node.segmentType !== 'intercepting' || !node.interceptedSegmentName) {\n    return {\n      segmentName: node.segmentName,\n      segmentType: node.segmentType,\n      paramName: node.paramName,\n      paramPrefix: node.paramPrefix,\n      paramSuffix: node.paramSuffix,\n    };\n  }\n\n  const seg = classifyUrlSegment(node.interceptedSegmentName);\n  if (seg.kind === 'static') {\n    return { segmentName: seg.value, segmentType: 'static' };\n  }\n  return {\n    segmentName: node.interceptedSegmentName,\n    segmentType: seg.kind,\n    paramName: seg.name,\n    paramPrefix: seg.kind === 'dynamic' ? seg.prefix : undefined,\n    paramSuffix: seg.kind === 'dynamic' ? seg.suffix : undefined,\n  };\n}\n\n/**\n * Parse an interception marker from a directory name.\n *\n * Returns the marker and the remaining segment name, or null if not an\n * intercepting route. Markers are checked longest-first to avoid `(..)`\n * matching before `(..)(..)`.\n *\n * Examples:\n *   \"(.)photo\"      → { marker: \"(.)\", segmentName: \"photo\" }\n *   \"(..)feed\"      → { marker: \"(..)\", segmentName: \"feed\" }\n *   \"(...)photos\"   → { marker: \"(...)\", segmentName: \"photos\" }\n *   \"(..)(..)admin\" → { marker: \"(..)(..)\", segmentName: \"admin\" }\n *   \"(marketing)\"   → null (route group, not interception)\n */\nfunction parseInterceptionMarker(\n  dirName: string\n): { marker: InterceptionMarker; segmentName: string } | null {\n  for (const marker of INTERCEPTION_MARKERS) {\n    if (dirName.startsWith(marker)) {\n      const rest = dirName.slice(marker.length);\n      // Must have a segment name after the marker, and the rest must not\n      // be empty or end with ) (which would be a route group like \"(auth)\")\n      if (rest.length > 0 && !rest.endsWith(')')) {\n        return { marker, segmentName: rest };\n      }\n    }\n  }\n  return null;\n}\n"],"mappings":"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"}

package/dist/_chunks/segment-context-D9_89u34.js

@@ -0,0 +1,34 @@
+import { createContext, createElement, useContext, useMemo } from "react";
+//#region src/client/segment-context.ts
+/**
+* Segment Context — provides layout segment position for useSelectedLayoutSegment hooks.
+*
+* Each layout in the segment tree is wrapped with a SegmentProvider that stores
+* the URL segments from root to the current layout level. The hooks read this
+* context to determine which child segments are active below the calling layout.
+*
+* The context value is intentionally minimal: just the segment path array and
+* parallel route keys. No internal cache details are exposed.
+*
+* Design docs: design/19-client-navigation.md, design/14-ecosystem.md
+*/
+var SegmentContext = createContext(null);
+/** Read the segment context. Returns null if no provider is above this component. */
+function useSegmentContext() {
+	return useContext(SegmentContext);
+}
+/**
+* Wraps each layout to provide segment position context.
+* Injected by rsc-entry.ts during element tree construction.
+*/
+function SegmentProvider({ segments, segmentId: _segmentId, parallelRouteKeys, children }) {
+	const value = useMemo(() => ({
+		segments,
+		parallelRouteKeys
+	}), [segments, parallelRouteKeys]);
+	return createElement(SegmentContext.Provider, { value }, children);
+}
+//#endregion
+export { useSegmentContext as n, SegmentProvider as t };
+
+//# sourceMappingURL=segment-context-D9_89u34.js.map

package/dist/_chunks/segment-context-D9_89u34.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment-context-D9_89u34.js","names":[],"sources":["../../src/client/segment-context.ts"],"sourcesContent":["/**\n * Segment Context — provides layout segment position for useSelectedLayoutSegment hooks.\n *\n * Each layout in the segment tree is wrapped with a SegmentProvider that stores\n * the URL segments from root to the current layout level. The hooks read this\n * context to determine which child segments are active below the calling layout.\n *\n * The context value is intentionally minimal: just the segment path array and\n * parallel route keys. No internal cache details are exposed.\n *\n * Design docs: design/19-client-navigation.md, design/14-ecosystem.md\n */\n\n'use client';\n\nimport { createContext, useContext, createElement, useMemo } from 'react';\n\n// ─── Types ───────────────────────────────────────────────────────\n\nexport interface SegmentContextValue {\n  /** URL segments from root to this layout (e.g. ['', 'dashboard', 'settings']) */\n  segments: string[];\n  /** Parallel route slot keys available at this layout level (e.g. ['sidebar', 'modal']) */\n  parallelRouteKeys: string[];\n}\n\n// ─── Context ─────────────────────────────────────────────────────\n\nconst SegmentContext = createContext<SegmentContextValue | null>(null);\n\n/** Read the segment context. Returns null if no provider is above this component. */\nexport function useSegmentContext(): SegmentContextValue | null {\n  return useContext(SegmentContext);\n}\n\n// ─── Provider ────────────────────────────────────────────────────\n\ninterface SegmentProviderProps {\n  segments: string[];\n  /**\n   * Unique identifier for this segment, used by the client-side segment\n   * merger for element caching. For route groups this includes the group\n   * name (e.g., \"/(marketing)\") since groups share their parent's urlPath.\n   * Falls back to the reconstructed path from `segments` if not provided.\n   */\n  segmentId?: string;\n  parallelRouteKeys: string[];\n  children: React.ReactNode;\n}\n\n/**\n * Wraps each layout to provide segment position context.\n * Injected by rsc-entry.ts during element tree construction.\n */\nexport function SegmentProvider({\n  segments,\n  segmentId: _segmentId,\n  parallelRouteKeys,\n  children,\n}: SegmentProviderProps) {\n  const value = useMemo(\n    () => ({ segments, parallelRouteKeys }),\n    // segments and parallelRouteKeys are static per layout — the layout's\n    // position in the tree is fixed. The arrays are used directly as deps\n    // (React Compiler requires simple expressions here). Referential stability\n    // of the context value doesn't matter: every consumer\n    // (useSelectedLayoutSegment/useSelectedLayoutSegments) also calls\n    // usePathname(), so it re-renders on every navigation regardless.\n    [segments, parallelRouteKeys]\n  );\n  return createElement(SegmentContext.Provider, { value }, children);\n}\n"],"mappings":";;;;;;;;;;;;;;AA4BA,IAAM,iBAAiB,cAA0C,IAAI;;AAGrE,SAAgB,oBAAgD;CAC9D,OAAO,WAAW,cAAc;AAClC;;;;;AAqBA,SAAgB,gBAAgB,EAC9B,UACA,WAAW,YACX,mBACA,YACuB;CACvB,MAAM,QAAQ,eACL;EAAE;EAAU;CAAkB,IAOrC,CAAC,UAAU,iBAAiB,CAC9B;CACA,OAAO,cAAc,eAAe,UAAU,EAAE,MAAM,GAAG,QAAQ;AACnE"}

package/dist/_chunks/segment-keys-D5hu1hz4.js

@@ -0,0 +1,62 @@
+//#region src/routing/segment-keys.ts
+/**
+* Compute tree paths for a segment chain — the directory path of each segment
+* with slots elided, e.g. `app/(browse)/feed` → `/(browse)/feed`.
+*
+* This is `computeSegmentKeys` with the group branch applied to *every*
+* segment rather than only to groups. That one difference is the whole point:
+* `computeSegmentKeys` resets to `urlPath` at each URL-visible segment, so
+* `(browse)/feed` and `(landing)/feed` both key as `/feed`. Two directories
+* that render different layouts must not share an identity.
+*
+* Used for interception scoping (`routing/interception.ts`), where the
+* question is "does this route pass through *that* directory?" — not "does it
+* render this URL?". Not interchangeable with `computeSegmentKeys`: the state
+* tree is keyed by URL on purpose, because the client caches by URL.
+*/
+function computeSegmentTreePaths(segments) {
+	const paths = [];
+	let prev = "";
+	for (const segment of segments) {
+		const name = segment.segmentName ?? "";
+		if (!name) {
+			paths.push("/");
+			prev = "/";
+			continue;
+		}
+		const path = `${prev === "/" ? "" : prev}/${name}`;
+		paths.push(path);
+		prev = path;
+	}
+	return paths;
+}
+/**
+* The directory names a tree path is built from — `/` is none, `/feed/(a)` is
+* `['feed', '(a)']`.
+*
+* The inverse of the walk above, and it lives beside it so the format is
+* stated once: `findChainByTreePath` (`server/children-interception.ts`) walks
+* these names back down the tree to the directory the path addresses, and
+* `treePathDepth` counts them. Both are readings of the same string, and a
+* reader that disagreed with the producer about what separates two names
+* resolves an interception to the wrong node or to none.
+*/
+function treePathNames(treePath) {
+	return treePath === "/" ? [] : treePath.slice(1).split("/");
+}
+/**
+* How many directories a tree path names — `/` is 0, `/feed` is 1,
+* `/feed/(a)` is 2.
+*
+* Two tree paths on a single rendered chain are strictly nested, so on that
+* chain depth orders them totally — which is what makes it usable as "the
+* deeper of these two directories" wherever a route passes through both
+* (`routing/interception.ts`).
+*/
+function treePathDepth(treePath) {
+	return treePathNames(treePath).length;
+}
+//#endregion
+export { treePathDepth as n, computeSegmentTreePaths as t };
+
+//# sourceMappingURL=segment-keys-D5hu1hz4.js.map

package/dist/_chunks/segment-keys-D5hu1hz4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment-keys-D5hu1hz4.js","names":[],"sources":["../../src/routing/segment-keys.ts"],"sourcesContent":["/**\n * Segment key computation — the stable identity of a segment in the route tree.\n *\n * A segment key is the string that names a segment across the RSC/SSR/client\n * boundary: it appears in the X-Timber-State-Tree header, the X-Timber-Segments\n * header, SegmentOutlet props, the client segment cache, and (since TIM-1279)\n * interception scoping.\n *\n * This module lives in `routing/` rather than `server/` because the keys are a\n * property of the route tree itself — both the build-time scanner tree and the\n * runtime manifest tree produce identical keys for the same directory, which is\n * what lets a build-time value (an interception scope) be compared against a\n * request-time matched chain.\n *\n * See design/19-client-navigation.md §\"X-Timber-State-Tree Header\"\n */\n\n/**\n * Segment node shape expected by computeSegmentKeys.\n *\n * Structurally satisfied by both `SegmentNode` (build time) and\n * `ManifestSegmentNode` (request time) — keys depend only on the\n * URL path and the segment classification, never on file payloads.\n */\n\nimport type { CoercedParams } from '../shared/param-value.ts';\n\nexport interface SegmentKeyInput {\n  urlPath: string;\n  segmentName?: string;\n  segmentType?: string;\n}\n\n/**\n * Compute state-tree keys for a segment chain.\n *\n * Non-group segments use their urlPath as-is. Route groups accumulate\n * ancestor group names to produce globally unique keys:\n *   app/(a)/(shared)/dashboard → keys: ['/', '/(a)', '/(a)/(shared)', '/dashboard']\n *\n * **An intercepting segment switches the chain to name accumulation for good.**\n * A children-path interception (TIM-1280) puts an intercepting node and its\n * descendants into the *main* rendered chain, and their `urlPath`s are not\n * URLs: interception adds no URL depth, so `app/(browse)/(...)[artistSlug]/[year]`\n * carries `/` and `/[year]`. Keyed by urlPath the intercepting node would\n * collide with its own owner, and `[year]` with any top-level `[year]` route —\n * so a client that had one mounted would reuse the wrong cached layout. The\n * switch is sticky rather than per-node because the *descendants* are where\n * the false URLs are; the intercepting node alone is not the problem.\n *\n * This is the single source of truth for segment keys — used by the\n * element builder (skip decisions, SegmentOutlet props), segment info\n * (X-Timber-Segments header), the client cache/state tree, and\n * interception scoping (`routing/interception.ts`).\n */\nexport function computeSegmentKeys(segments: SegmentKeyInput[]): string[] {\n  const keys: string[] = [];\n  let prevKey = '';\n  let insideIntercepting = false;\n\n  for (const segment of segments) {\n    if (segment.segmentType === 'intercepting') insideIntercepting = true;\n    if (segment.segmentType === 'group' || insideIntercepting) {\n      const base = prevKey === '/' ? '' : prevKey;\n      const key = `${base}/${segment.segmentName}`;\n      keys.push(key);\n      prevKey = key;\n    } else {\n      keys.push(segment.urlPath);\n      prevKey = segment.urlPath;\n    }\n  }\n\n  return keys;\n}\n\n/**\n * Compute tree paths for a segment chain — the directory path of each segment\n * with slots elided, e.g. `app/(browse)/feed` → `/(browse)/feed`.\n *\n * This is `computeSegmentKeys` with the group branch applied to *every*\n * segment rather than only to groups. That one difference is the whole point:\n * `computeSegmentKeys` resets to `urlPath` at each URL-visible segment, so\n * `(browse)/feed` and `(landing)/feed` both key as `/feed`. Two directories\n * that render different layouts must not share an identity.\n *\n * Used for interception scoping (`routing/interception.ts`), where the\n * question is \"does this route pass through *that* directory?\" — not \"does it\n * render this URL?\". Not interchangeable with `computeSegmentKeys`: the state\n * tree is keyed by URL on purpose, because the client caches by URL.\n */\nexport function computeSegmentTreePaths(segments: SegmentKeyInput[]): string[] {\n  const paths: string[] = [];\n  let prev = '';\n\n  for (const segment of segments) {\n    const name = segment.segmentName ?? '';\n    if (!name) {\n      // The app root — no directory name of its own.\n      paths.push('/');\n      prev = '/';\n      continue;\n    }\n    const base = prev === '/' ? '' : prev;\n    const path = `${base}/${name}`;\n    paths.push(path);\n    prev = path;\n  }\n\n  return paths;\n}\n\n/**\n * The directory names a tree path is built from — `/` is none, `/feed/(a)` is\n * `['feed', '(a)']`.\n *\n * The inverse of the walk above, and it lives beside it so the format is\n * stated once: `findChainByTreePath` (`server/children-interception.ts`) walks\n * these names back down the tree to the directory the path addresses, and\n * `treePathDepth` counts them. Both are readings of the same string, and a\n * reader that disagreed with the producer about what separates two names\n * resolves an interception to the wrong node or to none.\n */\nexport function treePathNames(treePath: string): string[] {\n  return treePath === '/' ? [] : treePath.slice(1).split('/');\n}\n\n/**\n * How many directories a tree path names — `/` is 0, `/feed` is 1,\n * `/feed/(a)` is 2.\n *\n * Two tree paths on a single rendered chain are strictly nested, so on that\n * chain depth orders them totally — which is what makes it usable as \"the\n * deeper of these two directories\" wherever a route passes through both\n * (`routing/interception.ts`).\n */\nexport function treePathDepth(treePath: string): number {\n  return treePathNames(treePath).length;\n}\n\n/**\n * Compute a unique key for a parallel route slot.\n * Format: `{parentSegmentId}/@{slotName}`, e.g. `/@sidebar` or `/dashboard/@modal`.\n */\nexport function computeSlotKey(parentSegmentId: string, slotName: string): string {\n  const name = slotName.startsWith('@') ? slotName : `@${slotName}`;\n  const prefix = parentSegmentId === '/' ? '' : parentSegmentId;\n  return `${prefix}/${name}`;\n}\n\n/**\n * Compute a content key for a parallel route slot.\n *\n * The content key encodes everything that determines the slot's rendered\n * output for a given navigation: the slot key (which includes the owning\n * segment's identity and the slot name), the URL parts consumed by the\n * owning segment (which determine parent params the slot page might\n * read), the matched page file (or a sentinel for `default.tsx`), and\n * the slot's own extracted params.\n *\n * The slot key prevents cross-group collisions: two route groups at the\n * same URL level each owning a `@sidebar` slot produce different keys\n * even when both fall back to `default.tsx`.\n *\n * The key is opaque to the client — it stores whatever the server sent\n * and advertises it back. The server computes the destination key and\n * checks membership. This eliminates the need for the server to\n * reconstruct the client's state from a departing URL.\n *\n * See design/07-routing.md §\"Segment Tree Diffing on Navigation\"\n */\nexport function computeSlotContentKey(\n  slotKey: string,\n  ownerParts: string[],\n  entryFile: string | null,\n  slotParams: CoercedParams\n): string {\n  const owner = ownerParts.join('/');\n  const entry = entryFile ?? '\\x01';\n  const paramKeys = Object.keys(slotParams).sort();\n  const paramParts = paramKeys.map((k) => {\n    const v = slotParams[k];\n    return Array.isArray(v) ? `${k}=${v.map(String).join('\\x02')}` : `${k}=${String(v)}`;\n  });\n  return [slotKey, owner, entry, ...paramParts].join('\\0');\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA2FA,SAAgB,wBAAwB,UAAuC;CAC7E,MAAM,QAAkB,CAAC;CACzB,IAAI,OAAO;CAEX,KAAK,MAAM,WAAW,UAAU;EAC9B,MAAM,OAAO,QAAQ,eAAe;EACpC,IAAI,CAAC,MAAM;GAET,MAAM,KAAK,GAAG;GACd,OAAO;GACP;EACF;EAEA,MAAM,OAAO,GADA,SAAS,MAAM,KAAK,KACZ,GAAG;EACxB,MAAM,KAAK,IAAI;EACf,OAAO;CACT;CAEA,OAAO;AACT;;;;;;;;;;;;AAaA,SAAgB,cAAc,UAA4B;CACxD,OAAO,aAAa,MAAM,CAAC,IAAI,SAAS,MAAM,CAAC,CAAC,CAAC,MAAM,GAAG;AAC5D;;;;;;;;;;AAWA,SAAgB,cAAc,UAA0B;CACtD,OAAO,cAAc,QAAQ,CAAC,CAAC;AACjC"}

package/dist/_chunks/singleflight-2lUWfcAk.js

@@ -0,0 +1,54 @@
+//#region src/cache/singleflight.ts
+/**
+* Error thrown when a singleflight call exceeds `timeoutMs`.
+* Exported so callers can distinguish timeout from other errors.
+*/
+var SingleflightTimeoutError = class extends Error {
+	constructor(key, timeoutMs) {
+		super(`Singleflight timeout: key "${key}" exceeded ${timeoutMs}ms`);
+		this.name = "SingleflightTimeoutError";
+	}
+};
+function createSingleflight(opts) {
+	const inflight = /* @__PURE__ */ new Map();
+	const timeoutMs = opts?.timeoutMs;
+	return {
+		do(key, fn) {
+			const existing = inflight.get(key);
+			if (existing) return existing;
+			const ac = new AbortController();
+			let promise;
+			if (timeoutMs != null && timeoutMs > 0) promise = new Promise((resolve, reject) => {
+				const timer = setTimeout(() => {
+					ac.abort();
+					reject(new SingleflightTimeoutError(key, timeoutMs));
+				}, timeoutMs);
+				try {
+					fn(ac.signal).then((value) => {
+						clearTimeout(timer);
+						resolve(value);
+					}, (err) => {
+						clearTimeout(timer);
+						reject(err);
+					});
+				} catch (err) {
+					clearTimeout(timer);
+					reject(err);
+				}
+			});
+			else promise = fn(ac.signal);
+			const tracked = promise.finally(() => {
+				inflight.delete(key);
+			});
+			inflight.set(key, tracked);
+			return tracked;
+		},
+		get(key) {
+			return inflight.get(key);
+		}
+	};
+}
+//#endregion
+export { createSingleflight as n, SingleflightTimeoutError as t };
+
+//# sourceMappingURL=singleflight-2lUWfcAk.js.map

package/dist/_chunks/singleflight-2lUWfcAk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleflight-2lUWfcAk.js","names":[],"sources":["../../src/cache/singleflight.ts"],"sourcesContent":["/**\n * Singleflight coalesces concurrent calls with the same key into a single\n * execution. All callers receive the same result (or error).\n *\n * Per-process, in-memory. Each process coalesces independently.\n *\n * An optional `timeoutMs` prevents hung `fn()` calls from permanently\n * blocking all future callers for that key. When set, `fn()` is raced\n * against a timeout — if the timeout fires first, the promise rejects\n * with `SingleflightTimeoutError`, `finally` cleans up the key, and\n * subsequent callers can retry. See TIM-518.\n */\n\nexport interface SingleflightOptions {\n  /** Maximum time (ms) a coalesced call may run before being rejected. */\n  timeoutMs?: number;\n}\n\nexport interface Singleflight {\n  do<T>(key: string, fn: (signal: AbortSignal) => Promise<T>): Promise<T>;\n  /** Return the in-flight promise for a key, or undefined if none. */\n  get(key: string): Promise<unknown> | undefined;\n}\n\n/**\n * Error thrown when a singleflight call exceeds `timeoutMs`.\n * Exported so callers can distinguish timeout from other errors.\n */\nexport class SingleflightTimeoutError extends Error {\n  constructor(key: string, timeoutMs: number) {\n    super(`Singleflight timeout: key \"${key}\" exceeded ${timeoutMs}ms`);\n    this.name = 'SingleflightTimeoutError';\n  }\n}\n\nexport function createSingleflight(opts?: SingleflightOptions): Singleflight {\n  const inflight = new Map<string, Promise<unknown>>();\n  const timeoutMs = opts?.timeoutMs;\n\n  return {\n    do<T>(key: string, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {\n      const existing = inflight.get(key);\n      if (existing) return existing as Promise<T>;\n\n      const ac = new AbortController();\n      let promise: Promise<T>;\n\n      if (timeoutMs != null && timeoutMs > 0) {\n        // Race fn() against a timeout to prevent hung calls from\n        // permanently blocking the key. See TIM-518.\n        // Abort the signal on timeout so the callback can skip\n        // side effects (e.g. cache writes). See TIM-1092.\n        promise = new Promise<T>((resolve, reject) => {\n          const timer = setTimeout(() => {\n            ac.abort();\n            reject(new SingleflightTimeoutError(key, timeoutMs));\n          }, timeoutMs);\n          try {\n            fn(ac.signal).then(\n              (value) => {\n                clearTimeout(timer);\n                resolve(value);\n              },\n              (err) => {\n                clearTimeout(timer);\n                reject(err);\n              }\n            );\n          } catch (err) {\n            clearTimeout(timer);\n            reject(err);\n          }\n        });\n      } else {\n        promise = fn(ac.signal);\n      }\n\n      const tracked = promise.finally(() => {\n        inflight.delete(key);\n      });\n\n      inflight.set(key, tracked);\n      return tracked as Promise<T>;\n    },\n    get(key: string): Promise<unknown> | undefined {\n      return inflight.get(key);\n    },\n  };\n}\n"],"mappings":";;;;;AA4BA,IAAa,2BAAb,cAA8C,MAAM;CAClD,YAAY,KAAa,WAAmB;EAC1C,MAAM,8BAA8B,IAAI,aAAa,UAAU,GAAG;EAClE,KAAK,OAAO;CACd;AACF;AAEA,SAAgB,mBAAmB,MAA0C;CAC3E,MAAM,2BAAW,IAAI,IAA8B;CACnD,MAAM,YAAY,MAAM;CAExB,OAAO;EACL,GAAM,KAAa,IAAqD;GACtE,MAAM,WAAW,SAAS,IAAI,GAAG;GACjC,IAAI,UAAU,OAAO;GAErB,MAAM,KAAK,IAAI,gBAAgB;GAC/B,IAAI;GAEJ,IAAI,aAAa,QAAQ,YAAY,GAKnC,UAAU,IAAI,SAAY,SAAS,WAAW;IAC5C,MAAM,QAAQ,iBAAiB;KAC7B,GAAG,MAAM;KACT,OAAO,IAAI,yBAAyB,KAAK,SAAS,CAAC;IACrD,GAAG,SAAS;IACZ,IAAI;KACF,GAAG,GAAG,MAAM,CAAC,CAAC,MACX,UAAU;MACT,aAAa,KAAK;MAClB,QAAQ,KAAK;KACf,IACC,QAAQ;MACP,aAAa,KAAK;MAClB,OAAO,GAAG;KACZ,CACF;IACF,SAAS,KAAK;KACZ,aAAa,KAAK;KAClB,OAAO,GAAG;IACZ;GACF,CAAC;QAED,UAAU,GAAG,GAAG,MAAM;GAGxB,MAAM,UAAU,QAAQ,cAAc;IACpC,SAAS,OAAO,GAAG;GACrB,CAAC;GAED,SAAS,IAAI,KAAK,OAAO;GACzB,OAAO;EACT;EACA,IAAI,KAA2C;GAC7C,OAAO,SAAS,IAAI,GAAG;EACzB;CACF;AACF"}

package/dist/_chunks/sizeof-lXffQ1Vr.js

@@ -0,0 +1,35 @@
+//#region src/cache/sizeof.ts
+/**
+* Lightweight byte-size estimation for cache entries.
+*
+* Estimates the in-memory byte cost of a JavaScript value using
+* JSON.stringify().length * 2 (UTF-16 char width). This is a rough
+* approximation — it doesn't account for V8 object overhead, Map
+* metadata, or non-serializable values — but it's fast and good
+* enough for cache budget enforcement.
+*
+* Values that fail JSON serialization (circular references, BigInt,
+* etc.) return 0, allowing the entry to be cached without counting
+* toward the byte budget. This is a conservative choice: it's better
+* to cache and undercount than to reject the entry.
+*/
+/**
+* Estimate the byte size of a value.
+*
+* Uses `JSON.stringify(value).length * 2` to approximate UTF-16
+* in-memory size. Returns 0 if the value is not serializable.
+*/
+function estimateByteSize(value) {
+	try {
+		const json = JSON.stringify(value);
+		if (json === void 0) return 0;
+		return json.length * 2;
+	} catch (e) {
+		console.debug("[timber] sizeof estimation failed:", e instanceof Error ? e.message : e);
+		return 0;
+	}
+}
+//#endregion
+export { estimateByteSize as t };
+
+//# sourceMappingURL=sizeof-lXffQ1Vr.js.map

package/dist/_chunks/sizeof-lXffQ1Vr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sizeof-lXffQ1Vr.js","names":[],"sources":["../../src/cache/sizeof.ts"],"sourcesContent":["/**\n * Lightweight byte-size estimation for cache entries.\n *\n * Estimates the in-memory byte cost of a JavaScript value using\n * JSON.stringify().length * 2 (UTF-16 char width). This is a rough\n * approximation — it doesn't account for V8 object overhead, Map\n * metadata, or non-serializable values — but it's fast and good\n * enough for cache budget enforcement.\n *\n * Values that fail JSON serialization (circular references, BigInt,\n * etc.) return 0, allowing the entry to be cached without counting\n * toward the byte budget. This is a conservative choice: it's better\n * to cache and undercount than to reject the entry.\n */\n\n/**\n * Estimate the byte size of a value.\n *\n * Uses `JSON.stringify(value).length * 2` to approximate UTF-16\n * in-memory size. Returns 0 if the value is not serializable.\n */\nexport function estimateByteSize(value: unknown): number {\n  try {\n    const json = JSON.stringify(value);\n    if (json === undefined) return 0;\n    // Each JS string character is 2 bytes (UTF-16)\n    return json.length * 2;\n  } catch (e) {\n    // Circular reference or non-serializable value\n    console.debug('[timber] sizeof estimation failed:', e instanceof Error ? e.message : e);\n    return 0;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,iBAAiB,OAAwB;CACvD,IAAI;EACF,MAAM,OAAO,KAAK,UAAU,KAAK;EACjC,IAAI,SAAS,KAAA,GAAW,OAAO;EAE/B,OAAO,KAAK,SAAS;CACvB,SAAS,GAAG;EAEV,QAAQ,MAAM,sCAAsC,aAAa,QAAQ,EAAE,UAAU,CAAC;EACtF,OAAO;CACT;AACF"}

package/dist/_chunks/{ssr-data-MjmprTmO.js → ssr-data-D6T6Y3ef.js}

@@ -1,32 +1,4 @@
-//#region src/client/state.ts
-/** The global router singleton — set once during bootstrap. */
-var globalRouter = null;
-function _setGlobalRouter(router) {
-	globalRouter = router;
-}
-/**
-* ALS-backed SSR data provider. When registered, getSsrData() reads from
-* this function (ALS store) instead of module-level currentSsrData.
-*/
-var ssrDataProvider;
-/** Fallback SSR data for tests and environments without ALS. */
-var currentSsrData;
-function _setCurrentSsrData(data) {
-	currentSsrData = data;
-}
-/** Current route params snapshot — replaced (not mutated) on each navigation. */
-var currentParams = {};
-function _setCurrentParams(params) {
-	currentParams = params;
-}
-/** Cached search string — avoids reparsing when URL hasn't changed. */
-var cachedSearch = "";
-var cachedSearchParams = new URLSearchParams();
-function _setCachedSearch(search, params) {
-	cachedSearch = search;
-	cachedSearchParams = params;
-}
-//#endregion
+import { f as ssrDataProvider, l as currentSsrData, n as _setCurrentSsrData } from "./state-FippDgxN.js";
 //#region src/client/ssr-data.ts
 /**
 * SSR Data — per-request state for client hooks during server-side rendering.
@@ -83,6 +55,6 @@ function getSsrData() {
 	return currentSsrData;
 }
 //#endregion
-export { _setCurrentParams as a, cachedSearchParams as c, _setCachedSearch as i, currentParams as l, getSsrData as n, _setGlobalRouter as o, setSsrData as r, cachedSearch as s, clearSsrData as t, globalRouter as u };
+export { getSsrData as n, setSsrData as r, clearSsrData as t };
 
-//# sourceMappingURL=ssr-data-MjmprTmO.js.map
+//# sourceMappingURL=ssr-data-D6T6Y3ef.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ssr-data-D6T6Y3ef.js","names":[],"sources":["../../src/client/ssr-data.ts"],"sourcesContent":["/**\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  /**\n   * The request's raw app-visible query string (`''` or `?…`), matching what\n   * `window.location.search` will hold after hydration. The raw string is\n   * the only representation carried here: it preserves repeated keys\n   * (`?tag=a&tag=b`), which a collapsed `Record<string, string>` cannot\n   * (TIM-1428). Parse with `new URLSearchParams(search)` where needed.\n   */\n  search: 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8GA,SAAgB,WAAW,MAAqB;CAC9C,mBAAmB,IAAI;AACzB;;;;;;;AAQA,SAAgB,eAAqB;CACnC,mBAAmB,KAAA,CAAS;AAC9B;;;;;;;;;;AAWA,SAAgB,aAAkC;CAChD,IAAI,iBACF,OAAO,gBAAgB;CAEzB,OAAO;AACT"}

package/dist/_chunks/state-FippDgxN.js

@@ -0,0 +1,52 @@
+//#region src/client/state.ts
+/** The global router singleton — set once during bootstrap. */
+var globalRouter = null;
+function _setGlobalRouter(router) {
+	globalRouter = router;
+}
+/**
+* ALS-backed SSR data provider. When registered, getSsrData() reads from
+* this function (ALS store) instead of module-level currentSsrData.
+*/
+var ssrDataProvider;
+/** Fallback SSR data for tests and environments without ALS. */
+var currentSsrData;
+function _setCurrentSsrData(data) {
+	currentSsrData = data;
+}
+/** Cached search string — avoids reparsing when URL hasn't changed. */
+var cachedSearch = "";
+var cachedSearchParams = new URLSearchParams();
+function _setCachedSearch(search, params) {
+	cachedSearch = search;
+	cachedSearchParams = params;
+}
+/** Whether the page is currently being unloaded. */
+var unloading = false;
+function _setUnloading(value) {
+	unloading = value;
+}
+/**
+* Whether a status page for the main route has rendered since the last
+* navigation was prepared. Raised by `StatusPageMarker`, consumed by the
+* navigation's commit. See navigation-commit.ts §"What a status page
+* teaches the cache".
+*/
+var statusPageRendered = false;
+function _setStatusPageRendered(value) {
+	statusPageRendered = value;
+}
+/**
+* What a status page report does beyond raising the flag: registered by the
+* router's committer so the report can clear the segment cache at once, for
+* the commits no navigation consumes (a row arriving inside Suspense after
+* its navigation published, a status document being hydrated).
+*/
+var onStatusPageRendered;
+function _setOnStatusPageRendered(handler) {
+	onStatusPageRendered = handler;
+}
+//#endregion
+export { _setStatusPageRendered as a, cachedSearchParams as c, onStatusPageRendered as d, ssrDataProvider as f, _setOnStatusPageRendered as i, currentSsrData as l, unloading as m, _setCurrentSsrData as n, _setUnloading as o, statusPageRendered as p, _setGlobalRouter as r, cachedSearch as s, _setCachedSearch as t, globalRouter as u };
+
+//# sourceMappingURL=state-FippDgxN.js.map

package/dist/_chunks/state-FippDgxN.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-FippDgxN.js","names":[],"sources":["../../src/client/state.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 { 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// ─── 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// ─── Status Page Commit Flag (from navigation-commit.ts) ────────────────────\n\n/**\n * Whether a status page for the main route has rendered since the last\n * navigation was prepared. Raised by `StatusPageMarker`, consumed by the\n * navigation's commit. See navigation-commit.ts §\"What a status page\n * teaches the cache\".\n */\nexport let statusPageRendered = false;\n\nexport function _setStatusPageRendered(value: boolean): void {\n  statusPageRendered = value;\n}\n\n/**\n * What a status page report does beyond raising the flag: registered by the\n * router's committer so the report can clear the segment cache at once, for\n * the commits no navigation consumes (a row arriving inside Suspense after\n * its navigation published, a status document being hydrated).\n */\nexport let onStatusPageRendered: (() => void) | undefined;\n\nexport function _setOnStatusPageRendered(handler: (() => void) | undefined): void {\n  onStatusPageRendered = handler;\n}\n"],"mappings":";;AA2BA,IAAW,eAAsC;AAEjD,SAAgB,iBAAiB,QAAqC;CACpE,eAAe;AACjB;;;;;AAQA,IAAW;;AAOX,IAAW;AAEX,SAAgB,mBAAmB,MAAiC;CAClE,iBAAiB;AACnB;;AAKA,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;;;;;;;AAUA,IAAW,qBAAqB;AAEhC,SAAgB,uBAAuB,OAAsB;CAC3D,qBAAqB;AACvB;;;;;;;AAQA,IAAW;AAEX,SAAgB,yBAAyB,SAAyC;CAChF,uBAAuB;AACzB"}