@timber-js/app 0.2.0-alpha.2 → 0.2.0-alpha.200

package/dist/_chunks/navigation-root-mHSK9psY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation-root-mHSK9psY.js","names":[],"sources":["../../src/client/router-ref.ts","../../src/client/use-pending-navigation.ts","../../src/client/top-loader.tsx","../../src/client/navigation-root.tsx"],"sourcesContent":["// Global router reference — shared between browser-entry and client hooks.\n//\n// Delegates to client/state.ts for the actual module-level variable.\n// This ensures singleton semantics regardless of import path — all\n// callers converge on the same state.ts instance via the barrel.\n//\n// See design/18-build-system.md §\"Module Singleton Strategy\"\n\nimport type { RouterInstance } from './router-types.ts';\nimport { globalRouter, _setGlobalRouter } from './state.ts';\n\n/**\n * Set the global router instance. Called once during bootstrap.\n */\nexport function setGlobalRouter(router: RouterInstance): void {\n  _setGlobalRouter(router);\n}\n\n/**\n * Get the global router instance. Throws if called before bootstrap.\n * Used by client-side hooks (usePendingNavigation, etc.)\n */\nexport function getRouter(): RouterInstance {\n  if (!globalRouter) {\n    throw new Error('[timber] Router not initialized. getRouter() was called before bootstrap().');\n  }\n  return globalRouter;\n}\n\n/**\n * Get the global router instance or null if not yet initialized.\n * Used by useRouter() methods to avoid silent failures — callers\n * can log a meaningful warning instead of silently no-oping.\n */\nexport function getRouterOrNull(): RouterInstance | null {\n  return globalRouter;\n}\n\n/**\n * Reset the global router to null. Used only in tests to isolate\n * module-level state between test cases.\n * @internal\n */\nexport function resetGlobalRouter(): void {\n  _setGlobalRouter(null);\n}\n","import { useSyncExternalStore } from 'react';\nimport { getRouterOrNull } from './router-ref.ts';\n\nfunction subscribe(onStoreChange: () => void): () => void {\n  const router = getRouterOrNull();\n  if (!router) return () => {};\n  return router.onPendingChange(onStoreChange);\n}\n\nfunction getSnapshot(): boolean {\n  const router = getRouterOrNull();\n  return router ? router.isPending() : false;\n}\n\nconst getServerSnapshot = getSnapshot;\n\n/**\n * Returns true while an RSC navigation is in flight.\n *\n * Reads from the router's external pending store via useSyncExternalStore.\n * Only components that call this hook re-render when pending state\n * changes — no full-tree re-render.\n *\n * ```tsx\n * 'use client'\n * import { usePendingNavigation } from '@timber-js/app/client'\n *\n * export function NavBar() {\n *   const isPending = usePendingNavigation()\n *   return (\n *     <nav className={isPending ? 'opacity-50' : ''}>\n *       <Link href=\"/dashboard\">Dashboard</Link>\n *     </nav>\n *   )\n * }\n * ```\n */\nexport function usePendingNavigation(): boolean {\n  return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);\n}\n","/**\n * TopLoader — Built-in progress bar for client navigations.\n *\n * Shows an animated progress bar at the top of the viewport while an RSC\n * navigation is in flight. Injected automatically by the framework into\n * NavigationRoot — users never render this component directly.\n *\n * Configuration is via timber.config.ts `topLoader` key. Enabled by default.\n * Users who want a fully custom progress indicator disable the built-in one\n * (`topLoader: { enabled: false }`) and use `usePendingNavigation()` directly.\n *\n * Animation approach: pure CSS @keyframes. The bar crawls from 0% to ~90%\n * width over ~30s using ease-out timing. When navigation completes, the bar\n * snaps to 100% and fades out over 200ms. No JS animation loops (RAF, setInterval).\n *\n * Phase transitions are derived synchronously during render (React's\n * getDerivedStateFromProps pattern) — no useEffect needed for state tracking.\n * The finishing → hidden cleanup uses onTransitionEnd from the CSS transition.\n *\n * When delay > 0, CSS animation-delay + a visibility keyframe ensure the bar\n * stays invisible during the delay period. If navigation finishes before the\n * delay, the bar was never visible so the finish transition is also invisible.\n *\n * See design/19-client-navigation.md §\"usePendingNavigation()\"\n * See LOCAL-336 for design decisions.\n */\n\n'use client';\n\nimport { useState, createElement } from 'react';\nimport { usePendingNavigation } from './use-pending-navigation.ts';\n\n// ─── Types ───────────────────────────────────────────────────────\n\nexport interface TopLoaderConfig {\n  /** Whether the top-loader is enabled. Default: true. */\n  enabled?: boolean;\n  /** Bar color. Default: '#2299DD'. */\n  color?: string;\n  /** Bar height in pixels. Default: 3. */\n  height?: number;\n  /** Show subtle glow/shadow effect. Default: false. */\n  shadow?: boolean;\n  /** Delay in ms before showing the bar. Default: 0. */\n  delay?: number;\n  /** CSS z-index. Default: 1600. */\n  zIndex?: number;\n}\n\n// ─── Defaults ────────────────────────────────────────────────────\n\nconst DEFAULT_COLOR = '#2299DD';\nconst DEFAULT_HEIGHT = 3;\nconst DEFAULT_SHADOW = false;\nconst DEFAULT_DELAY = 0;\nconst DEFAULT_Z_INDEX = 1600;\n\n// ─── Keyframes ───────────────────────────────────────────────────\n\n// Unique keyframes name to avoid collisions with user styles.\nconst CRAWL_KEYFRAMES = '__timber_top_loader_crawl';\nconst APPEAR_KEYFRAMES = '__timber_top_loader_appear';\nconst FINISH_KEYFRAMES = '__timber_top_loader_finish';\n\n// Track whether the @keyframes rules have been injected into the document.\nlet keyframesInjected = false;\n\n/**\n * Inject the @keyframes rules into the document head once.\n * Called during render (idempotent). Uses a <style> tag so the\n * animations are available for inline-styled elements.\n */\nfunction ensureKeyframes(): void {\n  if (keyframesInjected) return;\n  if (typeof document === 'undefined') return;\n\n  const style = document.createElement('style');\n  style.textContent = `\n@keyframes ${CRAWL_KEYFRAMES} {\n  0% { width: 0%; }\n  100% { width: 90%; }\n}\n@keyframes ${APPEAR_KEYFRAMES} {\n  from { opacity: 0; }\n  to { opacity: 1; }\n}\n@keyframes ${FINISH_KEYFRAMES} {\n  0% { width: 90%; opacity: 1; }\n  50% { width: 100%; opacity: 1; }\n  100% { width: 100%; opacity: 0; }\n}\n`;\n  document.head.appendChild(style);\n  keyframesInjected = true;\n}\n\n// ─── Component ───────────────────────────────────────────────────\n\n/**\n * Internal top-loader component. Injected by NavigationRoot.\n *\n * Reads pending navigation state from the router's external store, via\n * usePendingNavigation() — the one pending representation (TIM-1307).\n * Phase transitions are derived synchronously during render:\n *\n *   hidden → crawling:   when isPending becomes true\n *   crawling → finishing: when isPending becomes false\n *   finishing → hidden:   when CSS transition ends (onTransitionEnd)\n *   finishing → crawling: when isPending becomes true again\n *\n * No useEffect — all state changes are either derived during render\n * (getDerivedStateFromProps pattern) or triggered by DOM events.\n */\nexport function TopLoader({ config }: { config?: TopLoaderConfig }): React.ReactElement | null {\n  // Read pending state from the router's external store via\n  // useSyncExternalStore (inside usePendingNavigation). Only this\n  // component re-renders when pending changes — no full-tree re-render.\n  const isPending = usePendingNavigation();\n\n  const color = config?.color ?? DEFAULT_COLOR;\n  const height = config?.height ?? DEFAULT_HEIGHT;\n  const shadow = config?.shadow ?? DEFAULT_SHADOW;\n  const delay = config?.delay ?? DEFAULT_DELAY;\n  const zIndex = config?.zIndex ?? DEFAULT_Z_INDEX;\n\n  const [phase, setPhase] = useState<'hidden' | 'crawling' | 'finishing'>('hidden');\n\n  // ─── Synchronous phase derivation (getDerivedStateFromProps) ──\n  // React allows setState during render if the value changes — it\n  // immediately re-renders with the updated state before committing.\n\n  if (isPending && (phase === 'hidden' || phase === 'finishing')) {\n    setPhase('crawling');\n  }\n  if (!isPending && phase === 'crawling') {\n    setPhase('finishing');\n  }\n\n  // Inject keyframes on first visible render (idempotent)\n  if (phase !== 'hidden') {\n    ensureKeyframes();\n  }\n\n  if (phase === 'hidden') return null;\n\n  // ─── Styles ──────────────────────────────────────────────────\n\n  const containerStyle: React.CSSProperties = {\n    position: 'fixed',\n    top: 0,\n    left: 0,\n    width: '100%',\n    height: `${height}px`,\n    zIndex,\n    pointerEvents: 'none',\n  };\n\n  const barStyle: React.CSSProperties = {\n    height: '100%',\n    backgroundColor: color,\n    ...(phase === 'crawling'\n      ? {\n          // Crawl from 0% to 90% over 30s. When delay > 0, both the crawl\n          // and a visibility animation are delayed — the bar stays at width 0%\n          // and opacity 0 during the delay, then appears and starts crawling.\n          // With delay 0, the appear animation is instant (0s duration, no delay).\n          animation: [\n            `${CRAWL_KEYFRAMES} 30s ease-out ${delay}ms forwards`,\n            `${APPEAR_KEYFRAMES} 0s ${delay}ms both`,\n          ].join(', '),\n        }\n      : {\n          // Finishing: fill to 100% then fade out via a keyframe animation.\n          // We use a keyframe instead of a CSS transition because the\n          // animation-to-transition handoff is unreliable — the browser\n          // may not capture the animated width as the transition's \"from\"\n          // value when both the animation removal and transition are\n          // applied in the same render frame.\n          animation: `${FINISH_KEYFRAMES} 400ms ease forwards`,\n        }),\n    ...(shadow\n      ? {\n          boxShadow: `0 0 10px ${color}, 0 0 5px ${color}`,\n        }\n      : {}),\n  };\n\n  // Clean up the finishing phase when the finish animation completes.\n  const handleAnimationEnd =\n    phase === 'finishing'\n      ? (e: React.AnimationEvent) => {\n          if (e.animationName === FINISH_KEYFRAMES) {\n            setPhase('hidden');\n          }\n        }\n      : undefined;\n\n  return createElement(\n    'div',\n    {\n      'style': containerStyle,\n      'aria-hidden': 'true',\n      'data-timber-top-loader': '',\n    },\n    createElement('div', { style: barStyle, onAnimationEnd: handleAnimationEnd })\n  );\n}\n","/**\n * NavigationRoot — the component the router renders the page through.\n *\n * It is stateless. The router owns the displayed tree and drives React with\n * `root.render(<NavigationRoot rendered={{ element, publish }} />)` inside a\n * synchronous `startTransition` (see `client/react-root.ts`). A transition\n * update keeps the committed tree on screen while the incoming one resolves,\n * instead of replacing it with a Suspense fallback — the reason this\n * component exists (TIM-1306).\n *\n * It used to hold the tree in `useState` and register `setState` closures\n * into module globals during render so the router could reach into it, with a\n * second set of stand-in closures for the window before a root existed\n * (TIM-600). Inverting that — router calls React, not the reverse — deleted\n * all of it (TIM-1431). Next.js's `use-action-queue.ts` says it wants this\n * shape and cannot have it because it must decode Flight during render;\n * timber decodes in `router-pipeline.ts`, so nothing stands in the way.\n *\n * What this component does own is **the commit-time publish**: a navigation's\n * state (segment cache, address bar, history stack, pathname) is published\n * from a layout effect keyed on the tree object, so the event that puts a\n * route on screen is the event that makes it current (TIM-1301). Props work\n * for that exactly as state did.\n *\n * This component holds no pending state. The `TopLoader` it renders and the\n * public `usePendingNavigation()` both subscribe to the router's external\n * pending store; NavigationRoot's own `pendingUrl` was a second, unread\n * representation of the same fact and is gone (TIM-1307).\n *\n * Hard navigation guard: When a hard navigation is triggered (500 error,\n * version skew), the component throws an unresolved thenable AFTER all\n * hooks to suspend forever — preventing React from rendering children\n * during page teardown. The throw must come after hooks to satisfy\n * React's rules (same hook count every render) while still preventing\n * child renders that could hit hook count mismatches in components\n * whose positions shift during teardown. This pattern is borrowed from\n * Next.js (app-router.tsx pushRef.mpaNavigation — also after hooks).\n *\n * See design/05-streaming.md §\"deferSuspenseFor\"\n * See design/19-client-navigation.md §\"NavigationContext\"\n */\n\nimport { createElement, Fragment, useLayoutEffect, useRef, type ReactNode } from 'react';\nimport { TopLoader, type TopLoaderConfig } from './top-loader.tsx';\n\n// ─── Rendered Tree ──────────────────────────────────────────────\n\n/**\n * The tree the router has handed to React, and the state publish that belongs\n * to it. They travel as one object so React's commit of the tree is the event\n * that publishes — see the effect in NavigationRoot. Every `render` builds a\n * fresh one, which is what keys that effect: a tree is published once, however\n * many times React re-runs the effect for it.\n */\nexport interface RenderedTree {\n  element: ReactNode;\n  /**\n   * Publishes the navigation's state — segment cache, pathname, address bar,\n   * history stack, and the client's record of the mounted tree — and\n   * announces it to listeners outside React. Runs when React commits\n   * `element`, never before (TIM-1301). Null for a render that has nothing to\n   * publish on commit (hydration, the shallow search re-wrap).\n   */\n  publish: (() => void) | null;\n}\n\n/**\n * Hand a tree to React in a transition. `publish` runs when React commits it.\n *\n * Every path that puts a page on screen goes through one of these — a\n * navigation, a revalidation, a popstate replay, a shallow search re-wrap —\n * and it is always a synchronous `startTransition` around `root.render`.\n * The production one is `createReactRoot().render`.\n */\nexport type NavigationRender = (element: ReactNode, publish: (() => void) | null) => void;\n\n// ─── Hard Navigation Guard ──────────────────────────────────────\n\n/**\n * Module-level flag indicating a hard (MPA) navigation is in progress.\n *\n * When true:\n * - NavigationRoot throws an unresolved thenable to suspend forever,\n *   preventing React from rendering children during page teardown\n *   (avoids \"Rendered more hooks\" crashes).\n * - The Navigation API handler skips interception, letting the browser\n *   perform a full page load (prevents infinite loops where\n *   window.location.href → navigate event → router.navigate → 500 →\n *   window.location.href → ...).\n *\n * Uses globalThis for singleton guarantee across chunks (same pattern\n * as NavigationContext). See design/19-client-navigation.md §\"Singleton\n * Guarantee via globalThis\".\n */\nconst HARD_NAV_KEY = Symbol.for('__timber_hard_navigating');\n\nfunction getHardNavStore(): { value: boolean } {\n  const g = globalThis as Record<symbol, unknown>;\n  if (!g[HARD_NAV_KEY]) {\n    g[HARD_NAV_KEY] = { value: false };\n  }\n  return g[HARD_NAV_KEY] as { value: boolean };\n}\n\n/**\n * Set the hard-navigating flag. Call this BEFORE setting\n * window.location.href or window.location.reload() to prevent:\n * 1. React from rendering children during page teardown\n * 2. Navigation API from intercepting the hard navigation\n */\nexport function setHardNavigating(value: boolean): void {\n  getHardNavStore().value = value;\n}\n\n/**\n * Check if a hard navigation is in progress.\n * Used by NavigationRoot (throw unresolvedThenable) and by the\n * Navigation API handler (skip interception).\n */\nexport function isHardNavigating(): boolean {\n  return getHardNavStore().value;\n}\n\n/**\n * A thenable that never resolves. When thrown during React render,\n * it causes the component to suspend forever — React keeps the\n * old committed tree visible and never attempts to render children.\n *\n * This is the same pattern Next.js uses in app-router.tsx for MPA\n * navigations (pushRef.mpaNavigation → throw unresolvedThenable).\n */\n// for React's Suspense mechanism. Same pattern as Next.js's unresolvedThenable.\n// eslint-disable-next-line unicorn/no-thenable -- Intentionally a never-resolving thenable\nconst unresolvedThenable = { then() {} } as PromiseLike<never>;\n\n// ─── Component ───────────────────────────────────────────────────\n\n/**\n * Root component the router renders the page through.\n *\n * Renders the TopLoader alongside the tree it is given. Neither adds a DOM\n * element on the hydration path, so the tree matches the server HTML.\n *\n * Rendered only by `createReactRoot` (client/react-root.ts): hydration passes\n * `{ element, publish: null }`, and every later render is a synchronous\n * `startTransition(() => root.render(...))` with a fresh `rendered` object.\n */\nexport function NavigationRoot({\n  rendered,\n  topLoaderConfig,\n}: {\n  rendered: RenderedTree;\n  topLoaderConfig?: TopLoaderConfig;\n}): ReactNode {\n  // Publish the navigation's state when React commits its tree — not when the\n  // tree is handed over. A tree React is still waiting on, or one a later\n  // navigation replaces before React renders it, has been *given* to React\n  // without being on screen; publishing then describes a route the user never\n  // saw, which is the defect this ordering exists to prevent (TIM-1301).\n  //\n  // A **layout** effect, so the publish lands before the browser paints and,\n  // more importantly, before every descendant's passive effect. A destination\n  // component that navigates from a mount effect — a redirect guard, a\n  // `refresh()` on mount — would otherwise start its navigation while the\n  // segment cache, address bar and pathname still described the departing\n  // route, and send an X-Timber-State-Tree for a tree that is no longer\n  // mounted (codex on #998).\n  //\n  // Descendant *layout* effects still run first: React runs layout effects\n  // child-before-parent, and the only way to precede them would be a fiber\n  // rendered as an earlier sibling of the payload. That is not free here —\n  // `server/ssr-wrappers.tsx` mirrors this component's fiber shape so `useId`\n  // agrees across hydration, and an extra sibling shifts every id in the\n  // payload subtree. A layout effect that navigates on mount is the price.\n  //\n  // Keyed on the tree object rather than on the effect run. A publish moves\n  // the address bar, which is not idempotent, so any second invocation for the\n  // same tree — an effect re-run React is entitled to perform, StrictMode's\n  // double-invoke — must be a no-op rather than a second history entry.\n  const publishedRef = useRef<RenderedTree | null>(null);\n  useLayoutEffect(() => {\n    if (publishedRef.current === rendered) return;\n    publishedRef.current = rendered;\n    rendered.publish?.();\n  }, [rendered]);\n\n  // ─── Hard navigation guard ─────────────────────────────────\n  // When a hard navigation is in progress (500 error, version skew),\n  // suspend forever to prevent React from rendering children during\n  // page teardown. This avoids \"Rendered more hooks\" crashes in\n  // CHILD components whose hook counts may shift during teardown.\n  //\n  // CRITICAL: This throw MUST come AFTER all hooks (the useRef and\n  // useLayoutEffect above). React requires the same hooks to run on every\n  // render. If we threw before hooks, React would see 0 hooks on the\n  // re-render vs 2 on the initial render — triggering the exact \"Rendered\n  // more hooks\" error we're trying to prevent.\n  //\n  // By placing it after hooks but before the return, all hooks\n  // satisfy React's rules, but the thrown thenable prevents any\n  // children from rendering. Same pattern as Next.js app-router.tsx\n  // (pushRef.mpaNavigation — also placed after all hooks).\n  if (isHardNavigating()) {\n    throw unresolvedThenable;\n  }\n\n  // Inject TopLoader alongside the element tree. It subscribes to the router's\n  // pending store itself, so it takes no props from here beyond its config,\n  // and only it re-renders when a navigation starts or ends. Rendered only\n  // when not explicitly disabled via config.\n  //\n  // This Fragment is a FORK — two children — so it advances React's tree\n  // context and shifts every `useId` below it. `server/ssr-wrappers.tsx`\n  // mirrors it for exactly that reason; a single-child wrapper would not need\n  // a mirror. See tests/ssr-wrapper-parity.test.ts.\n  const showTopLoader = topLoaderConfig?.enabled !== false;\n  if (!showTopLoader) return rendered.element;\n  return createElement(\n    Fragment,\n    null,\n    createElement(TopLoader, { config: topLoaderConfig }),\n    rendered.element\n  );\n}\n"],"mappings":";;;;;;AAcA,SAAgB,gBAAgB,QAA8B;CAC5D,iBAAiB,MAAM;AACzB;;;;;AAMA,SAAgB,YAA4B;CAC1C,IAAI,CAAC,cACH,MAAM,IAAI,MAAM,6EAA6E;CAE/F,OAAO;AACT;;;;;;AAOA,SAAgB,kBAAyC;CACvD,OAAO;AACT;;;ACjCA,SAAS,UAAU,eAAuC;CACxD,MAAM,SAAS,gBAAgB;CAC/B,IAAI,CAAC,QAAQ,aAAa,CAAC;CAC3B,OAAO,OAAO,gBAAgB,aAAa;AAC7C;AAEA,SAAS,cAAuB;CAC9B,MAAM,SAAS,gBAAgB;CAC/B,OAAO,SAAS,OAAO,UAAU,IAAI;AACvC;AAEA,IAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;AAuB1B,SAAgB,uBAAgC;CAC9C,OAAO,qBAAqB,WAAW,aAAa,iBAAiB;AACvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AEuDA,IAAM,eAAe,OAAO,IAAI,0BAA0B;AAE1D,SAAS,kBAAsC;CAC7C,MAAM,IAAI;CACV,IAAI,CAAC,EAAE,eACL,EAAE,gBAAgB,EAAE,OAAO,MAAM;CAEnC,OAAO,EAAE;AACX;;;;;;;AAQA,SAAgB,kBAAkB,OAAsB;CACtD,gBAAgB,CAAC,CAAC,QAAQ;AAC5B"}

package/dist/_chunks/param-value-C8TNYchQ.js

@@ -0,0 +1,66 @@
+//#region src/shared/param-value.ts
+/** The domain, for error messages. Derived, never a second hand-written list. */
+var DOMAIN = `a string, number, boolean, bigint, null, undefined, a plain object, an array, or ${[
+	"Date",
+	"Map",
+	"Set"
+].join("/")}`;
+function reject(path, was, hint) {
+	throw new Error(`[timber] Segment param "${path || "(root)"}" was coerced to ${was}, which cannot cross to the client. A param value may be ${DOMAIN}.\n  ${hint}\n  See design/41-global-params.md §"Transport".`);
+}
+function describe(value) {
+	return value.constructor?.name ?? "an object";
+}
+/**
+* Deep-clone a codec's output into the canonical form, or throw.
+*
+* `seen` accumulates every object the walk has entered, and a second encounter
+* is rejected. That is one rule for two things — a shared reference and a cycle
+* are both "this object again" — and it is what keeps the result a tree.
+*/
+function normalizeParamValue(value, path = "") {
+	return normalize(value, path, /* @__PURE__ */ new Set());
+}
+function normalize(value, path, seen) {
+	if (value === null) return null;
+	const kind = typeof value;
+	if (kind === "string" || kind === "number" || kind === "boolean" || kind === "bigint") return value;
+	if (kind === "undefined") return void 0;
+	if (kind === "function") reject(path, "a function", "Return the data it would produce, not the function.");
+	if (kind === "symbol") reject(path, "a symbol", "Return a string instead — a symbol has no wire representation.");
+	const object = value;
+	if (seen.has(object)) throw new Error(`[timber] Segment param "${path || "(root)"}" is a value that already appears elsewhere in the same param — a shared reference or a cycle. A param value is a tree: React Flight carries a repeated \`Date\` by value and a repeated object by reference, so sharing would survive for some types and not others.\n  Return separate values, or move the shared part outside the params.\n  See design/41-global-params.md §"Transport".`);
+	seen.add(object);
+	if (Array.isArray(object)) {
+		const out = [];
+		for (let index = 0; index < object.length; index++) out.push(normalize(object[index], `${path}[${index}]`, seen));
+		return out;
+	}
+	if (object instanceof Date) return new Date(object.getTime());
+	if (object instanceof Map) {
+		const out = /* @__PURE__ */ new Map();
+		for (const [key, entry] of object) out.set(normalize(key, `${path}<key>`, seen), normalize(entry, `${path}.get(${keyLabel(key)})`, seen));
+		return out;
+	}
+	if (object instanceof Set) {
+		const out = /* @__PURE__ */ new Set();
+		let index = 0;
+		for (const entry of object) out.add(normalize(entry, `${path}[${index++}]`, seen));
+		return out;
+	}
+	const prototype = Object.getPrototypeOf(object);
+	if (prototype !== null && prototype !== Object.prototype) reject(path, `a ${describe(object)} instance`, "Return a plain object with the fields you need.");
+	const out = Object.create(null);
+	for (const key of Object.keys(object)) {
+		if (key === "__proto__") continue;
+		out[key] = normalize(object[key], path ? `${path}.${key}` : key, seen);
+	}
+	return out;
+}
+function keyLabel(key) {
+	return typeof key === "string" ? JSON.stringify(key) : String(key);
+}
+//#endregion
+export { normalizeParamValue as t };
+
+//# sourceMappingURL=param-value-C8TNYchQ.js.map

package/dist/_chunks/param-value-C8TNYchQ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"param-value-C8TNYchQ.js","names":[],"sources":["../../src/shared/param-value.ts"],"sourcesContent":["/**\n * The canonical form of a segment param value.\n *\n * `getSegmentParams()` on the server and `useSegmentParams()` on the client\n * must return the same value — same prototype, same own properties. This\n * module is how that is guaranteed, and the mechanism matters:\n *\n * **Both sides are images of one normalizer.** A codec's output is deep-cloned\n * into a closed canonical domain at coercion time, and *that clone* is what the\n * server returns and what goes on the wire. Server and client agree by\n * construction, because neither holds the codec's original.\n *\n * That replaces predicting what React Flight would do to an arbitrary value.\n * Prediction is what the previous design attempted and it cannot be finished:\n * the question \"will Flight's decode output be observably identical to this\n * input?\" ranges over every way a JS object can carry state that is not in its\n * serialization — own keys, enumerability, symbols, holes, accessors,\n * subclassing, exotic objects — and a `Proxy` defeats it outright, since a\n * lying `getPrototypeOf` trap makes any static check unsound. Twelve review\n * findings on PR #992 were each one more case of that set, and the set does\n * not close.\n *\n * Normalizing closes it. The only remaining question is whether Flight\n * round-trips the normalizer's *output range* — a finite domain we defined,\n * covered by `tests/e2e/segment-params.test.ts` against the real serializer.\n *\n * ## The domain\n *\n * - `undefined`, `null`, `string`, `number`, `boolean`, `bigint`\n * - null-prototype objects, own enumerable string keys only\n * - dense arrays\n * - `Date`, `Map`, `Set` — rebuilt, never the codec's instance\n *\n * ...and it is a **tree**: no value appears twice, and nothing is cyclic.\n * That is not a simplification, it is the last prediction being removed.\n * Flight encodes a `Date` by value at each occurrence but tracks plain objects\n * for reference dedup, so preserving aliasing would carry it across for some\n * types and drop it for others — and knowing which is exactly the kind of\n * guess this design exists to stop making (codex, PR #992). A tree has no\n * sharing to preserve or lose, so what Flight does about it is unobservable.\n *\n * Anything else throws, naming the param and what it was. Note what is *not*\n * a rejection: a `Date` subclass normalizes to a `Date`, a decorated array to\n * a plain one, a sparse array to a dense one, a getter to the value it\n * returned. Those used to be twelve separate checks. They are not divergences\n * any more, because the normalization happens once and both sides see its\n * result — so they need no checks at all.\n *\n * Own properties that Flight would drop (non-enumerable, symbol-keyed) are\n * dropped here instead, symmetrically. Prototype pollution is handled by the\n * same pass: `__proto__` is never copied, and every object is\n * `Object.create(null)` (design/13-security.md #36b/#36c, TIM-873).\n *\n * ## The prototype flip\n *\n * Flight refuses to serialize a null-prototype object, so the canonical form\n * cannot go on the wire as-is. `toPlainRecord` and `toNullProtoRecord` flip\n * the prototype on the way out and back. They are exact inverses and both\n * total, because they only ever see canonical values — there is nothing to\n * validate and no shape to special-case.\n *\n * See design/41-global-params.md §\"Transport\".\n */\n\n// ─── Post-coercion param types ──────────────────────────────────────────\n\n/**\n * A single segment param value after codec coercion and normalization.\n *\n * Before coercion, every param is `string | string[]` (the raw URL part).\n * After `app/schema.ts` codecs run, a param can be any value in the\n * `normalizeParamValue` domain below. This type replaces the previous\n * `string | string[]` declaration, which was a lie whenever a codec\n * produced a non-string value (TIM-1347).\n *\n * The typed accessor `getSegmentParams(SEGMENT_PATH)` resolves through\n * the schema and returns the exact type the codec declares. This type\n * covers the untyped/no-argument form and internal plumbing.\n */\nexport type CoercedParamValue =\n  | string\n  | number\n  | boolean\n  | bigint\n  | null\n  | undefined\n  | Date\n  | Map<CoercedParamValue, CoercedParamValue>\n  | Set<CoercedParamValue>\n  | CoercedParamValue[]\n  | { [key: string]: CoercedParamValue };\n\n/**\n * A record of coerced segment params, keyed by param name.\n *\n * This is the post-coercion type for `segmentParams` throughout the\n * framework. Before coercion (route matcher output, `rawSegmentParams`),\n * the type is `Record<string, string | string[]>`.\n */\nexport type CoercedParams = Record<string, CoercedParamValue>;\n\n/** Types the canonical form rebuilds rather than rejects. */\nconst REBUILT = ['Date', 'Map', 'Set'] as const;\n\n/** The domain, for error messages. Derived, never a second hand-written list. */\nconst DOMAIN = `a string, number, boolean, bigint, null, undefined, a plain object, an array, or ${REBUILT.join('/')}`;\n\nfunction reject(path: string, was: string, hint: string): never {\n  throw new Error(\n    `[timber] Segment param \"${path || '(root)'}\" was coerced to ${was}, which cannot ` +\n      `cross to the client. A param value may be ${DOMAIN}.\\n` +\n      `  ${hint}\\n` +\n      `  See design/41-global-params.md §\"Transport\".`\n  );\n}\n\nfunction describe(value: object): string {\n  return (value as { constructor?: { name?: string } }).constructor?.name ?? 'an object';\n}\n\n/**\n * Deep-clone a codec's output into the canonical form, or throw.\n *\n * `seen` accumulates every object the walk has entered, and a second encounter\n * is rejected. That is one rule for two things — a shared reference and a cycle\n * are both \"this object again\" — and it is what keeps the result a tree.\n */\nexport function normalizeParamValue(value: unknown, path = ''): CoercedParamValue {\n  return normalize(value, path, new Set());\n}\n\nfunction normalize(value: unknown, path: string, seen: Set<object>): CoercedParamValue {\n  if (value === null) return null;\n\n  const kind = typeof value;\n  if (kind === 'string' || kind === 'number' || kind === 'boolean' || kind === 'bigint') {\n    return value as string | number | boolean | bigint;\n  }\n  if (kind === 'undefined') return undefined;\n  if (kind === 'function') {\n    reject(path, 'a function', 'Return the data it would produce, not the function.');\n  }\n  if (kind === 'symbol') {\n    reject(path, 'a symbol', 'Return a string instead — a symbol has no wire representation.');\n  }\n\n  const object = value as object;\n  if (seen.has(object)) {\n    throw new Error(\n      `[timber] Segment param \"${path || '(root)'}\" is a value that already appears ` +\n        `elsewhere in the same param — a shared reference or a cycle. A param value is a ` +\n        `tree: React Flight carries a repeated \\`Date\\` by value and a repeated object by ` +\n        `reference, so sharing would survive for some types and not others.\\n` +\n        `  Return separate values, or move the shared part outside the params.\\n` +\n        `  See design/41-global-params.md §\"Transport\".`\n    );\n  }\n  seen.add(object);\n\n  if (Array.isArray(object)) {\n    // Read by index, so holes become `undefined` — on both sides, which is\n    // the point. A subclass and any own properties are left behind for the\n    // same reason: the clone is a plain, dense array either way.\n    const out: CoercedParamValue[] = [];\n    for (let index = 0; index < object.length; index++) {\n      out.push(normalize((object as unknown[])[index], `${path}[${index}]`, seen));\n    }\n    return out;\n  }\n\n  if (object instanceof Date) {\n    // A fresh Date, so a subclass or an attached property cannot travel half\n    // way and be dropped by the wire.\n    return new Date(object.getTime());\n  }\n\n  if (object instanceof Map) {\n    const out = new Map<CoercedParamValue, CoercedParamValue>();\n    for (const [key, entry] of object) {\n      out.set(\n        normalize(key, `${path}<key>`, seen),\n        normalize(entry, `${path}.get(${keyLabel(key)})`, seen)\n      );\n    }\n    return out;\n  }\n\n  if (object instanceof Set) {\n    const out = new Set<CoercedParamValue>();\n    let index = 0;\n    for (const entry of object) out.add(normalize(entry, `${path}[${index++}]`, seen));\n    return out;\n  }\n\n  // Everything else is judged by its prototype. A `Proxy` can lie here, and\n  // that is fine: whatever it answers, the clone below reads through it once\n  // and both sides see the same snapshot.\n  const prototype = Object.getPrototypeOf(object);\n  if (prototype !== null && prototype !== Object.prototype) {\n    reject(\n      path,\n      `a ${describe(object)} instance`,\n      'Return a plain object with the fields you need.'\n    );\n  }\n\n  // Own *enumerable string* keys only — the rest is what Flight would drop,\n  // so dropping it here keeps the two sides identical. `__proto__` is skipped\n  // rather than copied: it has a language-level setter that would change the\n  // prototype chain of the copy (TIM-655, TIM-855, TIM-873).\n  const out: Record<string, CoercedParamValue> = Object.create(null);\n  for (const key of Object.keys(object)) {\n    if (key === '__proto__') continue;\n    out[key] = normalize(\n      (object as Record<string, unknown>)[key],\n      path ? `${path}.${key}` : key,\n      seen\n    );\n  }\n  return out;\n}\n\nfunction keyLabel(key: unknown): string {\n  return typeof key === 'string' ? JSON.stringify(key) : String(key);\n}\n\n// ─── Prototype flip ──────────────────────────────────────────────\n\n/**\n * Canonical form → wire form. React Flight rejects a null prototype\n * (\"Classes or null prototypes are not supported\"), so objects cross as plain\n * ones and are restored on arrival.\n */\nexport function toPlainRecord<T>(value: T): T {\n  return reproto(value, {}) as T;\n}\n\n/** Wire form → canonical form. The exact inverse of `toPlainRecord`. */\nexport function toNullProtoRecord<T>(value: T): T {\n  return reproto(value, null) as T;\n}\n\n/**\n * Rebuild a canonical value with objects on `proto`.\n *\n * Total by construction: its input is always canonical, so the cases are the\n * domain and nothing else. No validation, no shape it might not have seen, and\n * no cycle to guard — a canonical value is a tree. That is what moving the\n * checking to `normalizeParamValue` bought.\n */\nfunction reproto(value: unknown, proto: object | null): unknown {\n  if (value === null || typeof value !== 'object') return value;\n\n  const object = value as object;\n\n  // A Date carries no nested values, so it crosses as itself.\n  if (object instanceof Date) return object;\n\n  if (Array.isArray(object)) {\n    return (object as unknown[]).map((item) => reproto(item, proto));\n  }\n\n  if (object instanceof Map) {\n    const out = new Map<unknown, unknown>();\n    for (const [key, entry] of object) out.set(reproto(key, proto), reproto(entry, proto));\n    return out;\n  }\n\n  if (object instanceof Set) {\n    const out = new Set<unknown>();\n    for (const entry of object) out.add(reproto(entry, proto));\n    return out;\n  }\n\n  const out: Record<string, unknown> = proto === null ? Object.create(null) : {};\n  for (const key of Object.keys(object)) {\n    if (key === '__proto__') continue;\n    out[key] = reproto((object as Record<string, unknown>)[key], proto);\n  }\n  return out;\n}\n"],"mappings":";;AAyGA,IAAM,SAAS,oFAAoF;CAHlF;CAAQ;CAAO;AAGmE,CAAA,CAAQ,KAAK,GAAG;AAEnH,SAAS,OAAO,MAAc,KAAa,MAAqB;CAC9D,MAAM,IAAI,MACR,2BAA2B,QAAQ,SAAS,mBAAmB,IAAI,2DACpB,OAAO,OAC/C,KAAK,iDAEd;AACF;AAEA,SAAS,SAAS,OAAuB;CACvC,OAAQ,MAA8C,aAAa,QAAQ;AAC7E;;;;;;;;AASA,SAAgB,oBAAoB,OAAgB,OAAO,IAAuB;CAChF,OAAO,UAAU,OAAO,sBAAM,IAAI,IAAI,CAAC;AACzC;AAEA,SAAS,UAAU,OAAgB,MAAc,MAAsC;CACrF,IAAI,UAAU,MAAM,OAAO;CAE3B,MAAM,OAAO,OAAO;CACpB,IAAI,SAAS,YAAY,SAAS,YAAY,SAAS,aAAa,SAAS,UAC3E,OAAO;CAET,IAAI,SAAS,aAAa,OAAO,KAAA;CACjC,IAAI,SAAS,YACX,OAAO,MAAM,cAAc,qDAAqD;CAElF,IAAI,SAAS,UACX,OAAO,MAAM,YAAY,gEAAgE;CAG3F,MAAM,SAAS;CACf,IAAI,KAAK,IAAI,MAAM,GACjB,MAAM,IAAI,MACR,2BAA2B,QAAQ,SAAS,6XAM9C;CAEF,KAAK,IAAI,MAAM;CAEf,IAAI,MAAM,QAAQ,MAAM,GAAG;EAIzB,MAAM,MAA2B,CAAC;EAClC,KAAK,IAAI,QAAQ,GAAG,QAAQ,OAAO,QAAQ,SACzC,IAAI,KAAK,UAAW,OAAqB,QAAQ,GAAG,KAAK,GAAG,MAAM,IAAI,IAAI,CAAC;EAE7E,OAAO;CACT;CAEA,IAAI,kBAAkB,MAGpB,OAAO,IAAI,KAAK,OAAO,QAAQ,CAAC;CAGlC,IAAI,kBAAkB,KAAK;EACzB,MAAM,sBAAM,IAAI,IAA0C;EAC1D,KAAK,MAAM,CAAC,KAAK,UAAU,QACzB,IAAI,IACF,UAAU,KAAK,GAAG,KAAK,QAAQ,IAAI,GACnC,UAAU,OAAO,GAAG,KAAK,OAAO,SAAS,GAAG,EAAE,IAAI,IAAI,CACxD;EAEF,OAAO;CACT;CAEA,IAAI,kBAAkB,KAAK;EACzB,MAAM,sBAAM,IAAI,IAAuB;EACvC,IAAI,QAAQ;EACZ,KAAK,MAAM,SAAS,QAAQ,IAAI,IAAI,UAAU,OAAO,GAAG,KAAK,GAAG,QAAQ,IAAI,IAAI,CAAC;EACjF,OAAO;CACT;CAKA,MAAM,YAAY,OAAO,eAAe,MAAM;CAC9C,IAAI,cAAc,QAAQ,cAAc,OAAO,WAC7C,OACE,MACA,KAAK,SAAS,MAAM,EAAE,YACtB,iDACF;CAOF,MAAM,MAAyC,OAAO,OAAO,IAAI;CACjE,KAAK,MAAM,OAAO,OAAO,KAAK,MAAM,GAAG;EACrC,IAAI,QAAQ,aAAa;EACzB,IAAI,OAAO,UACR,OAAmC,MACpC,OAAO,GAAG,KAAK,GAAG,QAAQ,KAC1B,IACF;CACF;CACA,OAAO;AACT;AAEA,SAAS,SAAS,KAAsB;CACtC,OAAO,OAAO,QAAQ,WAAW,KAAK,UAAU,GAAG,IAAI,OAAO,GAAG;AACnE"}

package/dist/_chunks/plugin-context-8idfR3UZ.js

@@ -0,0 +1,321 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { parseAst } from "vite";
+import { join, resolve } from "node:path";
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { performance } from "node:perf_hooks";
+//#region src/utils/startup-timer.ts
+/**
+* Startup timer — records named phases with their durations.
+*
+* Used by the plugin system to instrument cold start and report a
+* timing breakdown in dev mode. Zero overhead in production (disabled).
+*
+* See design/18-build-system.md, TIM-155.
+*/
+/**
+* Create a startup timer that records phase durations.
+*/
+function createStartupTimer() {
+	const pending = /* @__PURE__ */ new Map();
+	const phases = [];
+	return {
+		start(phase) {
+			pending.set(phase, performance.now());
+		},
+		end(phase) {
+			const startMs = pending.get(phase);
+			if (startMs === void 0) return 0;
+			pending.delete(phase);
+			const durationMs = performance.now() - startMs;
+			phases.push({
+				name: phase,
+				startMs,
+				durationMs
+			});
+			return durationMs;
+		},
+		getPhases() {
+			return [...phases].sort((a, b) => a.startMs - b.startMs);
+		},
+		totalMs() {
+			if (phases.length === 0) return 0;
+			const sorted = this.getPhases();
+			const first = sorted[0];
+			const last = sorted[sorted.length - 1];
+			return last.startMs + last.durationMs - first.startMs;
+		},
+		formatSummary() {
+			const sorted = this.getPhases();
+			if (sorted.length === 0) return "No phases recorded.";
+			const lines = sorted.map((p) => {
+				const ms = p.durationMs.toFixed(1);
+				return `  ${p.name.padEnd(30)} ${ms.padStart(8)}ms`;
+			});
+			const total = this.totalMs().toFixed(1);
+			lines.push(`  ${"total".padEnd(30)} ${total.padStart(8)}ms`);
+			return ["[timber] startup timing:", ...lines].join("\n");
+		}
+	};
+}
+/**
+* No-op timer for production builds — all methods are empty.
+*/
+function createNoopTimer() {
+	return {
+		start() {},
+		end() {
+			return 0;
+		},
+		getPhases() {
+			return [];
+		},
+		totalMs() {
+			return 0;
+		},
+		formatSummary() {
+			return "";
+		}
+	};
+}
+//#endregion
+//#region src/plugin-context.ts
+/**
+* Plugin context — internal types and helpers for timber sub-plugins.
+*
+* These are NOT part of the user-facing API. They are consumed by
+* sub-plugins (routing, entries, shims, etc.) via relative imports.
+* The root entry point (index.ts) does not re-export them.
+*
+* Design doc: 18-build-system.md §"Shared Plugin Context"
+*/
+var plugin_context_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_BUILD_DIR: () => DEFAULT_BUILD_DIR,
+	ParseMemo: () => ParseMemo,
+	configLoadHint: () => configLoadHint,
+	createPluginContext: () => createPluginContext,
+	isTimberPluginApi: () => isTimberPluginApi,
+	loadTimberConfigFile: () => loadTimberConfigFile,
+	mergeFileConfig: () => mergeFileConfig,
+	resolveAppDir: () => resolveAppDir,
+	resolveBuildDir: () => resolveBuildDir,
+	resolveClientJavascript: () => resolveClientJavascript,
+	warnConfigConflicts: () => warnConfigConflicts
+});
+/**
+* Resolve `clientJavascript` into a fully resolved config.
+*/
+function resolveClientJavascript(config) {
+	if (config.clientJavascript !== void 0) {
+		if (typeof config.clientJavascript === "boolean") return {
+			disabled: !config.clientJavascript,
+			enableHMRInDev: !config.clientJavascript
+		};
+		return {
+			disabled: config.clientJavascript.disabled,
+			enableHMRInDev: config.clientJavascript.enableHMRInDev ?? config.clientJavascript.disabled
+		};
+	}
+	return {
+		disabled: false,
+		enableHMRInDev: false
+	};
+}
+var PARSE_MEMO_CAPACITY = 32;
+/**
+* Content-keyed LRU memo for `parseAst`. Transforms for the same module run
+* back-to-back across plugins and environments, so a tiny window captures the
+* wins. The returned ProgramNode is shared — callers MUST NOT mutate it.
+*/
+var ParseMemo = class {
+	cache = /* @__PURE__ */ new Map();
+	/**
+	* Parse code, returning a cached ProgramNode if the same code was parsed
+	* before. The returned AST MUST NOT be mutated — it may be shared across
+	* multiple consumers.
+	*/
+	parse(code) {
+		const existing = this.cache.get(code);
+		if (existing) {
+			this.cache.delete(code);
+			this.cache.set(code, existing);
+			return existing;
+		}
+		const program = parseAst(code, { lang: "tsx" });
+		if (this.cache.size >= PARSE_MEMO_CAPACITY) {
+			const firstKey = this.cache.keys().next().value;
+			this.cache.delete(firstKey);
+		}
+		this.cache.set(code, program);
+		return program;
+	}
+	get size() {
+		return this.cache.size;
+	}
+};
+/** Narrow an unknown Vite `plugin.api` to timber's. */
+function isTimberPluginApi(api) {
+	return typeof api === "object" && api !== null && "getContext" in api && typeof api.getContext === "function";
+}
+/**
+* Resolve the app directory. Checks (in order):
+* 1. Explicit `configAppDir` from timber.config.ts
+* 2. `<root>/app`
+* 3. `<root>/src/app`
+*
+* Throws if none exist.
+*/
+function resolveAppDir(root, configAppDir) {
+	if (configAppDir) {
+		const explicit = join(root, configAppDir);
+		if (!existsSync(explicit)) throw new Error(`[timber] Configured appDir "${configAppDir}" does not exist at ${explicit}`);
+		return explicit;
+	}
+	const rootApp = join(root, "app");
+	if (existsSync(rootApp)) return rootApp;
+	const srcApp = join(root, "src", "app");
+	if (existsSync(srcApp)) return srcApp;
+	throw new Error(`[timber] Could not find app directory. Expected "app/" or "src/app/" in ${root}. You can set appDir in timber.config.ts to specify a custom location.`);
+}
+function createPluginContext(config, root) {
+	const projectRoot = root ?? process.cwd();
+	const resolvedConfig = { ...config };
+	return {
+		config: resolvedConfig,
+		clientJavascript: resolveClientJavascript(resolvedConfig),
+		routeTree: null,
+		appDir: join(projectRoot, "app"),
+		root: projectRoot,
+		dev: false,
+		base: "/",
+		buildManifest: null,
+		deploymentId: null,
+		timer: createStartupTimer(),
+		holdingServer: null,
+		buildDir: resolveBuildDir(projectRoot, resolvedConfig.buildDir),
+		parseCached: new ParseMemo()
+	};
+}
+/** Default build output directory (relative to root). */
+var DEFAULT_BUILD_DIR = join(".timber", "dist");
+/**
+* Resolve the build output directory.
+*
+* Priority:
+* 1. Explicit `timberBuildDir` from timber.config.ts
+* 2. Explicit `viteBuildOutDir` from Vite's build.outDir (if not the default 'dist')
+* 3. Default: `.timber/dist`
+*
+* Returns an absolute path.
+*/
+function resolveBuildDir(root, timberBuildDir, viteBuildOutDir) {
+	if (timberBuildDir) return resolve(root, timberBuildDir);
+	if (viteBuildOutDir && viteBuildOutDir !== "dist") return resolve(root, viteBuildOutDir);
+	return join(root, DEFAULT_BUILD_DIR);
+}
+/**
+* Map known timber.config load failures to actionable hints (TIM-1040).
+* Returns null when the error has no known remedy beyond its own message.
+*
+* Known failure modes of loading timber.config.ts via native require():
+* - Node < 22.18 has no default type stripping → ERR_UNKNOWN_FILE_EXTENSION
+* - Non-erasable TS syntax (enums, namespaces, parameter properties)
+*   → ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX / ERR_INVALID_TYPESCRIPT_SYNTAX
+* - ESM syntax in a `"type": "commonjs"` package → the stripped .ts is
+*   parsed as CJS and throws SyntaxError: "Unexpected token 'export'"
+*   (export statements) or "Cannot use import statement outside a
+*   module" (import statements)
+*/
+function configLoadHint(configName, err) {
+	const code = err?.code;
+	const isTs = configName.endsWith(".ts");
+	if (isTs && code === "ERR_UNKNOWN_FILE_EXTENSION") return "Loading a TypeScript config requires Node.js 22.18+ (built-in type stripping). Upgrade Node.js or rewrite the config as timber.config.js.";
+	if (code === "ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX" || code === "ERR_INVALID_TYPESCRIPT_SYNTAX") return "Node.js loads the config with type stripping, which only supports erasable TypeScript syntax — replace enums, namespaces, and constructor parameter properties with plain objects and types.";
+	if (isTs && err instanceof SyntaxError && /Unexpected token '(export|import)'|Cannot use import statement outside a module/.test(err.message)) return "The config uses ESM syntax but Node.js parsed it as CommonJS — set \"type\": \"module\" in package.json, or use module.exports instead of export default.";
+	return null;
+}
+/**
+* Load timber.config.ts (or .js, .mjs) from the project root.
+* Returns the config object or null if no config file is found.
+* Throws a descriptive error naming the file when a config file exists
+* but fails to load — a broken config must fail loudly, never silently
+* degrade (see TIM-1066). Known failure modes get an actionable hint
+* appended (see configLoadHint, TIM-1040).
+*
+* Uses require() — Node 22.12+ can require() ESM modules, and Node
+* 22.18+ strips types from .ts files by default (hence the engines
+* field requiring >=22.18.0). This keeps timber() synchronous — no
+* async config loading needed.
+* This is the single config loader — dev, build, and preview all use it.
+*/
+function loadTimberConfigFile(root) {
+	const configNames = [
+		"timber.config.ts",
+		"timber.config.js",
+		"timber.config.mjs"
+	];
+	const req = createRequire(join(root, "package.json"));
+	for (const name of configNames) {
+		const configPath = join(root, name);
+		if (existsSync(configPath)) try {
+			const mod = req(configPath);
+			return mod.default ?? mod;
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			const hint = configLoadHint(name, err);
+			throw new Error(`[timber] Failed to load ${configPath}: ${message}${hint ? `\n${hint}` : ""}`, { cause: err });
+		}
+	}
+	return null;
+}
+/**
+* Detect config keys set in both inline (vite.config.ts) and file (timber.config.ts)
+* and warn the user. The `output` key is excluded because it defaults to 'server'
+* in createPluginContext and would always appear as an inline key.
+*
+* Returns the list of conflicting key names (for testing).
+*/
+function warnConfigConflicts(inline, fileConfig) {
+	const conflicts = [];
+	for (const key of Object.keys(fileConfig)) if (key in inline && inline[key] !== void 0) conflicts.push(key);
+	if (conflicts.length > 0) console.warn(`[timber] Config conflict: ${conflicts.map((k) => `"${k}"`).join(", ")} set in both vite.config.ts (inline) and timber.config.ts. Move all config to timber.config.ts to avoid confusion. The inline value from vite.config.ts will be used.`);
+	return conflicts;
+}
+/**
+* Drop own keys whose value is `undefined` so they don't clobber file
+* config during spread merging. `timber({ buildDir: process.env.BUILD_DIR })`
+* with the var unset must not erase the timber.config.ts value.
+*/
+function stripUndefined(obj) {
+	return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0));
+}
+/**
+* Merge file-based config (timber.config.ts) with inline config (vite.config.ts).
+* Inline config takes precedence — file config only fills in missing fields.
+* Inline keys explicitly set to `undefined` are treated as absent, matching
+* the `!== undefined` check in warnConfigConflicts.
+*/
+function mergeFileConfig(inline, fileConfig) {
+	warnConfigConflicts(inline, fileConfig);
+	const definedInline = stripUndefined(inline);
+	return {
+		...fileConfig,
+		...definedInline,
+		...fileConfig.limits && definedInline.limits ? { limits: {
+			...fileConfig.limits,
+			...stripUndefined(definedInline.limits)
+		} } : {},
+		...fileConfig.dev && definedInline.dev ? { dev: {
+			...fileConfig.dev,
+			...stripUndefined(definedInline.dev)
+		} } : {},
+		...fileConfig.mdx && definedInline.mdx ? { mdx: {
+			...fileConfig.mdx,
+			...stripUndefined(definedInline.mdx)
+		} } : {}
+	};
+}
+//#endregion
+export { plugin_context_exports as a, resolveClientJavascript as c, mergeFileConfig as i, createNoopTimer as l, isTimberPluginApi as n, resolveAppDir as o, loadTimberConfigFile as r, resolveBuildDir as s, createPluginContext as t };
+
+//# sourceMappingURL=plugin-context-8idfR3UZ.js.map

package/dist/_chunks/plugin-context-8idfR3UZ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-context-8idfR3UZ.js","names":[],"sources":["../../src/utils/startup-timer.ts","../../src/plugin-context.ts"],"sourcesContent":["/**\n * Startup timer — records named phases with their durations.\n *\n * Used by the plugin system to instrument cold start and report a\n * timing breakdown in dev mode. Zero overhead in production (disabled).\n *\n * See design/18-build-system.md, TIM-155.\n */\n\nimport { performance } from 'node:perf_hooks';\n\nexport interface PhaseRecord {\n  name: string;\n  startMs: number;\n  durationMs: number;\n}\n\nexport interface StartupTimer {\n  /** Mark the beginning of a named phase. */\n  start(phase: string): void;\n  /** Mark the end of a named phase. Returns duration in ms. */\n  end(phase: string): number;\n  /** Get all completed phase records, ordered by start time. */\n  getPhases(): PhaseRecord[];\n  /** Total elapsed time from first start() to last end(). */\n  totalMs(): number;\n  /** Format a human-readable summary string. */\n  formatSummary(): string;\n}\n\n/**\n * Create a startup timer that records phase durations.\n */\nexport function createStartupTimer(): StartupTimer {\n  const pending = new Map<string, number>();\n  const phases: PhaseRecord[] = [];\n\n  return {\n    start(phase: string): void {\n      pending.set(phase, performance.now());\n    },\n\n    end(phase: string): number {\n      const startMs = pending.get(phase);\n      if (startMs === undefined) {\n        return 0;\n      }\n      pending.delete(phase);\n      const durationMs = performance.now() - startMs;\n      phases.push({ name: phase, startMs, durationMs });\n      return durationMs;\n    },\n\n    getPhases(): PhaseRecord[] {\n      return [...phases].sort((a, b) => a.startMs - b.startMs);\n    },\n\n    totalMs(): number {\n      if (phases.length === 0) return 0;\n      const sorted = this.getPhases();\n      const first = sorted[0];\n      const last = sorted[sorted.length - 1];\n      return last.startMs + last.durationMs - first.startMs;\n    },\n\n    formatSummary(): string {\n      const sorted = this.getPhases();\n      if (sorted.length === 0) return 'No phases recorded.';\n\n      const lines = sorted.map((p) => {\n        const ms = p.durationMs.toFixed(1);\n        return `  ${p.name.padEnd(30)} ${ms.padStart(8)}ms`;\n      });\n\n      const total = this.totalMs().toFixed(1);\n      lines.push(`  ${'total'.padEnd(30)} ${total.padStart(8)}ms`);\n\n      return ['[timber] startup timing:', ...lines].join('\\n');\n    },\n  };\n}\n\n/**\n * No-op timer for production builds — all methods are empty.\n */\nexport function createNoopTimer(): StartupTimer {\n  return {\n    start() {},\n    end() {\n      return 0;\n    },\n    getPhases() {\n      return [];\n    },\n    totalMs() {\n      return 0;\n    },\n    formatSummary() {\n      return '';\n    },\n  };\n}\n","/**\n * Plugin context — internal types and helpers for timber sub-plugins.\n *\n * These are NOT part of the user-facing API. They are consumed by\n * sub-plugins (routing, entries, shims, etc.) via relative imports.\n * The root entry point (index.ts) does not re-export them.\n *\n * Design doc: 18-build-system.md §\"Shared Plugin Context\"\n */\n\nimport { existsSync } from 'node:fs';\nimport { join, resolve } from 'node:path';\nimport { createRequire } from 'node:module';\nimport { parseAst } from 'vite';\nimport type { RouteTree } from './routing/types.ts';\nimport type { BuildManifest } from './server/build-manifest.ts';\nimport type { CaptureSummary } from './server/prebuilt-builder.ts';\nimport type { StartupTimer } from './utils/startup-timer.ts';\nimport { createStartupTimer } from './utils/startup-timer.ts';\nimport type { TimberUserConfig, ClientJavascriptConfig } from './config-types.ts';\nimport type { RscManifest } from './plugins/static-build.ts';\nimport type { HoldingServer } from './dev-tools/holding-server.ts';\nimport type { ProgramNode } from './plugins/callsite-ast.ts';\n\n// Re-export for sub-plugin convenience — they import from plugin-context.ts\nexport type { TimberUserConfig, ClientJavascriptConfig } from './config-types.ts';\n\n// ── Client JavaScript config ─────────────────────────────────────────────\n\n/** Fully resolved client JavaScript configuration (no optionals). */\nexport interface ResolvedClientJavascript {\n  disabled: boolean;\n  enableHMRInDev: boolean;\n}\n\n/**\n * Resolve `clientJavascript` into a fully resolved config.\n */\nexport function resolveClientJavascript(config: TimberUserConfig): ResolvedClientJavascript {\n  if (config.clientJavascript !== undefined) {\n    if (typeof config.clientJavascript === 'boolean') {\n      return {\n        disabled: !config.clientJavascript,\n        enableHMRInDev: !config.clientJavascript,\n      };\n    }\n    return {\n      disabled: config.clientJavascript.disabled,\n      enableHMRInDev: config.clientJavascript.enableHMRInDev ?? config.clientJavascript.disabled,\n    };\n  }\n  return { disabled: false, enableHMRInDev: false };\n}\n\n// ── Plugin Context ────────────────────────────────────────────────────────\n\n/**\n * Shared context object passed to all sub-plugins via closure.\n *\n * Sub-plugins communicate through this context — not through Vite's\n * plugin API or global state.\n * See design/18-build-system.md §\"Shared Plugin Context\".\n */\nexport interface PluginContext {\n  config: TimberUserConfig;\n  /** Resolved client JavaScript configuration */\n  clientJavascript: ResolvedClientJavascript;\n  /** The scanned route tree (populated by timber-routing, consumed by timber-entries) */\n  routeTree: RouteTree | null;\n  /** Absolute path to the app/ directory */\n  appDir: string;\n  /** Absolute path to the project root */\n  root: string;\n  /** Whether the dev server is running (set by timber-root-sync in configResolved) */\n  dev: boolean;\n  /**\n   * Vite's resolved `base` (set by timber-root-sync in configResolved).\n   * Always has a trailing slash; `'/'` unless the app is deployed under a\n   * sub-path. Every URL the framework emits — assets, fonts, RSC payloads —\n   * carries this prefix. This is the single copy: sub-plugins read it here\n   * rather than capturing `config.base` in their own configResolved.\n   *\n   * **Availability:** written by timber-root-sync, which has no `enforce`, so\n   * it is populated from `buildStart`/`load`/`generateBundle`/`configureServer`\n   * onward — but NOT during the `configResolved` of an `enforce: 'pre'`\n   * plugin, which Vite runs first. A pre plugin that needs the base inside\n   * its own `configResolved` must read `config.base` there (timber-fonts\n   * does). See TIM-1261.\n   */\n  base: string;\n  /** CSS build manifest (populated by adapter after client build, null in dev) */\n  buildManifest: BuildManifest | null;\n  /** Per-build deployment ID for version skew detection (null in dev) */\n  deploymentId: string | null;\n  /** Startup timer for profiling cold start phases (active in dev, no-op in prod) */\n  timer: StartupTimer;\n  /** Holding server that binds the port during dev startup (closed in timber-dev-server) */\n  holdingServer?: HoldingServer | null;\n  /**\n   * Resolved absolute path to the build output directory.\n   *\n   * Defaults to `<root>/.timber/dist`. Can be overridden via\n   * `timber.config.ts` `buildDir` or Vite's `build.outDir`.\n   * Timber config takes precedence when both are set.\n   *\n   * Used by adapter-build and cli preview.\n   */\n  buildDir: string;\n  /**\n   * Per-route client reference keys captured during the RSC build.\n   * Maps absolute route file paths to the set of client reference\n   * hash keys they transitively import. Used by adapter-build to\n   * populate per-route modulepreload entries from clientReferenceDeps.\n   */\n  routeClientRefKeys?: Map<string, Set<string>>;\n  /**\n   * Static request-dependency verdict per segment entry file, keyed by the\n   * absolute `filePath` the route scanner produced. Computed once by\n   * `timber-request-dep`'s RSC `buildEnd` and serialized into\n   * `buildManifest.requestDep` by `timber-build-manifest` (build only — dev\n   * answers the same question through the `Symbol.for('timber:request-dep')`\n   * bridge instead).\n   *\n   * `undefined` and `{}` are different states and the difference is the whole\n   * of TIM-1300: an empty object means the analysis ran and found no segments,\n   * `undefined` means it never ran, and the runtime cannot tell them apart —\n   * every key is absent either way, so every segment falls to the conservative\n   * `true` and nothing is ever skipped. The build fails loudly on `undefined`\n   * rather than shipping that silently.\n   */\n  requestDepMap?: Record<string, boolean>;\n  /**\n   * Maps absolute module IDs of client references in non-facade RSC\n   * chunks to the absolute paths of their consuming facade modules.\n   * Built during the RSC `generateBundle` phase by timber-chunks,\n   * consumed by `clientChunkGroup` to reclassify `shared:` modules\n   * that are only used by a single route boundary.\n   * See design/27-chunking-strategy.md, TIM-1107.\n   */\n  sharedModuleFacades?: Map<string, string[]>;\n  /**\n   * Module ID → prebuilt component IDs declared in it. Recorded by the\n   * timber-prebuilt transform (RSC environment, production builds only),\n   * consumed by the RSC `generateBundle` module-graph walk that computes\n   * `routePrebuiltComponents`. See design/44-render-at-build-time.md.\n   */\n  prebuiltModuleComponents?: Map<string, string[]>;\n  /**\n   * Module ID → mapping of variable name to component ID for the prebuilt\n   * components declared in that module. Used at `generateBundle` time to\n   * trace imports from other modules back to specific component IDs.\n   */\n  prebuiltBindingNames?: Map<string, Map<string, string>>;\n  /**\n   * Component ID → distinct static call-site prop objects captured from\n   * JSX usage sites during the transform and generateBundle phases.\n   * Consumed by the post-build capture pass to render with actual props\n   * instead of empty `{}`. See design/44 §Props Derivation.\n   */\n  prebuiltCallSiteProps?: Map<string, Record<string, unknown>[]>;\n  /**\n   * Route file path (page or layout, absolute) → prebuilt component IDs\n   * transitively reachable from it. Computed during RSC `generateBundle`,\n   * consumed by the post-build capture pass (TIM-1119) to decide which\n   * components to render under which route's param combos.\n   */\n  routePrebuiltComponents?: Map<string, string[]>;\n  /**\n   * Page file paths that were desugared from `export const prerender` by\n   * timber-prerender-sugar. The prebuilt transform uses this to verify\n   * the generated `cache.component(...)` call was picked up.\n   */\n  prerenderSugarPages?: Set<string>;\n  /**\n   * Component ID → built chunk file name for prebuilt-declaring modules\n   * that are only reachable via dynamic imports (import.meta.glob, lazy\n   * routes). The capture pass imports these chunks to trigger\n   * cache.component() registration before rendering. Populated during\n   * RSC generateBundle alongside routePrebuiltComponents.\n   */\n  prebuiltLazyChunks?: Map<string, string>;\n  /** Post-build prebuilt capture summary (populated by timber-prebuilt, consumed by build-report). */\n  captureSummary?: CaptureSummary;\n  /**\n   * Content-keyed AST parse memo shared across cache/prebuilt/prerender-sugar\n   * transforms. Collapses both cross-plugin and cross-environment duplicate\n   * parses: identical code hits, rewritten code misses (correct because Vite\n   * transforms chain — a rewrite produces different code). Bounded LRU (32\n   * entries) so it doesn't hold programs for the whole build.\n   *\n   * Consumers MUST treat the returned ProgramNode as read-only — they collect\n   * ranges and rewrite CODE via MagicString; the AST itself is never mutated.\n   */\n  parseCached?: ParseMemo;\n  /**\n   * Content-Type mappings for extensionless static API route outputs.\n   * Populated during static generation, consumed by adapter-build to\n   * write per-path Content-Type rules in _headers. See TIM-1241.\n   */\n  staticContentTypes?: Record<string, string>;\n  /**\n   * RSC flight payload manifest mapping unhashed → hashed URLs.\n   * Populated during static generation, consumed by adapters to set\n   * immutable cache headers for `_rsc/` files. See TIM-1254.\n   */\n  rscManifest?: RscManifest;\n}\n\n// ── AST parse memo ───────────────────────────────────────────────────────\n\nconst PARSE_MEMO_CAPACITY = 32;\n\n/**\n * Content-keyed LRU memo for `parseAst`. Transforms for the same module run\n * back-to-back across plugins and environments, so a tiny window captures the\n * wins. The returned ProgramNode is shared — callers MUST NOT mutate it.\n */\nexport class ParseMemo {\n  private cache = new Map<string, ProgramNode>();\n\n  /**\n   * Parse code, returning a cached ProgramNode if the same code was parsed\n   * before. The returned AST MUST NOT be mutated — it may be shared across\n   * multiple consumers.\n   */\n  parse(code: string): ProgramNode {\n    const existing = this.cache.get(code);\n    if (existing) {\n      // LRU refresh: move to end\n      this.cache.delete(code);\n      this.cache.set(code, existing);\n      return existing;\n    }\n    const program = parseAst(code, { lang: 'tsx' }) as unknown as ProgramNode;\n    if (this.cache.size >= PARSE_MEMO_CAPACITY) {\n      // Evict oldest (first inserted)\n      const firstKey = this.cache.keys().next().value!;\n      this.cache.delete(firstKey);\n    }\n    this.cache.set(code, program);\n    return program;\n  }\n\n  get size(): number {\n    return this.cache.size;\n  }\n}\n\n// ── App directory resolution ──────────────────────────────────────────────\n\n// ── Plugin API (Vite `plugin.api`) ────────────────────────────────────────\n\n/**\n * What `timber-root-sync` publishes on its Vite `plugin.api`.\n *\n * The single supported way to read timber's *resolved* configuration from\n * outside the plugin pipeline. Re-reading `timber.config.ts` is not equivalent:\n * config passed inline as `timber({ ... })` in `vite.config.ts` exists only in\n * the plugin's closure, and `root`/`appDir` are resolved against Vite's root\n * rather than the caller's cwd.\n */\nexport interface TimberPluginApi {\n  /** The live plugin context. Fully populated from `configResolved` onward. */\n  getContext(): PluginContext;\n}\n\n/** Narrow an unknown Vite `plugin.api` to timber's. */\nexport function isTimberPluginApi(api: unknown): api is TimberPluginApi {\n  return (\n    typeof api === 'object' &&\n    api !== null &&\n    'getContext' in api &&\n    typeof api.getContext === 'function'\n  );\n}\n\n/**\n * Resolve the app directory. Checks (in order):\n * 1. Explicit `configAppDir` from timber.config.ts\n * 2. `<root>/app`\n * 3. `<root>/src/app`\n *\n * Throws if none exist.\n */\nexport function resolveAppDir(root: string, configAppDir?: string): string {\n  if (configAppDir) {\n    const explicit = join(root, configAppDir);\n    if (!existsSync(explicit)) {\n      throw new Error(`[timber] Configured appDir \"${configAppDir}\" does not exist at ${explicit}`);\n    }\n    return explicit;\n  }\n\n  const rootApp = join(root, 'app');\n  if (existsSync(rootApp)) return rootApp;\n\n  const srcApp = join(root, 'src', 'app');\n  if (existsSync(srcApp)) return srcApp;\n\n  throw new Error(\n    `[timber] Could not find app directory. Expected \"app/\" or \"src/app/\" in ${root}. ` +\n      `You can set appDir in timber.config.ts to specify a custom location.`\n  );\n}\n\n// ── Plugin context factory ────────────────────────────────────────────────\n\nexport function createPluginContext(config?: TimberUserConfig, root?: string): PluginContext {\n  const projectRoot = root ?? process.cwd();\n  const resolvedConfig: TimberUserConfig = { ...config };\n  return {\n    config: resolvedConfig,\n    clientJavascript: resolveClientJavascript(resolvedConfig),\n    routeTree: null,\n    appDir: join(projectRoot, 'app'),\n    root: projectRoot,\n    dev: false,\n    base: '/',\n    buildManifest: null,\n    deploymentId: null,\n    timer: createStartupTimer(),\n    holdingServer: null,\n    buildDir: resolveBuildDir(projectRoot, resolvedConfig.buildDir),\n    parseCached: new ParseMemo(),\n  };\n}\n\n// ── Build directory resolution ────────────────────────────────────────────\n\n/** Default build output directory (relative to root). */\nexport const DEFAULT_BUILD_DIR = join('.timber', 'dist');\n\n/**\n * Resolve the build output directory.\n *\n * Priority:\n * 1. Explicit `timberBuildDir` from timber.config.ts\n * 2. Explicit `viteBuildOutDir` from Vite's build.outDir (if not the default 'dist')\n * 3. Default: `.timber/dist`\n *\n * Returns an absolute path.\n */\nexport function resolveBuildDir(\n  root: string,\n  timberBuildDir?: string,\n  viteBuildOutDir?: string\n): string {\n  if (timberBuildDir) {\n    return resolve(root, timberBuildDir);\n  }\n  if (viteBuildOutDir && viteBuildOutDir !== 'dist') {\n    return resolve(root, viteBuildOutDir);\n  }\n  return join(root, DEFAULT_BUILD_DIR);\n}\n\n// ── Config file loading ───────────────────────────────────────────────────\n\n/**\n * Map known timber.config load failures to actionable hints (TIM-1040).\n * Returns null when the error has no known remedy beyond its own message.\n *\n * Known failure modes of loading timber.config.ts via native require():\n * - Node < 22.18 has no default type stripping → ERR_UNKNOWN_FILE_EXTENSION\n * - Non-erasable TS syntax (enums, namespaces, parameter properties)\n *   → ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX / ERR_INVALID_TYPESCRIPT_SYNTAX\n * - ESM syntax in a `\"type\": \"commonjs\"` package → the stripped .ts is\n *   parsed as CJS and throws SyntaxError: \"Unexpected token 'export'\"\n *   (export statements) or \"Cannot use import statement outside a\n *   module\" (import statements)\n */\nexport function configLoadHint(configName: string, err: unknown): string | null {\n  const code = (err as NodeJS.ErrnoException | null)?.code;\n  const isTs = configName.endsWith('.ts');\n\n  if (isTs && code === 'ERR_UNKNOWN_FILE_EXTENSION') {\n    return (\n      'Loading a TypeScript config requires Node.js 22.18+ (built-in type stripping). ' +\n      'Upgrade Node.js or rewrite the config as timber.config.js.'\n    );\n  }\n  if (code === 'ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX' || code === 'ERR_INVALID_TYPESCRIPT_SYNTAX') {\n    return (\n      'Node.js loads the config with type stripping, which only supports erasable TypeScript syntax — ' +\n      'replace enums, namespaces, and constructor parameter properties with plain objects and types.'\n    );\n  }\n  if (\n    isTs &&\n    err instanceof SyntaxError &&\n    /Unexpected token '(export|import)'|Cannot use import statement outside a module/.test(\n      err.message\n    )\n  ) {\n    return (\n      'The config uses ESM syntax but Node.js parsed it as CommonJS — ' +\n      'set \"type\": \"module\" in package.json, or use module.exports instead of export default.'\n    );\n  }\n  return null;\n}\n\n/**\n * Load timber.config.ts (or .js, .mjs) from the project root.\n * Returns the config object or null if no config file is found.\n * Throws a descriptive error naming the file when a config file exists\n * but fails to load — a broken config must fail loudly, never silently\n * degrade (see TIM-1066). Known failure modes get an actionable hint\n * appended (see configLoadHint, TIM-1040).\n *\n * Uses require() — Node 22.12+ can require() ESM modules, and Node\n * 22.18+ strips types from .ts files by default (hence the engines\n * field requiring >=22.18.0). This keeps timber() synchronous — no\n * async config loading needed.\n * This is the single config loader — dev, build, and preview all use it.\n */\nexport function loadTimberConfigFile(root: string): TimberUserConfig | null {\n  const configNames = ['timber.config.ts', 'timber.config.js', 'timber.config.mjs'];\n  const req = createRequire(join(root, 'package.json'));\n\n  for (const name of configNames) {\n    const configPath = join(root, name);\n    if (existsSync(configPath)) {\n      try {\n        const mod = req(configPath);\n        return (mod.default ?? mod) as TimberUserConfig;\n      } catch (err) {\n        const message = err instanceof Error ? err.message : String(err);\n        const hint = configLoadHint(name, err);\n        throw new Error(\n          `[timber] Failed to load ${configPath}: ${message}${hint ? `\\n${hint}` : ''}`,\n          { cause: err }\n        );\n      }\n    }\n  }\n  return null;\n}\n\n/**\n * Detect config keys set in both inline (vite.config.ts) and file (timber.config.ts)\n * and warn the user. The `output` key is excluded because it defaults to 'server'\n * in createPluginContext and would always appear as an inline key.\n *\n * Returns the list of conflicting key names (for testing).\n */\nexport function warnConfigConflicts(\n  inline: TimberUserConfig,\n  fileConfig: TimberUserConfig\n): string[] {\n  const conflicts: string[] = [];\n  for (const key of Object.keys(fileConfig) as (keyof TimberUserConfig)[]) {\n    if (key in inline && inline[key] !== undefined) {\n      conflicts.push(key);\n    }\n  }\n  if (conflicts.length > 0) {\n    console.warn(\n      `[timber] Config conflict: ${conflicts.map((k) => `\"${k}\"`).join(', ')} set in both ` +\n        `vite.config.ts (inline) and timber.config.ts. ` +\n        `Move all config to timber.config.ts to avoid confusion. ` +\n        `The inline value from vite.config.ts will be used.`\n    );\n  }\n  return conflicts;\n}\n\n/**\n * Drop own keys whose value is `undefined` so they don't clobber file\n * config during spread merging. `timber({ buildDir: process.env.BUILD_DIR })`\n * with the var unset must not erase the timber.config.ts value.\n */\nfunction stripUndefined<T extends object>(obj: T): T {\n  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined)) as T;\n}\n\n/**\n * Merge file-based config (timber.config.ts) with inline config (vite.config.ts).\n * Inline config takes precedence — file config only fills in missing fields.\n * Inline keys explicitly set to `undefined` are treated as absent, matching\n * the `!== undefined` check in warnConfigConflicts.\n */\nexport function mergeFileConfig(\n  inline: TimberUserConfig,\n  fileConfig: TimberUserConfig\n): TimberUserConfig {\n  warnConfigConflicts(inline, fileConfig);\n  const definedInline = stripUndefined(inline);\n\n  return {\n    ...fileConfig,\n    ...definedInline,\n    ...(fileConfig.limits && definedInline.limits\n      ? { limits: { ...fileConfig.limits, ...stripUndefined(definedInline.limits) } }\n      : {}),\n    ...(fileConfig.dev && definedInline.dev\n      ? { dev: { ...fileConfig.dev, ...stripUndefined(definedInline.dev) } }\n      : {}),\n    ...(fileConfig.mdx && definedInline.mdx\n      ? { mdx: { ...fileConfig.mdx, ...stripUndefined(definedInline.mdx) } }\n      : {}),\n  };\n}\n"],"mappings":"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"}

package/dist/_chunks/poison-rules-DoEhbqaY.js

@@ -0,0 +1,110 @@
+import { isBuiltin } from "node:module";
+//#region src/analyze/poison-rules.ts
+/**
+* poison-rules — single source of truth for server-only / client-only
+* module rules.
+*
+* Two tiers with different enforcement policies (design/47 §3):
+*
+* 1. **Explicit markers** (`server-only`, `client-only`) — evaluation-time
+*    poison pills. `plugins/shims.ts` resolves them to virtual modules
+*    whose body is a top-level `throw` in the wrong environment and a
+*    silent no-op in the right one. The error fires when the module is
+*    evaluated, not at resolve time.
+*
+* 2. **Inferred rules** (`node:*` imports, timber's ALS modules, browser
+*    globals) — report-only. They have legitimate false positives
+*    (`import.meta.env.SSR`-guarded `node:*` use, conditionally-imported
+*    packages), so erroring the build on them would refuse working apps.
+*    The `timber graph` reporter surfaces them as hints.
+*
+* Both shims.ts and the reporter consume this module so the two surfaces
+* can never disagree. Promoting inferred rules to build errors is a
+* policy flip on this list, never a new rule set.
+*
+* Design doc: 47-module-environment-tooling.md §3.
+*/
+var EXPLICIT_MARKERS = [{
+	specifier: "server-only",
+	virtualId: "\0timber:server-only",
+	violatesIn: (env) => env === "client",
+	errorMessage: "This module cannot be imported from a Client Component module. It should only be used from a Server Component.",
+	enforcement: "poison-pill"
+}, {
+	specifier: "client-only",
+	virtualId: "\0timber:client-only",
+	violatesIn: (env) => env !== "client",
+	errorMessage: "This module cannot be imported from a Server Component module. It should only be used from a Client Component.",
+	enforcement: "poison-pill"
+}];
+/**
+* Look up an explicit marker by its import specifier. Throws on an
+* unknown specifier — callers reference rules that must exist, and a
+* silent undefined would just defer the failure.
+*/
+function markerFor(specifier) {
+	const marker = EXPLICIT_MARKERS.find((m) => m.specifier === specifier);
+	if (!marker) throw new Error(`[timber] unknown poison marker: ${specifier}`);
+	return marker;
+}
+/**
+* Generate the virtual module body for an explicit marker in `env`:
+* a top-level throw in the wrong environment, a no-op otherwise.
+*/
+function poisonPillSource(marker, env) {
+	if (marker.violatesIn(env)) return `throw new Error(${JSON.stringify(marker.errorMessage)});`;
+	return "export {};";
+}
+/**
+* Timber modules that hold per-request AsyncLocalStorage state. Importing
+* one from client-reachable code is a strong server-only signal — cf. the
+* no-server-imports-in-isomorphic-define-modules rule.
+*/
+var ALS_MODULE_SPECIFIERS = /* @__PURE__ */ new Set([
+	"@timber-js/app/server",
+	"@timber-js/app/server/internal",
+	"#server-internal"
+]);
+/**
+* The ALS registry module itself, as it appears in import sources.
+* Framework code imports it ESM-style with a `.js` specifier — both
+* `../server/als-registry.js` and sibling `./als-registry.js` forms
+* exist throughout src/server — while resolved module ids carry `.ts`.
+* Matching any path ending in the basename is deliberate: the rule is
+* report-only, and a user file coincidentally named als-registry is a
+* far rarer event than a missed hint on the real one.
+*/
+var ALS_REGISTRY_SUFFIX = /(?:^|\/)als-registry\.(?:ts|js)$/;
+var INFERRED_RULES = [
+	{
+		id: "node-builtin-import",
+		implies: "server-only",
+		enforcement: "report-only",
+		description: "imports a node:* built-in module",
+		matchesImport: (specifier) => specifier.startsWith("node:") && isBuiltin(specifier)
+	},
+	{
+		id: "timber-als-module",
+		implies: "server-only",
+		enforcement: "report-only",
+		description: "imports timber's per-request AsyncLocalStorage modules",
+		matchesImport: (specifier) => ALS_MODULE_SPECIFIERS.has(specifier) || ALS_REGISTRY_SUFFIX.test(specifier)
+	},
+	{
+		id: "browser-global",
+		implies: "client-only",
+		enforcement: "report-only",
+		description: "references a browser-only global",
+		identifiers: [
+			"window",
+			"document",
+			"navigator",
+			"localStorage",
+			"sessionStorage"
+		]
+	}
+];
+//#endregion
+export { poisonPillSource as i, INFERRED_RULES as n, markerFor as r, EXPLICIT_MARKERS as t };
+
+//# sourceMappingURL=poison-rules-DoEhbqaY.js.map