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

package/dist/params/codec-registry.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Client-side registry for schema segment param codecs.
+ *
+ * The Link component uses codec `serialize` functions to convert typed
+ * segment param values back to URL-safe strings. Without this registry,
+ * Link falls back to `String(value)` — which works for simple types
+ * but breaks for custom codecs (e.g., Date → '2026-04-10').
+ *
+ * Populated at startup by the browser entry importing `virtual:timber-schema`.
+ * Also usable on the server (isomorphic).
+ *
+ * Design doc: design/41-global-params.md §"Link Component"
+ */
+import type { Codec } from '../codec.ts';
+/**
+ * Register the resolved schema codecs for use by Link's URL interpolation.
+ * Called once at startup from the browser entry or RSC entry.
+ * @internal
+ */
+export declare function setLinkCodecs(codecs: Record<string, Codec<unknown>> | null): void;
+/**
+ * Look up a codec by bracket key (e.g. '[id]', '[...slug]').
+ * Returns undefined if no schema is registered or the key has no codec.
+ */
+export declare function getLinkCodec(bracketKey: string): Codec<unknown> | undefined;
+//# sourceMappingURL=codec-registry.d.ts.map

package/dist/params/codec-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-registry.d.ts","sourceRoot":"","sources":["../../src/params/codec-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAIzC;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CAEjF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,SAAS,CAE3E"}

package/dist/params/define-schema.d.ts

@@ -0,0 +1,81 @@
+/**
+ * defineSchema — global segment param schema definition.
+ *
+ * Identity function at runtime; the type information is what matters.
+ * The Vite plugin reads the schema at build time for codegen, and
+ * the pipeline reads it at runtime for coercion.
+ *
+ * Design doc: design/41-global-params.md
+ */
+import type { Codec, CatchAllCodec, OptionalCatchAllCodec } from '../codec.ts';
+import type { StandardSchemaV1 } from '../schema-bridge.ts';
+/**
+ * Infer the output type from a Codec, StandardSchemaV1, or nuqs parser.
+ *
+ * Used by codegen to reference schema types without hardcoding:
+ *   `InferCodecType<typeof schema.segmentParams['[year]']>`
+ */
+export type InferCodecType<V> = V extends Codec<infer T> ? T : V extends StandardSchemaV1<infer T> ? T : V extends {
+    parseServerSide: (value: string) => infer T;
+} ? T : string;
+/** Acceptable codec value for segment params: a Codec or Standard Schema. */
+export type SegmentParamCodec = Codec<unknown> | StandardSchemaV1<unknown>;
+/** Codec constraint for catch-all segment keys (`[...name]`). */
+export type CatchAllParamCodec = CatchAllCodec<unknown> | StandardSchemaV1<readonly unknown[]>;
+/** Codec constraint for optional catch-all segment keys (`[[...name]]`). */
+export type OptionalCatchAllParamCodec = OptionalCatchAllCodec<unknown> | StandardSchemaV1<readonly unknown[] | undefined>;
+/**
+ * Resolves the required codec type for a given bracket key pattern.
+ * - `[...name]`    → requires a catch-all codec
+ * - `[[...name]]`  → requires an optional catch-all codec
+ * - `[name]`       → accepts any segment param codec
+ */
+export type CodecForKey<K extends string> = K extends `[[...${string}]]` ? OptionalCatchAllParamCodec : K extends `[...${string}]` ? CatchAllParamCodec : SegmentParamCodec;
+/**
+ * Registry interface augmented by codegen with known filesystem bracket keys.
+ * When empty (no codegen yet), ValidDynamicSegmentKeys falls back to string.
+ */
+export interface ValidDynamicSegmentKeysRegistry {
+}
+/**
+ * Union of valid bracket keys for defineSchema.
+ * After codegen runs, this is the set of filesystem segment names.
+ * Before codegen (fresh project), accepts any string.
+ */
+export type ValidDynamicSegmentKeys = keyof ValidDynamicSegmentKeysRegistry extends never ? string : keyof ValidDynamicSegmentKeysRegistry & string;
+/** Configuration object for defineSchema. */
+export interface SchemaConfig<S extends Record<string, SegmentParamCodec>> {
+    segmentParams: S;
+}
+/**
+ * Define the global segment param schema.
+ *
+ * Each key uses the bracket syntax from the filesystem (`[id]`, `[...slug]`,
+ * `[[...slug]]`) mapped to a codec. This makes the relationship between
+ * filesystem segments and codecs visually obvious.
+ *
+ * A dynamic segment with no key here defaults to `string` at codegen time.
+ *
+ * ```ts
+ * // app/schema.ts
+ * import { defineSchema } from '@timber-js/app/params';
+ * import { codec } from '@timber-js/app/codec';
+ * import { z } from 'zod';
+ *
+ * export default defineSchema({
+ *   segmentParams: {
+ *     '[artistSlug]': codec.string,
+ *     '[year]': codec.integer,
+ *     '[id]': z.coerce.number().int(),
+ *   },
+ * });
+ * ```
+ */
+export declare function defineSchema<S extends {
+    [K in keyof S]: K extends ValidDynamicSegmentKeys ? K extends string ? CodecForKey<K> : SegmentParamCodec : never;
+}>(config: {
+    segmentParams: S;
+}): {
+    segmentParams: S;
+};
+//# sourceMappingURL=define-schema.d.ts.map

package/dist/params/define-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-schema.d.ts","sourceRoot":"","sources":["../../src/params/define-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAC/E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAM5D;;;;;GAKG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAC1B,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GACpB,CAAC,GACD,CAAC,SAAS,gBAAgB,CAAC,MAAM,CAAC,CAAC,GACjC,CAAC,GACD,CAAC,SAAS;IAAE,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,CAAA;CAAE,GACvD,CAAC,GACD,MAAM,CAAC;AAEjB,6EAA6E;AAC7E,MAAM,MAAM,iBAAiB,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;AAE3E,iEAAiE;AACjE,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC,OAAO,CAAC,GAAG,gBAAgB,CAAC,SAAS,OAAO,EAAE,CAAC,CAAC;AAE/F,4EAA4E;AAC5E,MAAM,MAAM,0BAA0B,GAClC,qBAAqB,CAAC,OAAO,CAAC,GAC9B,gBAAgB,CAAC,SAAS,OAAO,EAAE,GAAG,SAAS,CAAC,CAAC;AAErD;;;;;GAKG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,QAAQ,MAAM,IAAI,GACpE,0BAA0B,GAC1B,CAAC,SAAS,OAAO,MAAM,GAAG,GACxB,kBAAkB,GAClB,iBAAiB,CAAC;AAExB;;;GAGG;AAEH,MAAM,WAAW,+BAA+B;CAAG;AAEnD;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG,MAAM,+BAA+B,SAAS,KAAK,GACrF,MAAM,GACN,MAAM,+BAA+B,GAAG,MAAM,CAAC;AAEnD,6CAA6C;AAC7C,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC;IACvE,aAAa,EAAE,CAAC,CAAC;CAClB;AAMD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,YAAY,CAC1B,CAAC,SAAS;KACP,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,SAAS,uBAAuB,GAC7C,CAAC,SAAS,MAAM,GACd,WAAW,CAAC,CAAC,CAAC,GACd,iBAAiB,GACnB,KAAK;CACV,EACD,MAAM,EAAE;IAAE,aAAa,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,aAAa,EAAE,CAAC,CAAA;CAAE,CAEpD"}

package/dist/params/index.d.ts

@@ -0,0 +1,5 @@
+export { defineSchema } from './define-schema.ts';
+export type { InferCodecType, SchemaConfig, SegmentParamCodec, ValidDynamicSegmentKeys, ValidDynamicSegmentKeysRegistry, } from './define-schema.ts';
+export { resolveSchemaCodecs, toBracketKey } from './resolve-schema.ts';
+export { setLinkCodecs, getLinkCodec } from './codec-registry.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/params/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/params/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,YAAY,EACV,cAAc,EACd,YAAY,EACZ,iBAAiB,EACjB,uBAAuB,EACvB,+BAA+B,GAChC,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/params/index.js

@@ -0,0 +1,34 @@
+import { n as toBracketKey, t as resolveSchemaCodecs } from "../_chunks/resolve-schema-CBR6Lm4i.js";
+import { n as setLinkCodecs, t as getLinkCodec } from "../_chunks/codec-registry-oOUxugz3.js";
+//#region src/params/define-schema.ts
+/**
+* Define the global segment param schema.
+*
+* Each key uses the bracket syntax from the filesystem (`[id]`, `[...slug]`,
+* `[[...slug]]`) mapped to a codec. This makes the relationship between
+* filesystem segments and codecs visually obvious.
+*
+* A dynamic segment with no key here defaults to `string` at codegen time.
+*
+* ```ts
+* // app/schema.ts
+* import { defineSchema } from '@timber-js/app/params';
+* import { codec } from '@timber-js/app/codec';
+* import { z } from 'zod';
+*
+* export default defineSchema({
+*   segmentParams: {
+*     '[artistSlug]': codec.string,
+*     '[year]': codec.integer,
+*     '[id]': z.coerce.number().int(),
+*   },
+* });
+* ```
+*/
+function defineSchema(config) {
+	return config;
+}
+//#endregion
+export { defineSchema, getLinkCodec, resolveSchemaCodecs, setLinkCodecs, toBracketKey };
+
+//# sourceMappingURL=index.js.map

package/dist/params/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/params/define-schema.ts"],"sourcesContent":["/**\n * defineSchema — global segment param schema definition.\n *\n * Identity function at runtime; the type information is what matters.\n * The Vite plugin reads the schema at build time for codegen, and\n * the pipeline reads it at runtime for coercion.\n *\n * Design doc: design/41-global-params.md\n */\n\nimport type { Codec, CatchAllCodec, OptionalCatchAllCodec } from '../codec.ts';\nimport type { StandardSchemaV1 } from '../schema-bridge.ts';\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\n/**\n * Infer the output type from a Codec, StandardSchemaV1, or nuqs parser.\n *\n * Used by codegen to reference schema types without hardcoding:\n *   `InferCodecType<typeof schema.segmentParams['[year]']>`\n */\nexport type InferCodecType<V> =\n  V extends Codec<infer T>\n    ? T\n    : V extends StandardSchemaV1<infer T>\n      ? T\n      : V extends { parseServerSide: (value: string) => infer T }\n        ? T\n        : string;\n\n/** Acceptable codec value for segment params: a Codec or Standard Schema. */\nexport type SegmentParamCodec = Codec<unknown> | StandardSchemaV1<unknown>;\n\n/** Codec constraint for catch-all segment keys (`[...name]`). */\nexport type CatchAllParamCodec = CatchAllCodec<unknown> | StandardSchemaV1<readonly unknown[]>;\n\n/** Codec constraint for optional catch-all segment keys (`[[...name]]`). */\nexport type OptionalCatchAllParamCodec =\n  | OptionalCatchAllCodec<unknown>\n  | StandardSchemaV1<readonly unknown[] | undefined>;\n\n/**\n * Resolves the required codec type for a given bracket key pattern.\n * - `[...name]`    → requires a catch-all codec\n * - `[[...name]]`  → requires an optional catch-all codec\n * - `[name]`       → accepts any segment param codec\n */\nexport type CodecForKey<K extends string> = K extends `[[...${string}]]`\n  ? OptionalCatchAllParamCodec\n  : K extends `[...${string}]`\n    ? CatchAllParamCodec\n    : SegmentParamCodec;\n\n/**\n * Registry interface augmented by codegen with known filesystem bracket keys.\n * When empty (no codegen yet), ValidDynamicSegmentKeys falls back to string.\n */\n// eslint-disable-next-line typescript/no-empty-interface -- augmented by codegen\nexport interface ValidDynamicSegmentKeysRegistry {}\n\n/**\n * Union of valid bracket keys for defineSchema.\n * After codegen runs, this is the set of filesystem segment names.\n * Before codegen (fresh project), accepts any string.\n */\nexport type ValidDynamicSegmentKeys = keyof ValidDynamicSegmentKeysRegistry extends never\n  ? string\n  : keyof ValidDynamicSegmentKeysRegistry & string;\n\n/** Configuration object for defineSchema. */\nexport interface SchemaConfig<S extends Record<string, SegmentParamCodec>> {\n  segmentParams: S;\n}\n\n// ---------------------------------------------------------------------------\n// Factory\n// ---------------------------------------------------------------------------\n\n/**\n * Define the global segment param schema.\n *\n * Each key uses the bracket syntax from the filesystem (`[id]`, `[...slug]`,\n * `[[...slug]]`) mapped to a codec. This makes the relationship between\n * filesystem segments and codecs visually obvious.\n *\n * A dynamic segment with no key here defaults to `string` at codegen time.\n *\n * ```ts\n * // app/schema.ts\n * import { defineSchema } from '@timber-js/app/params';\n * import { codec } from '@timber-js/app/codec';\n * import { z } from 'zod';\n *\n * export default defineSchema({\n *   segmentParams: {\n *     '[artistSlug]': codec.string,\n *     '[year]': codec.integer,\n *     '[id]': z.coerce.number().int(),\n *   },\n * });\n * ```\n */\nexport function defineSchema<\n  S extends {\n    [K in keyof S]: K extends ValidDynamicSegmentKeys\n      ? K extends string\n        ? CodecForKey<K>\n        : SegmentParamCodec\n      : never;\n  },\n>(config: { segmentParams: S }): { segmentParams: S } {\n  return config;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAwGA,SAAgB,aAQd,QAAoD;CACpD,OAAO;AACT"}

package/dist/params/resolve-schema.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Schema resolution — resolves the global schema's segmentParams into
+ * a runtime-ready codec map keyed by bracket name (e.g. '[id]').
+ *
+ * Bracket keys are preserved so that `[id]`, `[...id]`, and `[[...id]]`
+ * remain distinct entries. The coercion layer reconstructs bracket keys
+ * from matched segment metadata to look up the correct codec.
+ *
+ * Design doc: design/41-global-params.md §Pipeline Integration
+ */
+import type { Codec } from '../codec.ts';
+/**
+ * Reconstruct the bracket key for a segment from its type and param name.
+ * Used by the coercion layer to look up codecs in the bracket-keyed map.
+ *
+ * 'dynamic'          + 'id'   → '[id]'
+ * 'catch-all'        + 'slug' → '[...slug]'
+ * 'optional-catch-all' + 'slug' → '[[...slug]]'
+ */
+export declare function toBracketKey(segmentType: string, paramName: string): string;
+/**
+ * Resolve the global schema's segmentParams into a map of bracket-keyed
+ * param name → resolved Codec.
+ *
+ * Keys are preserved exactly as written in `app/schema.ts` so that
+ * `[id]`, `[...id]`, and `[[...id]]` remain distinct entries.
+ * The coercion layer in `param-coercion.ts` reconstructs bracket keys
+ * from matched segment metadata to look up the correct codec.
+ *
+ * Input:  { '[id]': z.coerce.number(), '[...slug]': codec.string }
+ * Output: { '[id]': Codec<number>, '[...slug]': Codec<string> }
+ */
+export declare function resolveSchemaCodecs(segmentParams: Record<string, unknown>): Record<string, Codec<unknown>>;
+//# sourceMappingURL=resolve-schema.d.ts.map

package/dist/params/resolve-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-schema.d.ts","sourceRoot":"","sources":["../../src/params/resolve-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGzC;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAS3E;AAaD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACrC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAyBhC"}

package/dist/plugin-context.d.ts

@@ -0,0 +1,276 @@
+/**
+ * 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"
+ */
+import type { RouteTree } from './routing/types.ts';
+import type { BuildManifest } from './server/build-manifest.ts';
+import type { CaptureSummary } from './server/prebuilt-builder.ts';
+import type { StartupTimer } from './utils/startup-timer.ts';
+import type { TimberUserConfig } from './config-types.ts';
+import type { RscManifest } from './plugins/static-build.ts';
+import type { HoldingServer } from './dev-tools/holding-server.ts';
+import type { ProgramNode } from './plugins/callsite-ast.ts';
+export type { TimberUserConfig, ClientJavascriptConfig } from './config-types.ts';
+/** Fully resolved client JavaScript configuration (no optionals). */
+export interface ResolvedClientJavascript {
+    disabled: boolean;
+    enableHMRInDev: boolean;
+}
+/**
+ * Resolve `clientJavascript` into a fully resolved config.
+ */
+export declare function resolveClientJavascript(config: TimberUserConfig): ResolvedClientJavascript;
+/**
+ * Shared context object passed to all sub-plugins via closure.
+ *
+ * Sub-plugins communicate through this context — not through Vite's
+ * plugin API or global state.
+ * See design/18-build-system.md §"Shared Plugin Context".
+ */
+export interface PluginContext {
+    config: TimberUserConfig;
+    /** Resolved client JavaScript configuration */
+    clientJavascript: ResolvedClientJavascript;
+    /** The scanned route tree (populated by timber-routing, consumed by timber-entries) */
+    routeTree: RouteTree | null;
+    /** Absolute path to the app/ directory */
+    appDir: string;
+    /** Absolute path to the project root */
+    root: string;
+    /** Whether the dev server is running (set by timber-root-sync in configResolved) */
+    dev: boolean;
+    /**
+     * Vite's resolved `base` (set by timber-root-sync in configResolved).
+     * Always has a trailing slash; `'/'` unless the app is deployed under a
+     * sub-path. Every URL the framework emits — assets, fonts, RSC payloads —
+     * carries this prefix. This is the single copy: sub-plugins read it here
+     * rather than capturing `config.base` in their own configResolved.
+     *
+     * **Availability:** written by timber-root-sync, which has no `enforce`, so
+     * it is populated from `buildStart`/`load`/`generateBundle`/`configureServer`
+     * onward — but NOT during the `configResolved` of an `enforce: 'pre'`
+     * plugin, which Vite runs first. A pre plugin that needs the base inside
+     * its own `configResolved` must read `config.base` there (timber-fonts
+     * does). See TIM-1261.
+     */
+    base: string;
+    /** CSS build manifest (populated by adapter after client build, null in dev) */
+    buildManifest: BuildManifest | null;
+    /** Per-build deployment ID for version skew detection (null in dev) */
+    deploymentId: string | null;
+    /** Startup timer for profiling cold start phases (active in dev, no-op in prod) */
+    timer: StartupTimer;
+    /** Holding server that binds the port during dev startup (closed in timber-dev-server) */
+    holdingServer?: HoldingServer | null;
+    /**
+     * Resolved absolute path to the build output directory.
+     *
+     * Defaults to `<root>/.timber/dist`. Can be overridden via
+     * `timber.config.ts` `buildDir` or Vite's `build.outDir`.
+     * Timber config takes precedence when both are set.
+     *
+     * Used by adapter-build and cli preview.
+     */
+    buildDir: string;
+    /**
+     * Per-route client reference keys captured during the RSC build.
+     * Maps absolute route file paths to the set of client reference
+     * hash keys they transitively import. Used by adapter-build to
+     * populate per-route modulepreload entries from clientReferenceDeps.
+     */
+    routeClientRefKeys?: Map<string, Set<string>>;
+    /**
+     * Static request-dependency verdict per segment entry file, keyed by the
+     * absolute `filePath` the route scanner produced. Computed once by
+     * `timber-request-dep`'s RSC `buildEnd` and serialized into
+     * `buildManifest.requestDep` by `timber-build-manifest` (build only — dev
+     * answers the same question through the `Symbol.for('timber:request-dep')`
+     * bridge instead).
+     *
+     * `undefined` and `{}` are different states and the difference is the whole
+     * of TIM-1300: an empty object means the analysis ran and found no segments,
+     * `undefined` means it never ran, and the runtime cannot tell them apart —
+     * every key is absent either way, so every segment falls to the conservative
+     * `true` and nothing is ever skipped. The build fails loudly on `undefined`
+     * rather than shipping that silently.
+     */
+    requestDepMap?: Record<string, boolean>;
+    /**
+     * Maps absolute module IDs of client references in non-facade RSC
+     * chunks to the absolute paths of their consuming facade modules.
+     * Built during the RSC `generateBundle` phase by timber-chunks,
+     * consumed by `clientChunkGroup` to reclassify `shared:` modules
+     * that are only used by a single route boundary.
+     * See design/27-chunking-strategy.md, TIM-1107.
+     */
+    sharedModuleFacades?: Map<string, string[]>;
+    /**
+     * Module ID → prebuilt component IDs declared in it. Recorded by the
+     * timber-prebuilt transform (RSC environment, production builds only),
+     * consumed by the RSC `generateBundle` module-graph walk that computes
+     * `routePrebuiltComponents`. See design/44-render-at-build-time.md.
+     */
+    prebuiltModuleComponents?: Map<string, string[]>;
+    /**
+     * Module ID → mapping of variable name to component ID for the prebuilt
+     * components declared in that module. Used at `generateBundle` time to
+     * trace imports from other modules back to specific component IDs.
+     */
+    prebuiltBindingNames?: Map<string, Map<string, string>>;
+    /**
+     * Component ID → distinct static call-site prop objects captured from
+     * JSX usage sites during the transform and generateBundle phases.
+     * Consumed by the post-build capture pass to render with actual props
+     * instead of empty `{}`. See design/44 §Props Derivation.
+     */
+    prebuiltCallSiteProps?: Map<string, Record<string, unknown>[]>;
+    /**
+     * Route file path (page or layout, absolute) → prebuilt component IDs
+     * transitively reachable from it. Computed during RSC `generateBundle`,
+     * consumed by the post-build capture pass (TIM-1119) to decide which
+     * components to render under which route's param combos.
+     */
+    routePrebuiltComponents?: Map<string, string[]>;
+    /**
+     * Page file paths that were desugared from `export const prerender` by
+     * timber-prerender-sugar. The prebuilt transform uses this to verify
+     * the generated `cache.component(...)` call was picked up.
+     */
+    prerenderSugarPages?: Set<string>;
+    /**
+     * Component ID → built chunk file name for prebuilt-declaring modules
+     * that are only reachable via dynamic imports (import.meta.glob, lazy
+     * routes). The capture pass imports these chunks to trigger
+     * cache.component() registration before rendering. Populated during
+     * RSC generateBundle alongside routePrebuiltComponents.
+     */
+    prebuiltLazyChunks?: Map<string, string>;
+    /** Post-build prebuilt capture summary (populated by timber-prebuilt, consumed by build-report). */
+    captureSummary?: CaptureSummary;
+    /**
+     * Content-keyed AST parse memo shared across cache/prebuilt/prerender-sugar
+     * transforms. Collapses both cross-plugin and cross-environment duplicate
+     * parses: identical code hits, rewritten code misses (correct because Vite
+     * transforms chain — a rewrite produces different code). Bounded LRU (32
+     * entries) so it doesn't hold programs for the whole build.
+     *
+     * Consumers MUST treat the returned ProgramNode as read-only — they collect
+     * ranges and rewrite CODE via MagicString; the AST itself is never mutated.
+     */
+    parseCached?: ParseMemo;
+    /**
+     * Content-Type mappings for extensionless static API route outputs.
+     * Populated during static generation, consumed by adapter-build to
+     * write per-path Content-Type rules in _headers. See TIM-1241.
+     */
+    staticContentTypes?: Record<string, string>;
+    /**
+     * RSC flight payload manifest mapping unhashed → hashed URLs.
+     * Populated during static generation, consumed by adapters to set
+     * immutable cache headers for `_rsc/` files. See TIM-1254.
+     */
+    rscManifest?: RscManifest;
+}
+/**
+ * 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.
+ */
+export declare class ParseMemo {
+    private cache;
+    /**
+     * 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: string): ProgramNode;
+    get size(): number;
+}
+/**
+ * What `timber-root-sync` publishes on its Vite `plugin.api`.
+ *
+ * The single supported way to read timber's *resolved* configuration from
+ * outside the plugin pipeline. Re-reading `timber.config.ts` is not equivalent:
+ * config passed inline as `timber({ ... })` in `vite.config.ts` exists only in
+ * the plugin's closure, and `root`/`appDir` are resolved against Vite's root
+ * rather than the caller's cwd.
+ */
+export interface TimberPluginApi {
+    /** The live plugin context. Fully populated from `configResolved` onward. */
+    getContext(): PluginContext;
+}
+/** Narrow an unknown Vite `plugin.api` to timber's. */
+export declare function isTimberPluginApi(api: unknown): api is TimberPluginApi;
+/**
+ * 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.
+ */
+export declare function resolveAppDir(root: string, configAppDir?: string): string;
+export declare function createPluginContext(config?: TimberUserConfig, root?: string): PluginContext;
+/** Default build output directory (relative to root). */
+export declare const DEFAULT_BUILD_DIR: string;
+/**
+ * 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.
+ */
+export declare function resolveBuildDir(root: string, timberBuildDir?: string, viteBuildOutDir?: string): string;
+/**
+ * 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)
+ */
+export declare function configLoadHint(configName: string, err: unknown): string | 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.
+ */
+export declare function loadTimberConfigFile(root: string): TimberUserConfig | 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).
+ */
+export declare function warnConfigConflicts(inline: TimberUserConfig, fileConfig: TimberUserConfig): string[];
+/**
+ * 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.
+ */
+export declare function mergeFileConfig(inline: TimberUserConfig, fileConfig: TimberUserConfig): TimberUserConfig;
+//# sourceMappingURL=plugin-context.d.ts.map

package/dist/plugin-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-context.d.ts","sourceRoot":"","sources":["../src/plugin-context.ts"],"names":[],"mappings":"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"}

package/dist/plugins/adapter-build.d.ts

@@ -13,6 +13,26 @@
  * Design docs: design/11-platform.md, design/25-production-deployments.md
  */
 import type { Plugin } from 'vite';
-import type { PluginContext } from '#/index.js';
+import type { PluginContext } from '../plugin-context.ts';
+import type { BuildManifest } from '../server/build-manifest.ts';
 export declare function timberAdapterBuild(ctx: PluginContext): Plugin;
+/**
+ * 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.
+ */
+/**
+ * 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(buildDir: string, root: string, buildManifest: BuildManifest, routeClientRefKeys?: Map<string, Set<string>>): Promise<void>;
+export declare function stripJsFromRscAssetsManifests(buildDir: string): Promise<void>;
 //# sourceMappingURL=adapter-build.d.ts.map

package/dist/plugins/adapter-build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter-build.d.ts","sourceRoot":"","sources":["../../src/plugins/adapter-build.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAGnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAGhD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAoD7D"}
+{"version":3,"file":"adapter-build.d.ts","sourceRoot":"","sources":["../../src/plugins/adapter-build.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAInC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAIjE,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAgF7D;AAgHD;;;;;;;GAOG;AACH;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,MAAM,EAChB,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,wBAAsB,6BAA6B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA+CnF"}

package/dist/plugins/build-manifest.d.ts

@@ -16,8 +16,8 @@
  * Design docs: 18-build-system.md §"Build Manifest", 02-rendering-pipeline.md §"Early Hints"
  */
 import type { Plugin } from 'vite';
-import type { PluginContext } from '#/index.js';
-import type { BuildManifest } from '#/server/build-manifest.js';
+import type { PluginContext } from '../plugin-context.ts';
+import { type BuildManifest } from '../server/build-manifest.ts';
 interface OutputChunk {
     type: 'chunk';
     fileName: string;
@@ -28,6 +28,10 @@ interface OutputChunk {
     viteMetadata?: {
         importedCss?: Set<string>;
     };
+    modules?: Record<string, {
+        code: string | null;
+        renderedLength: number;
+    }>;
 }
 interface OutputAsset {
     type: 'asset';
@@ -72,7 +76,7 @@ export declare function buildManifestFromBundle(bundle: OutputBundle, base: stri
 /**
  * Create the timber-build-manifest Vite plugin.
  *
- * Hooks: configResolved, resolveId, load, generateBundle (client env only)
+ * Hooks: configResolved, resolveId, load, generateBundle (client and RSC envs)
  */
 export declare function timberBuildManifest(ctx: PluginContext): Plugin;
 export {};

package/dist/plugins/build-manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-manifest.d.ts","sourceRoot":"","sources":["../../src/plugins/build-manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAkB,MAAM,MAAM,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAIhE,UAAU,WAAW;IACnB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;KAAE,CAAC;CAC9C;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,KAAK,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAAC,CAAC;AAK9D;;;GAGG;AACH,UAAU,iBAAiB;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EAC/C,IAAI,EAAE,MAAM,GACX,aAAa,CAmBf;AAqCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,aAAa,CA0Df;AA8BD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAwF9D"}
+{"version":3,"file":"build-manifest.d.ts","sourceRoot":"","sources":["../../src/plugins/build-manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAkB,MAAM,MAAM,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAwB,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAMvF,UAAU,WAAW;IACnB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;KAAE,CAAC;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC3E;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,KAAK,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAAC,CAAC;AAK9D;;;GAGG;AACH,UAAU,iBAAiB;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EAC/C,IAAI,EAAE,MAAM,GACX,aAAa,CAmBf;AAqCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,aAAa,CA0Cf;AA+ID;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAiK9D"}