@timber-js/app 0.2.0-alpha.21 → 0.2.0-alpha.210

package/dist/plugins/prerender-sugar.d.ts

@@ -0,0 +1,39 @@
+/**
+ * timber-prerender-sugar — Vite plugin that desugars `export const prerender`
+ * on page and layout files into `cache.component(...)` wrappers.
+ *
+ * Design doc: design/45-cache-lifetimes.md §"Route-Level Static" and
+ * §"Layout Propagation".
+ *
+ * `export const prerender = true` on a page is pure sugar: it desugars to
+ * wrapping the page's default export in `timber.cache.component(Component,
+ * { prerender: true })`. Layout propagation cascades a layout's
+ * `export const prerender` to descendant pages via most-specific-wins:
+ * walk the segment tree from leaf to root, first explicit value wins.
+ *
+ * Layout declarations are propagation policy only. Layouts receive the real
+ * descendant React element as `children` to preserve the server-layout
+ * containment boundary, so their props are not cache-keyable and the layout
+ * itself must not be registered for capture.
+ *
+ * This transform runs BEFORE timber-prebuilt so the generated
+ * `cache.component(...)` call is picked up by the callsite rewrite.
+ */
+import type { Plugin } from 'vite';
+import type { PluginContext } from '../plugin-context.ts';
+import type { SegmentNode } from '../routing/types.ts';
+import { type PrerenderExportValue } from '../routing/export-detect.ts';
+/**
+ * Walk the segment tree and resolve the effective prerender value for
+ * every page. Returns a map from page file path to resolved value.
+ *
+ * **Pages:** walk from leaf toward root; first explicit `export const prerender`
+ * wins (page > nearest layout > ... > root layout). If none, dynamic.
+ *
+ * **Layouts:** declarations propagate to descendant pages but layouts are not
+ * included in the result. Their real React-element `children` preserve secure
+ * containment and deliberately make child-independent layout caching invalid.
+ */
+export declare function resolvePagePrerender(root: SegmentNode): Map<string, PrerenderExportValue>;
+export declare function timberPrerenderSugar(ctx: PluginContext): Plugin;
+//# sourceMappingURL=prerender-sugar.d.ts.map

package/dist/plugins/prerender-sugar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prerender-sugar.d.ts","sourceRoot":"","sources":["../../src/plugins/prerender-sugar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAa,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAY5F;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CA2BzF;AAuFD,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAwJ/D"}

package/dist/plugins/react-resolve.d.ts

@@ -0,0 +1,49 @@
+/**
+ * timber-react-resolve — Deduplicate React across timber and user project.
+ *
+ * Without this plugin, pnpm's strict isolation can install two physical
+ * copies of React when the user's pinned version differs from timber's
+ * peer dep. Timber's 47 bare `from 'react'` imports resolve to one copy
+ * while react-dom uses the other — causing "Invalid hook call" hydration
+ * crashes with no indication of the real cause.
+ *
+ * The fix: inject `resolve.dedupe` entries so Vite always resolves React
+ * packages from the project root. Unlike `resolve.alias`, `dedupe`
+ * preserves Vite's per-environment export conditions — the RSC
+ * environment still gets the `react-server` build, SSR gets the SSR
+ * build, and the browser gets the browser build. The deduplication
+ * happens at the package level, not the file level.
+ *
+ * A `configResolved` check detects version mismatches between timber's
+ * resolved React and the project's React, and logs an actionable error.
+ *
+ * Design doc: 18-build-system.md §"Module Resolution"
+ * Task: TIM-1520
+ */
+import type { Plugin } from 'vite';
+/**
+ * React packages to deduplicate. Vite's `resolve.dedupe` extracts the
+ * base package name (via `deepImportRE`) before checking, so subpath
+ * specifiers like `react/jsx-runtime` are covered by the base `react`
+ * entry — listing them separately has no effect.
+ */
+export declare const REACT_DEDUPE_PACKAGES: readonly ['react', 'react-dom'];
+export interface ReactVersionMismatch {
+    specifier: string;
+    timberVersion: string;
+    projectVersion: string;
+}
+/**
+ * Check whether timber's React and the user project's React resolve to
+ * the same version. Returns mismatches if any.
+ */
+export declare function detectReactMismatch(projectRoot: string): ReactVersionMismatch[];
+/**
+ * Format React version mismatches as an actionable warning.
+ */
+export declare function formatReactMismatch(mismatches: ReactVersionMismatch[]): string;
+/**
+ * Create the timber-react-resolve Vite plugin.
+ */
+export declare function timberReactResolve(): Plugin;
+//# sourceMappingURL=react-resolve.d.ts.map

package/dist/plugins/react-resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-resolve.d.ts","sourceRoot":"","sources":["../../src/plugins/react-resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,YAAI,OAAO,EAAE,WAAW,CAAU,CAAC;AAsBrE,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAc/E;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,oBAAoB,EAAE,GAAG,MAAM,CA4B9E;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CA8B3C"}

package/dist/plugins/request-dep/analysis.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Per-module syntactic facts for request-dependency analysis.
+ *
+ * This module is deliberately dumb: it records *what the source says*, with no
+ * knowledge of which specifiers or names are interesting. Every judgement —
+ * "is this an accessor", "is this a definition object" — lives in `origin.ts`,
+ * which resolves a binding to the module it actually came from.
+ *
+ * That split is the point. The previous shape asked each module in isolation
+ * "do you import `getSearchParams` from `@timber-js/app/server` and call it",
+ * which any indirection defeats: a barrel re-export, a namespace import, a
+ * factory reached through the app's own `_lib`. Each of those was a separate
+ * hole and each was found separately (TIM-1291). Recording bindings and edges
+ * here, and resolving them across the graph there, closes the family instead of
+ * its members.
+ *
+ * See design/19-client-navigation.md §"Why the slot comparison ignores the query".
+ */
+import type { ProgramNode } from '../callsite-ast.ts';
+/**
+ * One module-graph edge introduced by an `import` or `export … from`.
+ *
+ * `imported` is the name as it exists in the *source* module: an export name,
+ * `'default'`, or `'*'` for a namespace/star form.
+ */
+export interface ImportEdge {
+    source: string;
+    imported: string;
+}
+/** The callee of `const x = f()` / `const x = ns.f()`. */
+export type CalleeRef = {
+    kind: 'local';
+    name: string;
+} | {
+    kind: 'member';
+    object: string;
+    property: string;
+};
+export interface ModuleFacts {
+    /** Local name → the edge that bound it (`import { a as b } from 'x'`). */
+    importedBindings: Map<string, ImportEdge>;
+    /** Exported name → edge, for `export { a as b } from 'x'`. */
+    reExports: Map<string, ImportEdge>;
+    /** Sources of anonymous `export * from 'x'`, in source order. */
+    starReExports: string[];
+    /** Exported name → local name, for `export { x }`, `export const x = …`. */
+    localExports: Map<string, string>;
+    /** Local variable name → the callee that produced its value. */
+    factoryCalls: Map<string, CalleeRef>;
+    /** Local names invoked directly: `f()`. */
+    calledLocals: Set<string>;
+    /** `ns.f()` → `ns` → `{ f }`. */
+    calledMembers: Map<string, Set<string>>;
+    /** Base identifier of a `.get()` chain: `x.get()`, `x().get()`, `x.p.get()`. */
+    getterLocals: Set<string>;
+    /** `ns.defs.get()` → `ns` → `{ defs }`. */
+    getterMembers: Map<string, Set<string>>;
+    /** Every name the module *body* mentions — import/export clauses excluded. */
+    referencedLocals: Set<string>;
+    /** Specifier → resolved module id, filled by the plugin via `this.resolve`. */
+    resolvedSources: Map<string, string>;
+    /** Specifiers that failed to resolve — treated as request-dependent. */
+    unresolvedSources: Set<string>;
+}
+/** `export default` has no local name of its own; this stands in for one. */
+export declare const DEFAULT_EXPORT = "default";
+export declare function createModuleFacts(): ModuleFacts;
+/**
+ * Specifiers the origin walk can actually reach, so the plugin resolves those
+ * and not every import in the file.
+ *
+ * A re-export edge is always reachable — a downstream module can ask for any
+ * name it forwards. An `import` edge is reachable through any local name the
+ * module body mentions, or that it re-exports.
+ *
+ * The name set must be **the same one the taint rules consult**. Deriving it
+ * from the call shapes instead (called, `.get()`d, member-called, minted from)
+ * left `read(filters)` — a definition passed as an argument — with its
+ * specifier unresolved, so the origin walk reported it inert and the page read
+ * as request-independent. Two hand-maintained lists of "names that matter" is
+ * one list too many; this is the one, and `referencedLocals` is a superset of
+ * every call shape by construction, since each of them is an identifier the
+ * walk visits. (Codex review round 1 on PR #991.)
+ */
+export declare function usedSources(facts: ModuleFacts): Set<string>;
+/**
+ * True when the module cannot affect any answer, so its facts need not be kept.
+ *
+ * Every judgement bottoms out at a module edge: a call site resolves through
+ * `importedBindings`, a chain link through `reExports` / `starReExports`. A
+ * module with none of those can only ever resolve to `none` — its exports lead
+ * to locals that lead nowhere — which is exactly what a *missing* entry
+ * produces. Dropping it is behaviour-preserving and keeps the dev-time map from
+ * holding an entry for every leaf module in the graph.
+ */
+export declare function contributesNothing(facts: ModuleFacts): boolean;
+/**
+ * Record every binding, module edge, and call shape in one module.
+ *
+ * Names are recorded without scope analysis, so a parameter that shadows an
+ * imported name is credited to the import. That direction is deliberate: a
+ * needlessly request-dependent segment costs a re-render, a wrongly static one
+ * serves stale content.
+ */
+export declare function analyzeModule(program: ProgramNode): ModuleFacts;
+//# sourceMappingURL=analysis.d.ts.map

package/dist/plugins/request-dep/analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysis.d.ts","sourceRoot":"","sources":["../../../src/plugins/request-dep/analysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EACV,WAAW,EAKZ,MAAM,oBAAoB,CAAC;AAE5B;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,0DAA0D;AAC1D,MAAM,MAAM,SAAS,GACjB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzD,MAAM,WAAW,WAAW;IAC1B,0EAA0E;IAC1E,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAC1C,8DAA8D;IAC9D,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACnC,iEAAiE;IACjE,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,4EAA4E;IAC5E,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,gEAAgE;IAChE,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACrC,2CAA2C;IAC3C,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B,iCAAiC;IACjC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACxC,gFAAgF;IAChF,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B,2CAA2C;IAC3C,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACxC,8EAA8E;IAC9E,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC9B,+EAA+E;IAC/E,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,wEAAwE;IACxE,iBAAiB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAChC;AAED,6EAA6E;AAC7E,eAAO,MAAM,cAAc,YAAY,CAAC;AAExC,wBAAgB,iBAAiB,IAAI,WAAW,CAe/C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CAa3D;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAM9D;AAsRD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,WAAW,GAAG,WAAW,CAsB/D"}

package/dist/plugins/request-dep/index.d.ts

@@ -0,0 +1,75 @@
+/**
+ * timber-request-dep — Static module-graph analysis for request-dependency.
+ *
+ * Replaces runtime ALS-based taint tracking with a build/dev-time computed
+ * map: segment entry file → statically request-dependent?
+ *
+ * A segment/slot is request-dependent iff any module reachable from its
+ * layout/page/default in the RSC module graph (stopping at client-reference
+ * boundaries) reads the request: it calls a request accessor (`getHeaders`,
+ * `getSearchParams`, `cookies`, …) or calls `.get()` on a value minted by
+ * `defineSearchParams` / `defineCookie`.
+ *
+ * "Calls a request accessor" is decided by resolving the call site's binding
+ * back through import and re-export edges (`origin.ts`), not by matching the
+ * calling module's own import declarations. That distinction is the whole
+ * ticket: a barrel, an alias, or a namespace import used to make a page that
+ * reads the query look static, and a static slot is cached and skipped on a
+ * query-only navigation — serving stale content (TIM-1273, TIM-1291).
+ *
+ * This is deterministic, covers children/barrels/node_modules/Suspense-
+ * deferred code, and is computed before any byte is flushed.
+ *
+ * See design/19-client-navigation.md §"X-Timber-State-Tree Header"
+ */
+import type { Plugin } from 'vite';
+import type { PluginContext } from '../../plugin-context.ts';
+import { type ModuleFacts } from './analysis.ts';
+export type { ModuleFacts } from './analysis.ts';
+export { analyzeModule, usedSources } from './analysis.ts';
+export { createOriginResolver } from './origin.ts';
+export declare function isFrameworkModule(id: string): boolean;
+export interface ReachabilityInput {
+    factsMap: ReadonlyMap<string, ModuleFacts>;
+    getImports: (id: string) => string[];
+    /**
+     * Does the graph this walk runs over contain this module at all?
+     *
+     * Only the entry needs asking. Every other id the walk visits comes out of
+     * `getImports`, which enumerates edges the graph already resolved, so those
+     * are known by construction. The entry comes from outside — the route
+     * manifest's `filePath`, produced by the scanner from the filesystem — and
+     * nothing guarantees it is spelled the way the graph spells it, or that the
+     * module has been pulled through the pipeline yet.
+     */
+    isKnownModule: (id: string) => boolean;
+}
+/**
+ * Walk the module graph from an entry, returning true if any module reachable
+ * from it reads the request.
+ *
+ * Two passes, and the second is a deliberately blunt backstop:
+ *
+ * 1. **Binding origins.** For each reachable module, resolve every call site's
+ *    binding to its origin. This is precise and indifferent to indirection.
+ * 2. **Definition reachability.** A module that calls `.get()` on *something*
+ *    it imported, with a module holding a definition factory reachable behind
+ *    that import, counts too. The origin walk cannot see through a value that
+ *    is computed rather than bound — `getFilterCookie(key).get()`, where the
+ *    helper returns a definition — and this pass can.
+ *
+ * The second pass over-reports by construction, which is the safe direction: a
+ * needlessly request-dependent segment costs a re-render, a wrongly static one
+ * serves stale content.
+ *
+ * An entry the graph does not contain is an edge we failed to walk, not the
+ * absence of one — the same rule an unresolvable specifier gets. Without the
+ * check it reads as an entry with no imports and no facts, and both passes fall
+ * through to `false`: confidently request-INdependent, for a module nothing
+ * ever looked at. In the build that answer is worse than no answer, because it
+ * is written into `requestDep` as a definite `false` and the runtime's own
+ * "absent key → conservative" fallback never fires.
+ */
+export declare function isReachableTaintSource(entryId: string, input: ReachabilityInput): boolean;
+export declare function timberRequestDep(ctx: PluginContext): Plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/request-dep/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/request-dep/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D,OAAO,EAAkD,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAGjG,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAInD,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAKrD;AAgCD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAC3C,UAAU,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC;IACrC;;;;;;;;;OASG;IACH,aAAa,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC;CACxC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAgCzF;AAyED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAkI3D"}

package/dist/plugins/request-dep/origin.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Binding-origin resolution across the module graph.
+ *
+ * Given a local name at a call site, walk import and re-export edges until the
+ * binding lands somewhere that can be classified: a framework request accessor,
+ * a definition factory, a definition object minted by one, or nothing of
+ * interest. The walk is what makes the analysis indifferent to how the app
+ * organises its own code — a barrel, an alias, a namespace import, and a
+ * re-export chain five hops deep all reach the same origin (TIM-1291).
+ *
+ * The asymmetry that governs every judgement here: over-reporting costs a
+ * re-render, under-reporting serves stale content to a client that cached a
+ * slot whose render varies with the query. So an edge we cannot follow resolves
+ * to `unknown`, and `unknown` counts as request-dependent.
+ *
+ * See design/19-client-navigation.md §"Why the slot comparison ignores the query".
+ */
+import type { ModuleFacts } from './analysis.ts';
+/** Every specifier the classifier recognises without resolving it. */
+export declare const FRAMEWORK_SOURCES: ReadonlySet<string>;
+export type Origin = 
+/** A request accessor: `getSearchParams`, `cookies`, … */
+{
+    kind: 'accessor';
+}
+/** A definition factory: `defineSearchParams`, `defineCookie`. */
+ | {
+    kind: 'factory';
+}
+/** A value minted by a definition factory — `.get()` on it reads the request. */
+ | {
+    kind: 'definition';
+}
+/** A namespace object for a framework module (`import * as h from 'next/headers'`). */
+ | {
+    kind: 'framework-namespace';
+    source: string;
+}
+/** A namespace object for an app module. */
+ | {
+    kind: 'namespace';
+    moduleId: string;
+}
+/** An edge that could not be followed. Treated as request-dependent. */
+ | {
+    kind: 'unknown';
+}
+/** Resolved, and not interesting. */
+ | {
+    kind: 'none';
+};
+export interface OriginResolver {
+    /** Does this module itself read the request? */
+    isTainted(moduleId: string): boolean;
+    /** Does this module hold a definition factory binding? */
+    isDefinitionModule(moduleId: string): boolean;
+    /** Does this module call `.get()` on a binding it imported? */
+    callsGetterOnImport(moduleId: string): boolean;
+}
+export declare function createOriginResolver(factsMap: ReadonlyMap<string, ModuleFacts>): OriginResolver;
+//# sourceMappingURL=origin.d.ts.map

package/dist/plugins/request-dep/origin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"origin.d.ts","sourceRoot":"","sources":["../../../src/plugins/request-dep/origin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAyB,WAAW,EAAE,MAAM,eAAe,CAAC;AAwBxE,sEAAsE;AACtE,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAGhD,CAAC;AAIH,MAAM,MAAM,MAAM;AAChB,0DAA0D;AACxD;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE;AACtB,kEAAkE;GAChE;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE;AACrB,iFAAiF;GAC/E;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE;AACxB,uFAAuF;GACrF;IAAE,IAAI,EAAE,qBAAqB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AACjD,4CAA4C;GAC1C;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE;AACzC,wEAAwE;GACtE;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE;AACrB,qCAAqC;GACnC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAkCrB,MAAM,WAAW,cAAc;IAC7B,gDAAgD;IAChD,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IACrC,0DAA0D;IAC1D,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IAC9C,+DAA+D;IAC/D,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;CAChD;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,cAAc,CA0M/F"}

package/dist/plugins/routing.d.ts

@@ -8,6 +8,6 @@
  * Design docs: 18-build-system.md §"Virtual Modules", 07-routing.md
  */
 import type { Plugin } from 'vite';
-import type { PluginContext } from '#/index.js';
+import type { PluginContext } from '../plugin-context.ts';
 export declare function timberRouting(ctx: PluginContext): Plugin;
 //# sourceMappingURL=routing.d.ts.map

package/dist/plugins/routing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../../src/plugins/routing.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,MAAM,CAAC;AAWlD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AA2DhD,wBAAgB,aAAa,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CA2GxD"}
+{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../../src/plugins/routing.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,MAAM,CAAC;AAYlD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAoD1D,wBAAgB,aAAa,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAwRxD"}

package/dist/plugins/rsc-assets-manifest.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The RSC plugin's assets manifest (`__vite_rsc_assets_manifest.js`) — read
+ * into the build manifest, and stripped of JavaScript when client JS is off.
+ *
+ * The RSC plugin writes the file to rsc/ and ssr/ as a standalone file, not
+ * a Rollup chunk, so no `generateBundle` can intercept it; both operations
+ * work on the written files. Both run once, from the post-build phase's
+ * manifest finalization step (plugins/post-build.ts), before anything
+ * imports the built bundle.
+ *
+ * Design doc: 18-build-system.md §"Post-Build Phase"
+ */
+import type { BuildManifest } from '../server/build-manifest.ts';
+/**
+ * Read the RSC plugin's assets manifest and merge per-route CSS and
+ * per-route JS modulepreloads into the build manifest.
+ *
+ * CSS: `serverResources` maps server component paths to CSS URLs.
+ * JS: `clientReferenceDeps` maps reference hashes to JS dep URLs.
+ *     Combined with `routeClientRefKeys` (from the RSC generateBundle
+ *     module graph walk) to produce per-route modulepreload entries.
+ */
+export declare function mergeRscAssetsManifest(rscDir: string, root: string, buildManifest: BuildManifest, routeClientRefKeys?: Map<string, Set<string>>): Promise<void>;
+/**
+ * Strip JS references from the RSC plugin's assets manifest files.
+ *
+ * The RSC plugin writes `__vite_rsc_assets_manifest.js` to rsc/ and ssr/
+ * as standalone files (not Rollup chunks), so generateBundle can't
+ * intercept them. This rewrites the files on disk after all builds
+ * complete but before the adapter copies them to the output directory.
+ */
+export declare function stripJsFromRscAssetsManifests(serverDirs: string[]): Promise<void>;
+//# sourceMappingURL=rsc-assets-manifest.d.ts.map

package/dist/plugins/rsc-assets-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsc-assets-manifest.d.ts","sourceRoot":"","sources":["../../src/plugins/rsc-assets-manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAiHjE;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,aAAa,EAC5B,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,GAC5C,OAAO,CAAC,IAAI,CAAC,CAmDf;AAED;;;;;;;GAOG;AACH,wBAAsB,6BAA6B,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA8CvF"}

package/dist/plugins/server-bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server-bundle.d.ts","sourceRoot":"","sources":["../../src/plugins/server-bundle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEnC,wBAAgB,kBAAkB,IAAI,MAAM,EAAE,CA6H7C"}
+{"version":3,"file":"server-bundle.d.ts","sourceRoot":"","sources":["../../src/plugins/server-bundle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AA4CnC,wBAAgB,kBAAkB,IAAI,MAAM,EAAE,CAuK7C"}

package/dist/plugins/shims.d.ts

@@ -5,15 +5,39 @@
  * shim implementations. This enables Next.js-compatible libraries
  * (nuqs, next-intl, etc.) to work unmodified.
  *
- * NOTE: This plugin does NOT resolve @timber-js/app/* subpath imports.
- * Those are handled by Vite's native package.json `exports` resolution,
- * which maps them to dist/ files. This ensures a single module instance
- * for shared modules like request-context (ALS singleton).
+ * This plugin also remaps ALL @timber-js/app/* subpath imports to src/ in
+ * server environments (RSC + SSR). This is required because dist/ chunks
+ * are pre-built and miss Vite's RSC transforms (e.g. createContext from
+ * 'react' doesn't exist in RSC's React build). It also ensures a single
+ * module instance for shared mutable state. See SUBPATH_SRC_MAP and TIM-568.
  *
  * Design doc: 18-build-system.md §"Shim Map"
  */
 import type { Plugin } from 'vite';
-import type { PluginContext } from '#/index.js';
+import type { PluginContext } from '../plugin-context.ts';
+/**
+ * Map from @timber-js/app/<subpath> to relative src/ file paths.
+ *
+ * Used by the catch-all resolveId rule to remap subpath imports to src/
+ * in server environments. When adding a new subpath export to package.json,
+ * add it here too — tests/shims-drift.test.ts enumerates package.json
+ * exports and fails if an entry is missing. See TIM-568.
+ *
+ * Exported for the drift test.
+ */
+export declare const SUBPATH_SRC_MAP: Record<string, string>;
+/**
+ * Runtime value exports of @timber-js/app/server, stubbed in the client
+ * (browser) environment so a stray client-side import fails with a clear
+ * call-time error instead of a confusing bundler error.
+ *
+ * Must stay in sync with the actual runtime exports of server/index.ts —
+ * tests/shims-drift.test.ts compares this list against
+ * Object.keys(import('../server/index.ts')) and fails on drift.
+ * Type-only exports (DenyOptions, AccessContext, …) are erased at runtime
+ * and must NOT appear here.
+ */
+export declare const SERVER_STUB_EXPORTS: readonly string[];
 /**
  * Create the timber-shims Vite plugin.
  *

package/dist/plugins/shims.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shims.d.ts","sourceRoot":"","sources":["../../src/plugins/shims.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAGnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAiDhD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CA4JvD"}
+{"version":3,"file":"shims.d.ts","sourceRoot":"","sources":["../../src/plugins/shims.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAGnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAsB1D;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAsBlD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EA6BhD,CAAC;AA2CF;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAoOvD"}