@timber-js/app 0.2.0-alpha.8 → 0.2.0-alpha.80

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 '../plugin-context.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // Detect whether we're running from source (src/plugins/) or dist (dist/).
@@ -38,6 +39,23 @@ 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',
+  'cookies': 'cookies/index.ts',
+  'search-params': 'search-params/index.ts',
+
+  'adapters/cloudflare': 'adapters/cloudflare.ts',
+  'adapters/cloudflare/dev': 'adapters/cloudflare-dev.ts',
+  'adapters/nitro': 'adapters/nitro.ts',
+};
+
 /**
  * Map from next/* import specifiers to shim file paths.
  *
@@ -49,10 +67,14 @@ const SHIM_MAP: Record<string, string> = {
   'next/image': resolve(SHIMS_DIR, 'image.ts'),
   'next/navigation': resolve(SHIMS_DIR, 'navigation.ts'),
   'next/headers': resolve(SHIMS_DIR, 'headers.ts'),
-  // next/font/* redirects to the timber-fonts virtual modules.
-  // The fonts plugin's load hook serves the actual module code.
+  // next/font/* and @timber-js/app/fonts/* redirect to the timber-fonts
+  // virtual modules. The fonts plugin's load hook serves the actual module
+  // code. The package.json exports point to shim stubs for non-Vite contexts
+  // (tsc, tests), but in Vite the virtual module takes priority via this map.
   'next/font/google': '\0@timber/fonts/google',
   'next/font/local': '\0@timber/fonts/local',
+  '@timber-js/app/fonts/google': '\0@timber/fonts/google',
+  '@timber-js/app/fonts/local': '\0@timber/fonts/local',
 };
 
 /**
@@ -88,14 +110,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 +139,110 @@ 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).
+
+      // ── #imports resolution for package-internal modules ─────────────
+      //
+      // #server-internal and #client-internal are Node package imports
+      // (package.json "imports" field). They are only resolvable from
+      // within this package — external consumers get module-not-found.
+      //
+      // In Vite, we intercept them here to resolve to src/ for dev/build
+      // correctness (same rationale as the @timber-js/app/* remap above).
+      if (cleanId === '#server-internal') {
+        const envName = (this as unknown as { environment?: { name?: string } }).environment?.name;
+        if (envName === 'client') {
+          return '\0timber:server-empty';
+        }
+        return resolve(PKG_ROOT, 'src', 'server', 'internal.ts');
+      }
+
+      if (cleanId === '#client-internal') {
+        // Always resolve to src/ — all environments (RSC, SSR, client)
+        // use src/ for framework internals. In the client env, this
+        // ensures browser-entry and @timber-js/app/client share the
+        // same module graph (both resolve to src/).
+        return resolve(PKG_ROOT, 'src', 'client', 'internal.ts');
+      }
+
+      if (cleanId === '#routing') {
+        return resolve(PKG_ROOT, 'src', 'routing', 'index.ts');
+      }
+
+      // Legacy aliases — vitest and monorepo configs may still reference
+      // the old @timber-js/app/server/internal and @timber-js/app/client/internal
+      // specifiers via resolve.alias. When those aliases resolve to the
+      // absolute src/ path, they bypass this plugin entirely. But if the
+      // specifier reaches us unresolved (e.g., in a Vite build without
+      // aliases), handle it the same way as the #imports above.
+      if (cleanId === '@timber-js/app/server/internal') {
+        const envName = (this as unknown as { environment?: { name?: string } }).environment?.name;
+        if (envName === 'client') {
+          return '\0timber:server-empty';
+        }
+        return resolve(PKG_ROOT, 'src', 'server', 'internal.ts');
+      }
+
+      if (cleanId === '@timber-js/app/client/internal') {
+        // Same as #client-internal above — always resolve to src/.
+        return resolve(PKG_ROOT, 'src', 'client', 'internal.ts');
+      }
+
       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;
-        if (envName === 'ssr') {
+        // RSC: return null — needs dist/ for 'use client' boundary detection.
+        // SSR + Client: resolve to src/ so that browser-entry (which uses
+        // relative imports from src/) and user code (which uses the bare
+        // specifier @timber-js/app/client) share the same module instances.
+        // Without this, state.ts is loaded twice (src/ and dist/) and
+        // setGlobalRouter() writes to one copy while getRouterOrNull()
+        // reads from the other (always null).
+        if (envName === 'ssr' || envName === 'client') {
           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;
@@ -202,6 +296,12 @@ const msg = "[timber] @timber-js/app/server was imported from client code. " +
 function stub() { throw new Error(msg); }
 export const headers = stub;
 export const cookies = stub;
+export const getHeaders = stub;
+export const getHeader = stub;
+export const getCookies = stub;
+export const getCookie = stub;
+export const getSearchParams = stub;
+export const getSegmentParams = stub;
 export const searchParams = stub;
 export const deny = stub;
 export const notFound = stub;
@@ -209,7 +309,7 @@ export const redirect = stub;
 export const permanentRedirect = stub;
 export const redirectExternal = stub;
 export const waitUntil = stub;
-export const RenderError = stub;
+export const DenyOptions = {};
 export const RedirectType = {};
 export const DenySignal = stub;
 export const RedirectSignal = stub;

package/src/plugins/static-build.ts

@@ -2,7 +2,7 @@
  * timber-static-build — Vite sub-plugin for static output mode.
  *
  * When `output: 'static'` is set in timber.config.ts, this plugin:
- * 1. Validates that no dynamic APIs (cookies(), headers()) are used
+ * 1. Validates that no dynamic APIs (getCookies(), getHeaders()) are used
  * 2. When client JavaScript is disabled, rejects 'use client' and 'use server' directives
  * 3. Coordinates build-time rendering of all pages
  *
@@ -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 '../plugin-context.js';
+import { detectFileDirective } from '../utils/directive-parser.js';
 
 // ---------------------------------------------------------------------------
 // Types
@@ -29,7 +29,7 @@ export interface StaticOptions {
 }
 
 // ---------------------------------------------------------------------------
-// Detection: dynamic APIs (cookies, headers)
+// Detection: dynamic APIs (getCookies, getHeaders, and legacy cookies/headers)
 // ---------------------------------------------------------------------------
 
 /**
@@ -39,12 +39,14 @@ export interface StaticOptions {
  * We detect both import-level and call-level usage.
  */
 const DYNAMIC_API_PATTERNS: Array<{ pattern: RegExp; name: string }> = [
+  { pattern: /\bgetCookies\s*\(/, name: 'getCookies()' },
+  { pattern: /\bgetHeaders\s*\(/, name: 'getHeaders()' },
   { pattern: /\bcookies\s*\(/, name: 'cookies()' },
   { pattern: /\bheaders\s*\(/, name: 'headers()' },
 ];
 
 /**
- * Detect usage of dynamic per-request APIs (cookies(), headers())
+ * Detect usage of dynamic per-request APIs (getCookies(), getHeaders())
  * that cannot work at build time in static mode.
  *
  * Returns an array of validation errors.
@@ -134,7 +136,7 @@ export function detectDirectives(
  * Run all static mode validations on a source file.
  *
  * Combines:
- * - Dynamic API detection (cookies, headers) — always in static mode
+ * - Dynamic API detection (getCookies, getHeaders) — always in static mode
  * - Directive detection ('use client', 'use server') — only when client JS is disabled
  */
 export function validateStaticMode(
@@ -163,9 +165,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',
 
@@ -173,10 +172,15 @@ export function timberStaticBuild(ctx: PluginContext): Plugin {
      * Validate source files during transform.
      *
      * In static mode, we check every app/ file for:
-     * - Dynamic API usage (cookies(), headers()) → build error
+     * - Dynamic API usage (getCookies(), getHeaders()) → build error
      * - 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 +193,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