@timber-js/app 0.1.0

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

@@ -0,0 +1,18 @@
+/**
+ * timber-adapter-build — Invoke the adapter's buildOutput after vite build.
+ *
+ * After all environments are built and the RSC plugin has written its
+ * asset manifests, calls `adapter.buildOutput()` to transform the output
+ * into a deployable artifact (e.g., Cloudflare Workers entry + wrangler.jsonc).
+ *
+ * Uses a `buildApp` hook with `order: 'post'` so that Vite calls the
+ * RSC plugin's buildApp (which orchestrates all environment builds and
+ * writes asset manifests) first, then runs this handler after everything
+ * is complete.
+ *
+ * Design docs: design/11-platform.md, design/25-production-deployments.md
+ */
+import type { Plugin } from 'vite';
+import type { PluginContext } from '#/index.js';
+export declare function timberAdapterBuild(ctx: PluginContext): Plugin;
+//# sourceMappingURL=adapter-build.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,79 @@
+/**
+ * timber-build-manifest — Vite sub-plugin for build asset manifest generation.
+ *
+ * Provides `virtual:timber-build-manifest` which exports a BuildManifest
+ * mapping route segment file paths to their CSS, JS, and modulepreload
+ * output chunks.
+ *
+ * - Dev mode: exports an empty manifest (Vite HMR handles CSS/JS).
+ * - Build mode: virtual module reads from globalThis.__TIMBER_BUILD_MANIFEST__
+ *   at runtime. The actual manifest data is injected by the adapter via a
+ *   _timber-manifest-init.js module that runs before the RSC handler.
+ *
+ * The generateBundle hook (client env only) extracts CSS/JS/modulepreload
+ * data from the Rollup bundle and populates ctx.buildManifest.
+ *
+ * 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';
+interface OutputChunk {
+    type: 'chunk';
+    fileName: string;
+    facadeModuleId: string | null;
+    imports: string[];
+    name: string;
+    code: string;
+    viteMetadata?: {
+        importedCss?: Set<string>;
+    };
+}
+interface OutputAsset {
+    type: 'asset';
+    fileName: string;
+}
+type OutputBundle = Record<string, OutputChunk | OutputAsset>;
+/**
+ * Vite's manifest.json entry shape (subset we need).
+ * See https://vite.dev/guide/backend-integration.html
+ */
+interface ViteManifestEntry {
+    file: string;
+    css?: string[];
+    imports?: string[];
+}
+/**
+ * Parse Vite's .vite/manifest.json into a BuildManifest.
+ *
+ * Walks each entry and collects:
+ * - `css`: CSS output URLs per input file (transitive CSS included by Vite)
+ * - `js`: Hashed JS chunk URL per input file
+ * - `modulepreload`: Transitive JS dependency URLs per input file
+ *
+ * Keys are input file paths (relative to project root).
+ */
+export declare function parseViteManifest(viteManifest: Record<string, ViteManifestEntry>, base: string): BuildManifest;
+/**
+ * Build a BuildManifest from a Rollup output bundle.
+ *
+ * Unlike parseViteManifest (which reads Vite's manifest.json), this
+ * works directly with the Rollup bundle output. This is necessary because
+ * the RSC plugin doesn't produce a standard Vite manifest.json.
+ *
+ * Walks each chunk in the bundle and collects:
+ * - `css`: CSS files imported by each chunk (via viteMetadata.importedCss)
+ * - `js`: The output filename for each chunk with a facadeModuleId
+ * - `modulepreload`: Transitive JS imports for each entry chunk
+ *
+ * Keys are input file paths relative to root.
+ */
+export declare function buildManifestFromBundle(bundle: OutputBundle, base: string, root: string): BuildManifest;
+/**
+ * Create the timber-build-manifest Vite plugin.
+ *
+ * Hooks: configResolved, resolveId, load, generateBundle (client env only)
+ */
+export declare function timberBuildManifest(ctx: PluginContext): Plugin;
+export {};
+//# sourceMappingURL=build-manifest.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,63 @@
+/**
+ * timber-build-report — Post-build route summary table.
+ *
+ * After a production build, logs a per-route table showing:
+ * - Route type (○ static, λ dynamic, ƒ function)
+ * - Route-specific client JS size
+ * - First-load JS size (gzip) — route-specific + shared chunks
+ *
+ * Only active during production builds. Sizes are computed from the
+ * already-generated Vite client bundle — no extra analysis passes.
+ *
+ * Design docs: 18-build-system.md §"Build Pipeline", 07-routing.md
+ * Task: TIM-287
+ */
+import type { Plugin } from 'vite';
+import type { PluginContext } from '#/index.js';
+import type { SegmentNode, RouteTree } from '#/routing/types.js';
+import { formatSize } from '#/utils/format.js';
+export type RouteType = 'static' | 'dynamic' | 'function';
+export interface RouteEntry {
+    path: string;
+    type: RouteType;
+    /** Route-specific client JS size in bytes (raw). */
+    size: number;
+    /** Total first-load JS in bytes (gzip): route-specific + shared. */
+    firstLoadSize: number;
+}
+/**
+ * Classify a route by its segment chain and output mode.
+ *
+ * In server mode (default), all pages are dynamic (rendered per-request).
+ * In static mode, only pages with dynamic/catch-all segments are dynamic.
+ * API routes (route.ts) are always classified as function.
+ */
+export declare function classifyRoute(segments: SegmentNode[], outputMode?: 'server' | 'static'): RouteType;
+export { formatSize };
+interface RouteInfo {
+    path: string;
+    segments: SegmentNode[];
+    entryFilePath: string | null;
+}
+/** Walk the route tree and collect all leaf routes (pages + API endpoints). */
+export declare function collectRoutes(tree: RouteTree): RouteInfo[];
+/** Produce formatted report lines for the Vite logger. */
+export declare function buildRouteReport(entries: RouteEntry[], sharedSize: number): string[];
+interface ChunkSize {
+    raw: number;
+    gzip: number;
+}
+interface OutputChunkLike {
+    type: 'chunk' | 'asset';
+    fileName: string;
+    code?: string;
+    source?: string | Uint8Array;
+    modules?: Record<string, unknown>;
+    facadeModuleId?: string | null;
+}
+/** Measure raw + gzip sizes for all JS chunks and CSS assets in a bundle. */
+export declare function collectChunkSizes(bundle: Record<string, OutputChunkLike>): Map<string, ChunkSize>;
+/** Find the output chunk that contains a given input file. */
+export declare function findChunkForFile(filePath: string, bundle: Record<string, OutputChunkLike>): string | null;
+export declare function timberBuildReport(ctx: PluginContext): Plugin;
+//# sourceMappingURL=build-report.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build-report.d.ts","sourceRoot":"","sources":["../../src/plugins/build-report.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAU,MAAM,MAAM,CAAC;AAC3C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAI/C,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;AAE1D,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,SAAS,CAAC;IAChB,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,aAAa,EAAE,MAAM,CAAC;CACvB;AAUD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,WAAW,EAAE,EACvB,UAAU,GAAE,QAAQ,GAAG,QAAmB,GACzC,SAAS,CAYX;AAID,OAAO,EAAE,UAAU,EAAE,CAAC;AAQtB,UAAU,SAAS;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,EAAE,CAoB1D;AAID,0DAA0D;AAC1D,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAyCpF;AAcD,UAAU,SAAS;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,eAAe;IACvB,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAYjG;AAOD,8DAA8D;AAC9D,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GACtC,MAAM,GAAG,IAAI,CAOf;AAwED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAwE5D"}

package/dist/plugins/cache-transform.d.ts

@@ -0,0 +1,36 @@
+import type { Plugin } from 'vite';
+/**
+ * Parse a cacheLife duration string to seconds.
+ * Supports: '30s', '5m', '1h', '2d', '1w', or a plain number (seconds).
+ */
+export declare function parseCacheLife(value: string | number): number;
+export interface CacheTransformWarning {
+    message: string;
+    functionName: string;
+}
+interface TransformResult {
+    code: string;
+    map?: null;
+    warnings?: CacheTransformWarning[];
+}
+/**
+ * Check if a 'use cache' function in a dynamic route page/layout receives
+ * Promise-typed params, which are not serializable as cache keys.
+ */
+export declare function detectPromiseParamsWarning(declaration: string, functionName: string, fileId: string): CacheTransformWarning | null;
+/**
+ * Transform source code containing 'use cache' directives into
+ * registerCachedFunction() calls.
+ *
+ * Returns null if no transformations were made.
+ */
+export declare function transformUseCache(code: string, fileId: string): TransformResult | null;
+/**
+ * Vite plugin: timber-cache
+ *
+ * Transforms 'use cache' directives into registerCachedFunction() calls.
+ * Only runs in the RSC environment.
+ */
+export declare function cacheTransformPlugin(): Plugin;
+export {};
+//# sourceMappingURL=cache-transform.d.ts.map

package/dist/plugins/cache-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-transform.d.ts","sourceRoot":"","sources":["../../src/plugins/cache-transform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAGnC;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAc7D;AAKD,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,IAAI,CAAC;IACX,QAAQ,CAAC,EAAE,qBAAqB,EAAE,CAAC;CACpC;AAmDD;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,GACb,qBAAqB,GAAG,IAAI,CAW9B;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAuDtF;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAsB7C"}

package/dist/plugins/chunks.d.ts

@@ -0,0 +1,45 @@
+/**
+ * timber-chunks — Vite sub-plugin for intelligent client chunk splitting.
+ *
+ * Splits client bundles into cache tiers based on update frequency:
+ *
+ * Tier 1: vendor-react  — react, react-dom, scheduler (changes rarely)
+ * Tier 2: vendor-timber — timber runtime, RSC runtime (changes per framework update)
+ * Tier 3: [route]-*     — per-route app code (changes per deploy, handled by Vite defaults)
+ *
+ * Server environments (RSC, SSR) are left to Vite's default chunking since
+ * Cloudflare Workers load all code from a single deployment bundle with no
+ * benefit from cache-tier separation.
+ *
+ * Design docs: 27-chunking-strategy.md
+ */
+import type { Plugin } from 'vite';
+/**
+ * Categorize a module ID into a cache tier chunk name.
+ *
+ * Returns a chunk name for vendor modules, or undefined to let
+ * Rollup's default splitting handle app/route code.
+ */
+export declare function assignChunk(id: string): string | undefined;
+/**
+ * Group timber's internal 'use client' modules into the vendor-timber chunk.
+ *
+ * The RSC plugin creates separate entry points for each 'use client' module,
+ * which manualChunks can't merge. This function is passed as the RSC plugin's
+ * `clientChunks` callback to group timber internals into a single chunk.
+ * User and third-party client components are left to default per-route splitting.
+ */
+export declare function assignClientChunk(meta: {
+    id: string;
+    normalizedId: string;
+    serverChunk: string;
+}): string | undefined;
+/**
+ * Create the timber-chunks Vite plugin.
+ *
+ * Uses Vite's per-environment config to apply manualChunks only to
+ * the client build. The config hook runs before environments are
+ * created, so we use `environments.client` to target the client.
+ */
+export declare function timberChunks(): Plugin;
+//# sourceMappingURL=chunks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunks.d.ts","sourceRoot":"","sources":["../../src/plugins/chunks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEnC;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAoB1D;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,MAAM,GAAG,SAAS,CAErB;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAoBrC"}

package/dist/plugins/content.d.ts

@@ -0,0 +1,19 @@
+/**
+ * timber-content — Vite sub-plugin for content collections.
+ *
+ * Wraps @content-collections/vite to provide content collection support.
+ * Activates only when a content-collections.ts config file exists at the
+ * project root.
+ *
+ * Design doc: 20-content-collections.md §"Content Collections"
+ */
+import type { Plugin } from 'vite';
+import type { PluginContext } from '#/index.js';
+/**
+ * Create the timber-content Vite plugin.
+ *
+ * Delegates all content scanning, validation, code generation, and file watching
+ * to @content-collections/vite. This plugin only handles detection and activation.
+ */
+export declare function timberContent(ctx: PluginContext): Plugin;
+//# sourceMappingURL=content.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../src/plugins/content.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAGnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAoBhD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAgGxD"}

package/dist/plugins/dev-error-overlay.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Dev error overlay — formats and sends errors to Vite's browser overlay and stderr.
+ *
+ * Integrates with Vite's built-in error overlay (`server.ssrFixStacktrace` +
+ * `server.hot.send`) rather than implementing a custom overlay.
+ *
+ * Design doc: 21-dev-server.md §"Error Overlay"
+ */
+import type { ViteDevServer } from 'vite';
+/** The phase of the pipeline where the error occurred. */
+export type ErrorPhase = 'module-transform' | 'proxy' | 'middleware' | 'access' | 'render' | 'handler';
+export type FrameType = 'app' | 'framework' | 'internal';
+/**
+ * Classify a stack frame line by origin.
+ *
+ * - 'app': user application code (in project root, not node_modules)
+ * - 'framework': timber-app internal code
+ * - 'internal': node_modules, Node.js internals
+ */
+export declare function classifyFrame(frameLine: string, projectRoot: string): FrameType;
+/**
+ * Extract the React component stack from an error, if present.
+ * React attaches this as `componentStack` during renderToReadableStream errors.
+ */
+export declare function extractComponentStack(error: unknown): string | null;
+interface SourceLocation {
+    file: string;
+    line: number;
+    column: number;
+}
+/**
+ * Parse the first application frame from a stack trace.
+ * Returns file/line/column for the overlay's `loc` field.
+ */
+export declare function parseFirstAppFrame(stack: string, projectRoot: string): SourceLocation | null;
+/**
+ * Classify the error phase by inspecting the error's stack trace.
+ * Falls back to 'render' if no specific phase can be determined.
+ */
+export declare function classifyErrorPhase(error: Error, projectRoot: string): ErrorPhase;
+/**
+ * Format an error for terminal output.
+ *
+ * - Red for the error message and phase label
+ * - Dim for framework-internal frames
+ * - Normal for application frames
+ * - Separate section for component stack (if present)
+ */
+export declare function formatTerminalError(error: Error, phase: ErrorPhase, projectRoot: string): string;
+/**
+ * Send an error to Vite's browser overlay and log it to stderr.
+ *
+ * Uses `server.ssrFixStacktrace()` to map stack traces back to source,
+ * then sends the error via `server.hot.send()` for the browser overlay.
+ *
+ * The dev server remains running — errors are handled, not fatal.
+ */
+export declare function sendErrorToOverlay(server: ViteDevServer, error: Error, phase: ErrorPhase, projectRoot: string): void;
+export {};
+//# sourceMappingURL=dev-error-overlay.d.ts.map

package/dist/plugins/dev-error-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-error-overlay.d.ts","sourceRoot":"","sources":["../../src/plugins/dev-error-overlay.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAI1C,0DAA0D;AAC1D,MAAM,MAAM,UAAU,GAClB,kBAAkB,GAClB,OAAO,GACP,YAAY,GACZ,QAAQ,GACR,QAAQ,GACR,SAAS,CAAC;AAcd,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,WAAW,GAAG,UAAU,CAAC;AAEzD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,SAAS,CAU/E;AAID;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAUnE;AAID,UAAU,cAAc;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAqB5F;AAID;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,GAAG,UAAU,CAehF;AAUD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAiChG;AAID;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,UAAU,EACjB,WAAW,EAAE,MAAM,GAClB,IAAI,CAgCN"}

package/dist/plugins/dev-logs.d.ts

@@ -0,0 +1,46 @@
+/**
+ * timber-dev-logs — Pipes server console output to the browser console in dev.
+ *
+ * Patches `console.log/warn/error/debug/info` on the server side and
+ * forwards messages to connected browsers via Vite's HMR WebSocket.
+ * The browser entry replays them in the browser console with the
+ * correct log level and a "[server]" prefix.
+ *
+ * Dev-only: this plugin only runs during `vite dev` (apply: 'serve').
+ * No runtime overhead in production.
+ *
+ * Design docs: 18-build-system.md §"Dev Server", 02-rendering-pipeline.md
+ */
+import type { Plugin } from 'vite';
+import type { PluginContext } from '#/index.js';
+/** Log levels that are patched and forwarded. */
+export type ServerLogLevel = 'log' | 'warn' | 'error' | 'debug' | 'info';
+/** Payload sent over Vite's HMR WebSocket. */
+export interface ServerLogPayload {
+    level: ServerLogLevel;
+    args: unknown[];
+    /** Server-side source location (file:line:col) if available. */
+    location: string | null;
+    /** Timestamp in ms (Date.now()) */
+    timestamp: number;
+}
+/**
+ * Check if the calling code is from timber's internal plugin/adapter plumbing.
+ *
+ * Only filters logs from `plugins/` and `adapters/` directories — these are
+ * framework operational noise (request summaries, codegen warnings, adapter
+ * setup). Logs from `server/` are preserved because they surface user errors
+ * (render errors, action errors, route handler errors, etc.).
+ *
+ * Handles both monorepo paths (timber-app/src/plugins/) and installed
+ * package paths (@timber/app/dist/plugins/).
+ */
+export declare function isFrameworkInternalCaller(): boolean;
+/**
+ * Create the timber-dev-logs Vite plugin.
+ *
+ * Patches console methods when the dev server starts and restores them
+ * when the server closes. Only active during `vite dev`.
+ */
+export declare function timberDevLogs(_ctx: PluginContext): Plugin;
+//# sourceMappingURL=dev-logs.d.ts.map

package/dist/plugins/dev-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-logs.d.ts","sourceRoot":"","sources":["../../src/plugins/dev-logs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,MAAM,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAIhD,iDAAiD;AACjD,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;AAIzE,8CAA8C;AAC9C,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,cAAc,CAAC;IACtB,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,gEAAgE;IAChE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;CACnB;AA2ID;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAsBnD;AAoDD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAiBzD"}

package/dist/plugins/dev-server.d.ts

@@ -0,0 +1,22 @@
+/**
+ * timber-dev-server — Vite sub-plugin for dev server request handling.
+ *
+ * Registers a configureServer middleware that intercepts requests and
+ * routes them through the timber pipeline:
+ *   proxy.ts → canonicalize → route match → middleware → access → render → flush
+ *
+ * The RSC entry module is loaded via Vite's ssrLoadModule, which uses
+ * Vite's dev module graph instead of built bundles. The full pipeline
+ * (including proxy.ts) runs on every request.
+ *
+ * Design docs: 18-build-system.md §"Dev Server", 02-rendering-pipeline.md
+ */
+import type { Plugin } from 'vite';
+import type { PluginContext } from '#/index.js';
+/**
+ * Create the timber-dev-server Vite plugin.
+ *
+ * Hook: configureServer (returns post-hook to register after Vite's middleware)
+ */
+export declare function timberDevServer(ctx: PluginContext): Plugin;
+//# sourceMappingURL=dev-server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dev-server.d.ts","sourceRoot":"","sources":["../../src/plugins/dev-server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,MAAM,CAAC;AAIlD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAiChD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAmD1D"}

package/dist/plugins/dynamic-transform.d.ts

@@ -0,0 +1,72 @@
+/**
+ * timber-dynamic-transform — Vite sub-plugin for 'use dynamic' directive.
+ *
+ * Detects `'use dynamic'` directives in server component function bodies
+ * and transforms them into `markDynamic()` runtime calls. The directive
+ * declares a dynamic boundary — the component and its subtree opt out of
+ * the pre-rendered shell and render per-request.
+ *
+ * - In `output: 'static'` mode, `'use dynamic'` is a build error.
+ * - In standard SSR routes (no prerender.ts), the directive is a no-op
+ *   (everything is already per-request), but the transform still runs
+ *   so the runtime can skip unnecessary work.
+ *
+ * Design doc: design/15-future-prerendering.md §"'use dynamic'"
+ */
+import type { Plugin } from 'vite';
+import type { PluginContext } from '#/index.js';
+/**
+ * Quick check: does this source file contain 'use dynamic' anywhere?
+ * Used as a fast bail-out before doing expensive AST parsing.
+ */
+export declare function containsUseDynamic(code: string): boolean;
+interface TransformResult {
+    code: string;
+    map?: null;
+}
+/**
+ * Find function declarations/expressions containing 'use dynamic' and
+ * transform them into markDynamic() calls.
+ *
+ * Input:
+ * ```tsx
+ * export default async function AddToCartButton({ productId }) {
+ *   'use dynamic'
+ *   const user = await getUser()
+ *   return <button>Add to cart</button>
+ * }
+ * ```
+ *
+ * Output:
+ * ```tsx
+ * import { markDynamic as __markDynamic } from '@timber/app/runtime';
+ * export default async function AddToCartButton({ productId }) {
+ *   __markDynamic();
+ *   const user = await getUser()
+ *   return <button>Add to cart</button>
+ * }
+ * ```
+ *
+ * The markDynamic() call registers the component boundary as dynamic
+ * at render time. The pre-render pass uses this to know which subtrees
+ * to skip and leave as holes for per-request rendering.
+ */
+export declare function transformUseDynamic(code: string): TransformResult | null;
+/**
+ * In `output: 'static'` mode, `'use dynamic'` is a build error.
+ * Static mode renders everything at build time — there is no per-request
+ * rendering to opt into.
+ */
+export declare function validateNoDynamicInStaticMode(code: string): {
+    message: string;
+    line?: number;
+} | null;
+/**
+ * Create the timber-dynamic-transform Vite plugin.
+ *
+ * In server mode: transforms 'use dynamic' into markDynamic() calls.
+ * In static mode: rejects 'use dynamic' as a build error.
+ */
+export declare function timberDynamicTransform(ctx: PluginContext): Plugin;
+export {};
+//# sourceMappingURL=dynamic-transform.d.ts.map

package/dist/plugins/dynamic-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-transform.d.ts","sourceRoot":"","sources":["../../src/plugins/dynamic-transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAOhD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAMD,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,IAAI,CAAC;CACZ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAoBxE;AAMD;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,MAAM,GACX;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAa3C;AAMD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAkCjE"}

package/dist/plugins/entries.d.ts

@@ -0,0 +1,21 @@
+/**
+ * timber-entries — Vite sub-plugin for entry virtual module resolution.
+ *
+ * Resolves virtual:timber-rsc-entry, virtual:timber-ssr-entry,
+ * virtual:timber-browser-entry to real TypeScript files, and generates
+ * virtual:timber-config as serialized runtime config.
+ *
+ * Entry modules are real .ts files — NOT codegen strings. The only
+ * generated code is virtual:timber-config (serialized runtime config).
+ *
+ * Design docs: 18-build-system.md §"Entry Generation", §"Virtual Modules"
+ */
+import type { Plugin } from 'vite';
+import type { PluginContext } from '#/index.js';
+/**
+ * Create the timber-entries Vite plugin.
+ *
+ * Hooks: resolveId, load
+ */
+export declare function timberEntries(ctx: PluginContext): Plugin;
+//# sourceMappingURL=entries.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entries.d.ts","sourceRoot":"","sources":["../../src/plugins/entries.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAGnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AA2FhD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CA2FxD"}

package/dist/plugins/fonts.d.ts

@@ -0,0 +1,77 @@
+/**
+ * timber-fonts — Vite sub-plugin for build-time font processing.
+ *
+ * Handles:
+ * - Virtual module resolution for `@timber/fonts/google` and `@timber/fonts/local`
+ * - Static analysis of font function calls during `transform`
+ * - @font-face CSS generation and scoped class output
+ * - Size-adjusted fallback font generation
+ *
+ * Does NOT handle (separate tasks):
+ * - Google Fonts downloading/caching (timber-nk5)
+ * - Build manifest / Early Hints integration (timber-qnx)
+ *
+ * Design doc: 24-fonts.md
+ */
+import type { Plugin } from 'vite';
+import type { PluginContext } from '#/index.js';
+import type { ExtractedFont, GoogleFontConfig } from '#/fonts/types.js';
+/**
+ * Registry of fonts extracted during transform.
+ * Keyed by a unique font ID derived from family + config.
+ */
+export type FontRegistry = Map<string, ExtractedFont>;
+/**
+ * Extract static font config from a font function call in source code.
+ *
+ * Parses patterns like:
+ *   const inter = Inter({ subsets: ['latin'], weight: '400', display: 'swap', variable: '--font-sans' })
+ *
+ * Returns null if the call cannot be statically analyzed.
+ *
+ * Uses acorn AST parsing for robust handling of comments, trailing commas,
+ * and multi-line configs.
+ */
+export declare function extractFontConfig(callSource: string): GoogleFontConfig | null;
+/**
+ * Detect if a source file contains dynamic/computed font function calls
+ * that cannot be statically analyzed.
+ *
+ * Returns the offending expression if found, null if all calls are static.
+ *
+ * Uses acorn AST parsing for accurate detection.
+ */
+export declare function detectDynamicFontCall(source: string, importedNames: string[]): string | null;
+/**
+ * Parse import specifiers from a source file that imports from
+ * `@timber/fonts/google` or `next/font/google`.
+ *
+ * Returns the list of imported font names (e.g. ['Inter', 'JetBrains_Mono']).
+ */
+export declare function parseGoogleFontImports(source: string): string[];
+/**
+ * Parse the original (remote) font family names from imports.
+ *
+ * Returns a map of local name → family name.
+ * e.g. { Inter: 'Inter', JetBrains_Mono: 'JetBrains Mono' }
+ */
+export declare function parseGoogleFontFamilies(source: string): Map<string, string>;
+/**
+ * Generate the CSS output for all extracted fonts.
+ *
+ * Includes @font-face rules, fallback @font-face rules, and scoped classes.
+ */
+export declare function generateAllFontCss(registry: FontRegistry): string;
+/**
+ * Parse the local name used for the default import of `@timber/fonts/local`.
+ *
+ * Handles:
+ *   import localFont from '@timber/fonts/local'
+ *   import myLoader from '@timber/fonts/local'
+ */
+export declare function parseLocalFontImportName(source: string): string | null;
+/**
+ * Create the timber-fonts Vite plugin.
+ */
+export declare function timberFonts(ctx: PluginContext): Plugin;
+//# sourceMappingURL=fonts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fonts.d.ts","sourceRoot":"","sources":["../../src/plugins/fonts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAkBxE;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AA4CtD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAE7E;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,CAE5F;AAUD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAkB/D;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAqB3E;AAwED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAiBjE;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKtE;AAqED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAoOtD"}

package/dist/plugins/mdx.d.ts

@@ -0,0 +1,21 @@
+/**
+ * timber-mdx — Vite sub-plugin for MDX page rendering.
+ *
+ * Wires @mdx-js/rollup into the Vite pipeline when MDX is activated.
+ * MDX is activated when pageExtensions includes 'mdx' or 'md', or
+ * when a content/ directory exists at the project root.
+ *
+ * Design doc: 20-content-collections.md §"The timber-mdx Plugin"
+ */
+import type { Plugin } from 'vite';
+import type { PluginContext } from '#/index.js';
+/**
+ * Create the timber-mdx Vite plugin.
+ *
+ * Uses the transform and resolveId hooks to delegate MDX compilation
+ * to @mdx-js/rollup. The inner plugin is loaded lazily on first activation.
+ *
+ * Hooks: buildStart (loads @mdx-js/rollup), resolveId, load, transform
+ */
+export declare function timberMdx(ctx: PluginContext): Plugin;
+//# sourceMappingURL=mdx.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mdx.d.ts","sourceRoot":"","sources":["../../src/plugins/mdx.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAGnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAmDhD;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CA0GpD"}