@timber-js/app 0.2.0-alpha.6 → 0.2.0-alpha.60

package/src/plugins/fonts.ts

@@ -17,26 +17,41 @@
 import type { Plugin, ViteDevServer } from 'vite';
 import { readFileSync, existsSync } from 'node:fs';
 import { resolve, normalize } from 'node:path';
-import type { PluginContext } from '#/index.js';
-import type { ExtractedFont, GoogleFontConfig } from '#/fonts/types.js';
-import type { ManifestFontEntry } from '#/server/build-manifest.js';
-import { generateVariableClass, generateFontFamilyClass, generateFontFaces } from '#/fonts/css.js';
-import { generateFallbackCss, buildFontStack } from '#/fonts/fallbacks.js';
-import { processLocalFont, generateLocalFontFaces } from '#/fonts/local.js';
-import { inferFontFormat } from '#/fonts/local.js';
-import { downloadAndCacheFonts, type CachedFont } from '#/fonts/google.js';
+import type { PluginContext } from '../index.js';
+import type { ExtractedFont, GoogleFontConfig } from '../fonts/types.js';
+import type { ManifestFontEntry } from '../server/build-manifest.js';
+import { generateVariableClass, generateFontFamilyClass, generateFontFaces } from '../fonts/css.js';
+import { generateFallbackCss, buildFontStack } from '../fonts/fallbacks.js';
+import { processLocalFont, generateLocalFontFaces } from '../fonts/local.js';
+import { inferFontFormat } from '../fonts/local.js';
+import { downloadAndCacheFonts, type CachedFont } from '../fonts/google.js';
 import {
   extractFontConfigAst,
   extractLocalFontConfigAst,
   detectDynamicFontCallAst,
-} from '#/fonts/ast.js';
+} from '../fonts/ast.js';
 
 const VIRTUAL_GOOGLE = '@timber/fonts/google';
 const VIRTUAL_LOCAL = '@timber/fonts/local';
-const VIRTUAL_FONT_CSS = 'virtual:timber-fonts.css';
 const RESOLVED_GOOGLE = '\0@timber/fonts/google';
 const RESOLVED_LOCAL = '\0@timber/fonts/local';
-const RESOLVED_FONT_CSS = '\0virtual:timber-fonts.css';
+
+/**
+ * Virtual side-effect module that registers font CSS on globalThis.
+ *
+ * When a file calls localFont() or a Google font function, the transform
+ * hook injects `import 'virtual:timber-font-css-register'` into that file.
+ * This virtual module sets `globalThis.__timber_font_css` with the combined
+ * @font-face CSS. The RSC entry reads it at render time to inline a <style> tag.
+ *
+ * This approach avoids timing issues because:
+ * 1. The font file is in the RSC module graph (imported by layout.tsx)
+ * 2. The side-effect import is added to the font file during transform
+ * 3. When layout.tsx is loaded, fonts.ts runs → side-effect module runs → globalThis is set
+ * 4. RSC entry renders → reads globalThis → inlines <style>
+ */
+const VIRTUAL_FONT_CSS_REGISTER = 'virtual:timber-font-css-register';
+const RESOLVED_FONT_CSS_REGISTER = '\0virtual:timber-font-css-register';
 
 /**
  * Registry of fonts extracted during transform.
@@ -246,6 +261,33 @@ function generateLocalVirtualModule(): string {
   ].join('\n');
 }
 
+/**
+ * Generate CSS for a single extracted font.
+ *
+ * Includes @font-face rules (for local fonts), fallback @font-face,
+ * and the scoped class rule.
+ */
+export function generateFontCss(font: ExtractedFont): string {
+  const cssParts: string[] = [];
+
+  if (font.provider === 'local' && font.localSources) {
+    const faces = generateLocalFontFaces(font.family, font.localSources, font.display);
+    const faceCss = generateFontFaces(faces);
+    if (faceCss) cssParts.push(faceCss);
+  }
+
+  const fallbackCss = generateFallbackCss(font.family);
+  if (fallbackCss) cssParts.push(fallbackCss);
+
+  if (font.variable) {
+    cssParts.push(generateVariableClass(font.className, font.variable, font.fontFamily));
+  } else {
+    cssParts.push(generateFontFamilyClass(font.className, font.fontFamily));
+  }
+
+  return cssParts.join('\n\n');
+}
+
 /**
  * Generate the CSS output for all extracted fonts.
  *
@@ -254,27 +296,9 @@ function generateLocalVirtualModule(): string {
  */
 export function generateAllFontCss(registry: FontRegistry): string {
   const cssParts: string[] = [];
-
   for (const font of registry.values()) {
-    // Generate @font-face rules for local fonts
-    if (font.provider === 'local' && font.localSources) {
-      const faces = generateLocalFontFaces(font.family, font.localSources, font.display);
-      const faceCss = generateFontFaces(faces);
-      if (faceCss) cssParts.push(faceCss);
-    }
-
-    // Generate fallback @font-face if metrics are available
-    const fallbackCss = generateFallbackCss(font.family);
-    if (fallbackCss) cssParts.push(fallbackCss);
-
-    // Generate scoped class
-    if (font.variable) {
-      cssParts.push(generateVariableClass(font.className, font.variable, font.fontFamily));
-    } else {
-      cssParts.push(generateFontFamilyClass(font.className, font.fontFamily));
-    }
+    cssParts.push(generateFontCss(font));
   }
-
   return cssParts.join('\n\n');
 }
 
@@ -371,34 +395,61 @@ export function timberFonts(ctx: PluginContext): Plugin {
     name: 'timber-fonts',
 
     /**
-     * Resolve `@timber/fonts/google`, `@timber/fonts/local`, and the
-     * virtual font CSS module to internal IDs.
+     * Resolve `@timber/fonts/google`, `@timber/fonts/local`,
+     * and `virtual:timber-font-css` virtual modules.
+     *
+     * Handles \0 prefix and root prefix stripping for RSC/SSR
+     * environments where the RSC plugin re-imports virtual modules
+     * with additional prefixes.
      */
     resolveId(id: string) {
-      if (id === VIRTUAL_GOOGLE) return RESOLVED_GOOGLE;
-      if (id === VIRTUAL_LOCAL) return RESOLVED_LOCAL;
-      if (id === VIRTUAL_FONT_CSS) return RESOLVED_FONT_CSS;
+      // Strip \0 prefix (RSC plugin re-imports)
+      let cleanId = id.startsWith('\0') ? id.slice(1) : id;
+      // Strip root prefix (SSR build entries)
+      if (cleanId.startsWith(ctx.root)) {
+        const stripped = cleanId.slice(ctx.root.length);
+        if (stripped.startsWith('/') || stripped.startsWith('\\')) {
+          cleanId = stripped.slice(1);
+        } else {
+          cleanId = stripped;
+        }
+      }
+
+      if (cleanId === VIRTUAL_GOOGLE) return RESOLVED_GOOGLE;
+      if (cleanId === VIRTUAL_LOCAL) return RESOLVED_LOCAL;
+      if (cleanId === VIRTUAL_FONT_CSS_REGISTER) return RESOLVED_FONT_CSS_REGISTER;
       return null;
     },
 
     /**
      * Return generated source for font virtual modules.
      *
-     * The font CSS virtual module returns the combined @font-face rules,
-     * fallback CSS, and scoped classes for all registered fonts.
+     * `virtual:timber-font-css` exports the combined @font-face CSS
+     * as a string. The RSC entry imports it and inlines a <style> tag.
+     * Because this is loaded lazily (on first request), the font
+     * registry is always populated by the time it's needed.
      */
     load(id: string) {
       if (id === RESOLVED_GOOGLE) return generateGoogleVirtualModule(registry);
       if (id === RESOLVED_LOCAL) return generateLocalVirtualModule();
-      if (id === RESOLVED_FONT_CSS) return generateAllFontCss(registry);
+
+      if (id === RESOLVED_FONT_CSS_REGISTER) {
+        const css = generateAllFontCss(registry);
+        // Side-effect module: sets font CSS on globalThis for the RSC entry to read.
+        return `globalThis.__timber_font_css = ${JSON.stringify(css)};`;
+      }
       return null;
     },
 
     /**
-     * Serve local font files in dev mode under `/_timber/fonts/`.
+     * Serve local font files and font CSS in dev mode under `/_timber/fonts/`.
+     *
+     * Serves:
+     * - `/_timber/fonts/fonts.css` — combined @font-face + scoped class CSS
+     * - `/_timber/fonts/<filename>` — individual font files from the registry
      *
-     * Only files that are registered in the font registry (via localSources)
-     * are served. Paths are validated to prevent directory traversal.
+     * Only files registered in the font registry are served.
+     * Paths are validated to prevent directory traversal.
      */
     configureServer(server: ViteDevServer) {
       server.middlewares.use((req, res, next) => {
@@ -413,6 +464,9 @@ export function timberFonts(ctx: PluginContext): Plugin {
           return;
         }
 
+        // Font CSS is now injected via Vite's CSS pipeline (virtual:timber-font-css modules).
+        // This middleware only serves font binary files (woff2, etc.).
+
         // Find the matching font file in the registry
         for (const font of registry.values()) {
           if (font.provider !== 'local' || !font.localSources) continue;
@@ -420,7 +474,6 @@ export function timberFonts(ctx: PluginContext): Plugin {
             const basename = src.path.split('/').pop() ?? '';
             if (basename === requestedFilename) {
               const absolutePath = normalize(resolve(src.path));
-              // Verify the resolved path hasn't escaped (extra safety)
               if (!existsSync(absolutePath)) {
                 res.statusCode = 404;
                 res.end('Not found');
@@ -571,10 +624,11 @@ export function timberFonts(ctx: PluginContext): Plugin {
       }
 
       if (transformedCode !== code) {
-        // Inject a CSS import for the virtual font stylesheet.
-        // Vite treats .css imports as CSS modules — in dev it's injected
-        // via HMR, in prod the RSC plugin emits it via preinit().
-        transformedCode = `import '${VIRTUAL_FONT_CSS}';\n` + transformedCode;
+        // Inject side-effect import that registers font CSS on globalThis.
+        // The RSC entry reads globalThis.__timber_font_css to inline a <style> tag.
+        if (registry.size > 0) {
+          transformedCode = `import '${VIRTUAL_FONT_CSS_REGISTER}';\n` + transformedCode;
+        }
         return { code: transformedCode, map: null };
       }
 
@@ -620,15 +674,8 @@ export function timberFonts(ctx: PluginContext): Plugin {
         }
       }
 
-      // Emit the combined font CSS as an asset
-      const fontCss = generateAllFontCss(registry);
-      if (fontCss) {
-        this.emitFile({
-          type: 'asset',
-          fileName: '_timber/fonts/fonts.css',
-          source: fontCss,
-        });
-      }
+      // Font CSS is emitted by Vite's CSS pipeline via virtual:timber-font-css modules.
+      // We only need to emit font binary files and update the build manifest here.
 
       if (!ctx.buildManifest) return;
 

package/src/plugins/mdx.ts

@@ -11,7 +11,7 @@
 import type { Plugin } from 'vite';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import type { PluginContext } from '#/index.js';
+import type { PluginContext } from '../index.js';
 
 const MDX_EXTENSIONS = ['mdx', 'md'];
 

package/src/plugins/routing.ts

@@ -11,15 +11,15 @@
 import type { Plugin, ViteDevServer } from 'vite';
 import { writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { scanRoutes } from '#/routing/scanner.js';
-import { generateRouteMap } from '#/routing/codegen.js';
-import { collectInterceptionRewrites } from '#/routing/interception.js';
+import { scanRoutes } from '../routing/scanner.js';
+import { generateRouteMap } from '../routing/codegen.js';
+import { collectInterceptionRewrites } from '../routing/interception.js';
 import {
   lintStatusFileDirectives,
   formatStatusFileLintWarnings,
-} from '#/routing/status-file-lint.js';
-import type { RouteTree, SegmentNode, RouteFile } from '#/routing/types.js';
-import type { PluginContext } from '#/index.js';
+} from '../routing/status-file-lint.js';
+import type { RouteTree, SegmentNode, RouteFile } from '../routing/types.js';
+import type { PluginContext } from '../index.js';
 
 const VIRTUAL_MODULE_ID = 'virtual:timber-route-manifest';
 const RESOLVED_VIRTUAL_ID = `\0${VIRTUAL_MODULE_ID}`;
@@ -28,7 +28,7 @@ const RESOLVED_VIRTUAL_ID = `\0${VIRTUAL_MODULE_ID}`;
  * File convention names we track for changes that require manifest regeneration.
  */
 const ROUTE_FILE_PATTERNS =
-  /\/(page|layout|middleware|access|route|error|default|denied|search-params|\d{3}|[45]xx|not-found|forbidden|unauthorized|sitemap|robots|manifest|favicon|icon|opengraph-image|twitter-image|apple-icon)\./;
+  /\/(page|layout|middleware|access|route|error|default|denied|params|\d{3}|[45]xx|not-found|forbidden|unauthorized|sitemap|robots|manifest|favicon|icon|opengraph-image|twitter-image|apple-icon)\./;
 
 /**
  * Create the timber-routing Vite plugin.
@@ -168,20 +168,49 @@ export function timberRouting(ctx: PluginContext): Plugin {
       // Watch the app directory
       devServer.watcher.add(ctx.appDir);
 
-      const handleFileChange = (filePath: string) => {
-        // Only react to route-significant files in the app directory
+      /** Snapshot of the last generated manifest, used to detect structural changes. */
+      let lastManifest = ctx.routeTree ? generateManifestModule(ctx.routeTree) : '';
+
+      /**
+       * Handle a route-significant file being added or removed.
+       * Always triggers a full-reload since the route tree structure changed.
+       */
+      const handleStructuralChange = (filePath: string) => {
         if (!filePath.startsWith(ctx.appDir)) return;
         if (!ROUTE_FILE_PATTERNS.test(filePath)) return;
 
-        // Rescan the route tree
         rescan();
-
-        // Invalidate the virtual module in all environments
+        lastManifest = ctx.routeTree ? generateManifestModule(ctx.routeTree) : '';
         invalidateManifest(devServer);
       };
 
-      devServer.watcher.on('add', handleFileChange);
-      devServer.watcher.on('unlink', handleFileChange);
+      /**
+       * Handle a route file's content changing.
+       *
+       * Most content edits (JSX changes, fixing typos) don't affect route
+       * metadata — Vite's React Fast Refresh handles those via normal HMR.
+       * Only rescan and full-reload when route metadata actually changed
+       * (e.g., searchParams export added/removed, metadata export changed).
+       */
+      const handleContentChange = (filePath: string) => {
+        if (!filePath.startsWith(ctx.appDir)) return;
+        if (!ROUTE_FILE_PATTERNS.test(filePath)) return;
+
+        rescan();
+        const newManifest = ctx.routeTree ? generateManifestModule(ctx.routeTree) : '';
+        if (newManifest !== lastManifest) {
+          lastManifest = newManifest;
+          invalidateManifest(devServer);
+        }
+        // Otherwise: content edit didn't change route metadata — let Vite HMR handle it
+      };
+
+      devServer.watcher.on('add', handleStructuralChange);
+      devServer.watcher.on('unlink', handleStructuralChange);
+      // Watch content changes to page files — searchParams detection depends
+      // on file contents (export const searchParams), not just file presence.
+      // But only full-reload when route metadata actually changes.
+      devServer.watcher.on('change', handleContentChange);
       // Also watch renames (which are add+unlink) — handled by the above
     },
   };
@@ -301,12 +330,15 @@ function generateManifestModule(tree: RouteTree): string {
         `${nextIndent}denied: { load: ${v}, filePath: ${JSON.stringify(node.denied.filePath)} },`
       );
     }
-    if (node.searchParams) {
-      const v = addImport(node.searchParams);
+    if (node.params) {
+      const v = addImport(node.params);
       parts.push(
-        `${nextIndent}searchParams: { load: ${v}, filePath: ${JSON.stringify(node.searchParams.filePath)} },`
+        `${nextIndent}params: { load: ${v}, filePath: ${JSON.stringify(node.params.filePath)} },`
       );
     }
+    // searchParams is now a named export from page.tsx, not a separate file.
+    // The page module's searchParams export is loaded via the page's lazy import.
+    // Runtime registration happens in the route loader using the page module.
 
     // Status-code files
     if (node.statusFiles && node.statusFiles.size > 0) {
@@ -391,6 +423,13 @@ function generateManifestModule(tree: RouteTree): string {
     proxyLine = `  proxy: { load: ${v}, filePath: ${JSON.stringify(tree.proxy.filePath)} },`;
   }
 
+  // Global error page (Tier 2)
+  let globalErrorLine = '';
+  if (tree.globalError) {
+    const v = addImport(tree.globalError);
+    globalErrorLine = `  globalError: { load: ${v}, filePath: ${JSON.stringify(tree.globalError.filePath)} },`;
+  }
+
   // Interception rewrites — computed at build time from the route tree.
   // Only interceptedPattern and interceptingPrefix are needed at runtime.
   const rewrites = collectInterceptionRewrites(tree.root);
@@ -407,6 +446,7 @@ function generateManifestModule(tree: RouteTree): string {
     '',
     'const manifest = {',
     proxyLine,
+    globalErrorLine,
     rewritesLine,
     `  root: ${rootSerialized},`,
     '};',

package/src/plugins/server-action-exports.ts

@@ -1,7 +1,7 @@
 import type { Plugin } from 'vite';
 import { Parser } from 'acorn';
 import acornJsx from 'acorn-jsx';
-import { detectFileDirective } from '#/utils/directive-parser.js';
+import { detectFileDirective } from '../utils/directive-parser.js';
 
 const jsxParser = Parser.extend(acornJsx());
 

package/src/plugins/server-bundle.ts

@@ -137,5 +137,36 @@ export function timberServerBundle(): Plugin[] {
     },
   };
 
-  return [bundlePlugin, esmInitFixPlugin];
+  // Fix Rolldown's `createRequire(import.meta.url)` CJS interop shim for
+  // Cloudflare Workers. Rolldown emits this for CJS dependencies (e.g.
+  // @opentelemetry/context-async-hooks) that use `require()`. On Workers,
+  // `import.meta.url` is `undefined` for non-entry modules, causing:
+  //   TypeError: The argument 'path' must be a file URL object, a file URL
+  //   string, or an absolute path string. Received 'undefined'
+  //
+  // The fix: provide a fallback URL when `import.meta.url` is undefined.
+  // The actual URL doesn't matter — `createRequire` only needs it for
+  // resolving relative paths, but the only `__require()` calls are for
+  // Node built-ins (events, async_hooks) which resolve from any base.
+  //
+  // The top-level `ssr: { target: 'webworker' }` was supposed to prevent
+  // this, but it doesn't propagate to custom environments (rsc) in Vite's
+  // Environment API. See LOCAL-405.
+  const createRequireFixPlugin: Plugin = {
+    name: 'timber-create-require-fix',
+    applyToEnvironment(environment) {
+      return environment.name === 'rsc' || environment.name === 'ssr';
+    },
+    renderChunk(code) {
+      const pattern = 'createRequire(import.meta.url)';
+      if (!code.includes(pattern)) return null;
+
+      return {
+        code: code.replace(pattern, 'createRequire(import.meta.url || "file:///app")'),
+        map: null,
+      };
+    },
+  };
+
+  return [bundlePlugin, esmInitFixPlugin, createRequireFixPlugin];
 }

package/src/plugins/shims.ts

@@ -5,10 +5,11 @@
  * 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"
  */
@@ -16,7 +17,7 @@
 import type { Plugin } from 'vite';
 import { resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import type { PluginContext } from '#/index.js';
+import type { PluginContext } from '../index.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // Detect whether we're running from source (src/plugins/) or dist (dist/).
@@ -38,6 +39,24 @@ const SHIMS_DIR = resolve(PKG_ROOT, 'src', 'shims');
 const SERVER_ONLY_VIRTUAL = '\0timber:server-only';
 const CLIENT_ONLY_VIRTUAL = '\0timber:client-only';
 
+/**
+ * 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. See TIM-568.
+ */
+const SUBPATH_SRC_MAP: Record<string, string> = {
+  'cache': 'cache/index.ts',
+  'content': 'content/index.ts',
+  'cookies': 'cookies/index.ts',
+  'params': 'params/index.ts',
+  'search-params': 'search-params/index.ts',
+  'routing': 'routing/index.ts',
+  'adapters/cloudflare': 'adapters/cloudflare.ts',
+  'adapters/nitro': 'adapters/nitro.ts',
+};
+
 /**
  * Map from next/* import specifiers to shim file paths.
  *
@@ -88,14 +107,14 @@ export function timberShims(_ctx: PluginContext): Plugin {
      * 3. Check next/* shim map
      * 4. Return null (pass through) for everything else
      *
-     * @timber-js/app/server is resolved to src/ so it shares the same module
-     * instance as framework internals (which import via #/). This ensures
-     * a single requestContextAls and _getRscFallback variable.
+     * All @timber-js/app/* subpath imports resolve to dist/ via package.json
+     * exports in all environments. This ensures a single module instance
+     * for each module — the dist/ chunks share code via rollup's code
+     * splitting. No src/ remapping is needed (see TIM-568).
      *
-     * @timber-js/app/client is resolved to src/ in the SSR environment so
-     * client hooks share the same module instance as ssr-entry.ts internals.
-     * In RSC it resolves to dist/ (via package.json exports) where 'use client'
-     * is preserved on the entry for client boundary detection.
+     * The only exception is @timber-js/app/server in the client (browser)
+     * environment, which returns a virtual stub — server code must never
+     * be bundled into the browser.
      */
     resolveId(id: string) {
       // Poison pill packages — resolve to virtual modules handled by load()
@@ -117,38 +136,57 @@ export function timberShims(_ctx: PluginContext): Plugin {
         return SHIM_MAP[cleanId];
       }
 
-      // @timber-js/app/server → src/ in server environments so user code
-      // shares the same module instance as framework internals (single ALS).
-      // In the client environment, return a virtual empty module — server
-      // code must never be bundled into the browser.
+      // ── @timber-js/app/* → src/ resolution in server environments ──
+      //
+      // All @timber-js/app/* subpath imports are remapped to src/ in server
+      // environments (RSC + SSR). This is required for two reasons:
+      //
+      // 1. RSC correctness: dist/ chunks eagerly import from 'react' (e.g.
+      //    createContext in segment-context) which doesn't exist in RSC's
+      //    React build. Vite's RSC plugin only transforms src/ files —
+      //    dist/ chunks are pre-built and served as-is.
+      //
+      // 2. Module singleton correctness: framework internals use relative
+      //    imports that resolve within src/. If user code resolved to dist/
+      //    while framework code resolved to src/, mutable module-level state
+      //    (ALS refs, registered callbacks) would be duplicated. By remapping
+      //    all @timber-js/app/* to src/, everything shares one module graph.
+      //
+      // Exception: @timber-js/app/client in RSC resolves to dist/ where
+      // 'use client' is preserved for client boundary detection.
+      //
+      // In the client (browser) environment, all imports resolve to dist/
+      // via package.json exports (no remapping needed).
+
       if (cleanId === '@timber-js/app/server') {
         const envName = (this as unknown as { environment?: { name?: string } }).environment?.name;
         if (envName === 'client') {
           return '\0timber:server-empty';
         }
+        // RSC + SSR: remap to src/
         return resolve(PKG_ROOT, 'src', 'server', 'index.ts');
       }
 
-      // @timber-js/app/client → src/ in the SSR environment so client hooks
-      // (useParams, usePathname, etc.) share the same module instance as
-      // ssr-entry.ts's internal imports (via #/client/...).
-      //
-      // Without this remap, @timber-js/app/client resolves to dist/ (via
-      // package.json exports), creating a module instance split: ssr-entry.ts
-      // registers the ALS-backed SSR data provider on the src/ instance of
-      // ssr-data.ts, but client component hooks read getSsrData() from the
-      // dist/ instance — which has no provider. Result: hooks like useParams()
-      // return empty defaults during SSR.
-      //
-      // This remap is SSR-only. The RSC environment still resolves to dist/
-      // where 'use client' is preserved on the entry (needed for client
-      // boundary detection). The client (browser) environment uses dist/
-      // for bundling.
       if (cleanId === '@timber-js/app/client') {
         const envName = (this as unknown as { environment?: { name?: string } }).environment?.name;
+        // SSR only — RSC needs dist/ for 'use client' boundary detection
         if (envName === 'ssr') {
           return resolve(PKG_ROOT, 'src', 'client', 'index.ts');
         }
+        return null;
+      }
+
+      // Catch-all: remap any other @timber-js/app/<subpath> to src/
+      // in non-client environments (RSC + SSR).
+      if (cleanId.startsWith('@timber-js/app/') && cleanId !== '@timber-js/app/package.json') {
+        const envName = (this as unknown as { environment?: { name?: string } }).environment?.name;
+        if (envName !== 'client') {
+          const subpath = cleanId.slice('@timber-js/app/'.length);
+          const srcPath = SUBPATH_SRC_MAP[subpath];
+          if (srcPath) {
+            return resolve(PKG_ROOT, 'src', srcPath);
+          }
+        }
       }
 
       return null;

package/src/plugins/static-build.ts

@@ -10,8 +10,8 @@
  */
 
 import type { Plugin } from 'vite';
-import type { PluginContext } from '#/index.js';
-import { detectFileDirective } from '#/utils/directive-parser.js';
+import type { PluginContext } from '../index.js';
+import { detectFileDirective } from '../utils/directive-parser.js';
 
 // ---------------------------------------------------------------------------
 // Types
@@ -163,9 +163,6 @@ export function validateStaticMode(
  * - transform: Validates source files for static mode violations
  */
 export function timberStaticBuild(ctx: PluginContext): Plugin {
-  const isStatic = ctx.config.output === 'static';
-  const clientJavascriptDisabled = ctx.clientJavascript.disabled;
-
   return {
     name: 'timber-static-build',
 
@@ -177,6 +174,11 @@ export function timberStaticBuild(ctx: PluginContext): Plugin {
      * - When client JS disabled: 'use client' / 'use server' directives → build error
      */
     transform(code: string, id: string) {
+      // Read ctx.config lazily inside the hook — not at plugin construction
+      // time — so file-based config from timber.config.ts is respected.
+      // See TIM-451.
+      const isStatic = ctx.config.output === 'static';
+
       // Only active in static mode
       if (!isStatic) return null;
 
@@ -189,7 +191,9 @@ export function timberStaticBuild(ctx: PluginContext): Plugin {
       // Only check JS/TS files
       if (!/\.[jt]sx?$/.test(id)) return null;
 
-      const errors = validateStaticMode(code, id, { clientJavascriptDisabled });
+      const errors = validateStaticMode(code, id, {
+        clientJavascriptDisabled: ctx.clientJavascript.disabled,
+      });
 
       if (errors.length > 0) {
         // Format all errors into a single build error message