@timber-js/app 0.2.0-alpha.166 → 0.2.0-alpha.168

package/src/config-validation.ts

@@ -30,12 +30,9 @@ const KNOWN_CONFIG_KEYS = {
   debug: true,
   clientJavascript: true,
   adapter: true,
-  cacheHandler: true,
-  cdnPurge: true,
   allowedOrigins: true,
   csrf: true,
   limits: true,
-  actions: true,
   forms: true,
   pageExtensions: true,
   slowRequestMs: true,
@@ -49,6 +46,7 @@ const KNOWN_CONFIG_KEYS = {
   reactCompiler: true,
   sitemap: true,
   buildDir: true,
+  clientSegmentCache: true,
   topLoader: true,
   budget: true,
 } satisfies Record<keyof TimberUserConfig, true>;
@@ -197,12 +195,16 @@ export function validateConfig(config: TimberUserConfig): ConfigError[] {
     }
   }
 
+  const MOVED_TO_CACHE_FILE = new Set(['cacheHandler', 'cdnPurge']);
+
   for (const key of Object.keys(config)) {
     if (!knownKeys.has(key)) {
       errors.push({
         field: key,
         message: `Unknown config option: "${key}".`,
-        suggestion: `Check for typos. Known options: ${[...knownKeys].sort().join(', ')}.`,
+        suggestion: MOVED_TO_CACHE_FILE.has(key)
+          ? `"${key}" has moved to timber.cache.ts. Export cacheHandler as default, cdnPurge as a named export.`
+          : `Check for typos. Known options: ${[...knownKeys].sort().join(', ')}.`,
       });
     }
   }
@@ -248,7 +250,7 @@ const VIRTUAL_MODULE_NAMES: Record<string, string> = {
   'virtual:timber-config': 'Runtime config (timber.config.ts)',
   'virtual:timber-route-manifest': 'Route manifest (app/ file tree)',
   'virtual:timber-instrumentation': 'Instrumentation (instrumentation.ts)',
-  'virtual:timber-cache-handler': 'Cache handler (cacheHandler config)',
+  'virtual:timber-cache-handler': 'Cache handler (timber.cache.ts)',
   'virtual:timber-build-manifest': 'Build manifest (asset mapping)',
 };
 

package/src/fonts/pipeline.ts

@@ -208,6 +208,38 @@ export class FontPipeline {
     }
   }
 
+  /** True if at least one entry is registered under `importer`. */
+  hasImporter(importer: string): boolean {
+    for (const entry of this._entries.values()) {
+      if (entry.importer === importer) return true;
+    }
+    return false;
+  }
+
+  /**
+   * Drop **every** registry entry that originated from `importer`,
+   * regardless of family.
+   *
+   * Called at the start of the transform hook before re-registering the
+   * current extraction set. This handles the cases `pruneFor` misses:
+   *
+   * - **Family rename** (Inter → Roboto): the old family's entries are
+   *   cleared because we prune by importer, not by (importer, family).
+   * - **Font call deleted**: the old entries are cleared even though no
+   *   new call provides a family to prune against.
+   *
+   * Other importers' fonts are untouched.
+   *
+   * See TIM-1087.
+   */
+  pruneImporter(importer: string): void {
+    for (const [id, entry] of this._entries) {
+      if (entry.importer === importer) {
+        this._entries.delete(id);
+      }
+    }
+  }
+
   /** Drop every registered font. Used by tests and rebuild flows. */
   clear(): void {
     this._entries.clear();

package/src/fonts/transform.ts

@@ -213,7 +213,11 @@ export function runFontsTransform(
 
   const s = new MagicString(code);
 
-  // Process each call site.
+  // Extract and validate all call sites before mutating the pipeline.
+  // If any extraction fails (emitError throws), the pipeline is untouched
+  // so the previous valid CSS stays intact (TIM-1087).
+  const pending: { extracted: ExtractedFont; site: (typeof analysis.callSites)[0] }[] = [];
+
   for (const site of analysis.callSites) {
     if (site.binding.provider === 'google') {
       const family = site.binding.importedName.replace(/_/g, ' ');
@@ -232,24 +236,22 @@ export function runFontsTransform(
       const fontStack = buildFontStack(family);
       const display = config!.display ?? 'swap';
 
-      const extracted: ExtractedFont = {
-        id: fontId,
-        family,
-        provider: 'google',
-        weights: normalizeWeightArray(config!.weight),
-        styles: normalizeStyleArray(config!.style),
-        subsets: config!.subsets ?? ['latin'],
-        display,
-        variable: config!.variable,
-        className,
-        fontFamily: fontStack,
-        importer: id,
-      };
-
-      pipeline.pruneFor(id, family);
-      pipeline.register(extracted);
-
-      s.overwrite(site.replaceStart, site.replaceEnd, buildFontResultLiteral(extracted));
+      pending.push({
+        site,
+        extracted: {
+          id: fontId,
+          family,
+          provider: 'google',
+          weights: normalizeWeightArray(config!.weight),
+          styles: normalizeStyleArray(config!.style),
+          subsets: config!.subsets ?? ['latin'],
+          display,
+          variable: config!.variable,
+          className,
+          fontFamily: fontStack,
+          importer: id,
+        },
+      });
     } else {
       // local font
       const config = extractLocalFontConfigFromNode(site.configNode);
@@ -261,14 +263,18 @@ export function runFontsTransform(
         );
       }
 
-      const extracted = processLocalFont(config!, id);
-      pipeline.pruneFor(id, extracted.family);
-      pipeline.register(extracted);
-
-      s.overwrite(site.replaceStart, site.replaceEnd, buildFontResultLiteral(extracted));
+      pending.push({ site, extracted: processLocalFont(config!, id) });
     }
   }
 
+  // All extractions succeeded — now prune stale entries and register.
+  // Handles family renames and deleted font calls (TIM-1087).
+  pipeline.pruneImporter(id);
+  for (const { extracted, site } of pending) {
+    pipeline.register(extracted);
+    s.overwrite(site.replaceStart, site.replaceEnd, buildFontResultLiteral(extracted));
+  }
+
   // Remove font import declarations. Use a Set to avoid double-removing
   // when multiple bindings come from the same ImportDeclaration.
   const removedRanges = new Set<string>();

package/src/plugins/adapter-build.ts

@@ -15,6 +15,7 @@
 
 import type { Plugin } from 'vite';
 import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { readFile, writeFile } from 'node:fs/promises';
 import type { PluginContext } from '../plugin-context.js';
 import type { TimberPlatformAdapter, TimberConfig } from '../adapters/types.js';
@@ -83,6 +84,7 @@ export function timberAdapterBuild(ctx: PluginContext): Plugin {
         }
 
         const adapterConfig: TimberConfig = {
+          root: ctx.root,
           output: ctx.config.output ?? 'server',
           clientJavascriptDisabled: ctx.clientJavascript.disabled,
           manifestInit,
@@ -94,6 +96,116 @@ export function timberAdapterBuild(ctx: PluginContext): Plugin {
   };
 }
 
+/**
+ * Parse the RSC assets manifest at `manifestPath`. Tries JSON.parse first
+ * (fast path for plain-string manifests); falls back to a dynamic import()
+ * for manifests that contain runtime expressions from renderBuiltUrl.
+ * Returns null if both paths fail.
+ */
+async function parseRscManifest(
+  manifestPath: string,
+  content: string
+): Promise<Record<string, unknown> | null> {
+  const jsonStr = content.replace(/^export default\s*/, '').replace(/;?\s*$/, '');
+  try {
+    return JSON.parse(jsonStr);
+  } catch {
+    // Not strict JSON — manifest likely contains renderBuiltUrl runtime
+    // expressions. Fall back to evaluating the module directly.
+  }
+
+  // When renderBuiltUrl's runtime expressions reference external helpers
+  // not defined in the manifest file, this import will fail. That's an
+  // inherent limitation: runtime-computed URLs can't be resolved at build
+  // time for <link> tag injection. The warning below provides observability.
+  try {
+    const url = pathToFileURL(manifestPath).href;
+    const mod = await import(`${url}?t=${Date.now()}`);
+    return mod.default ?? null;
+  } catch (err) {
+    swallow(err, `failed to evaluate RSC assets manifest: ${manifestPath}`, { level: 'warn' });
+    return null;
+  }
+}
+
+/**
+ * Replace all `"js": [...]` array contents with `"js": []` using balanced
+ * bracket matching. Handles nested brackets from runtime expressions like
+ * `__rbu("path/to/[slug]/file.js")`.
+ */
+function clearJsArrays(src: string): string {
+  const pattern = /"js"\s*:\s*\[/g;
+  let result = '';
+  let lastEnd = 0;
+  let match: RegExpExecArray | null;
+
+  while ((match = pattern.exec(src)) !== null) {
+    const arrayStart = match.index + match[0].length;
+    let depth = 1;
+    let i = arrayStart;
+    while (i < src.length && depth > 0) {
+      if (src[i] === '[') depth++;
+      else if (src[i] === ']') depth--;
+      i++;
+    }
+    result += src.slice(lastEnd, match.index) + '"js": []';
+    lastEnd = i;
+  }
+  result += src.slice(lastEnd);
+  return result;
+}
+
+/**
+ * Replace `"bootstrapScriptContent": <value>` with an empty string. The
+ * value may be a JS expression (e.g., concatenation with runtime helpers),
+ * not a simple string literal. Scans forward from the colon, tracking
+ * balanced parens and brackets, and stops at the next unbalanced `,` or `}`.
+ */
+function clearBootstrapScriptContent(src: string): string {
+  const key = '"bootstrapScriptContent"';
+  const idx = src.indexOf(key);
+  if (idx === -1) return src;
+
+  // Find the colon after the key
+  const colonIdx = src.indexOf(':', idx + key.length);
+  if (colonIdx === -1) return src;
+
+  // Skip whitespace after colon
+  let valStart = colonIdx + 1;
+  while (valStart < src.length && /\s/.test(src[valStart])) valStart++;
+
+  // Scan forward to find the end of the value expression
+  let i = valStart;
+  let depth = 0;
+  let inString = false;
+  let stringChar = '';
+
+  while (i < src.length) {
+    const ch = src[i];
+    if (inString) {
+      if (ch === '\\') {
+        i += 2;
+        continue;
+      }
+      if (ch === stringChar) inString = false;
+    } else {
+      if (ch === '"' || ch === "'") {
+        inString = true;
+        stringChar = ch;
+      } else if (ch === '(' || ch === '[') {
+        depth++;
+      } else if (ch === ')' || ch === ']') {
+        depth--;
+      } else if (depth === 0 && (ch === ',' || ch === '}' || ch === '\n')) {
+        break;
+      }
+    }
+    i++;
+  }
+
+  return src.slice(0, idx) + '"bootstrapScriptContent": ""' + src.slice(i);
+}
+
 /**
  * Strip JS references from the RSC plugin's assets manifest files.
  *
@@ -125,13 +237,8 @@ export async function mergeRscAssetsManifest(
     return;
   }
 
-  const jsonStr = content.replace(/^export default\s*/, '').replace(/;?\s*$/, '');
-  let manifest: Record<string, unknown>;
-  try {
-    manifest = JSON.parse(jsonStr);
-  } catch {
-    return;
-  }
+  const manifest = await parseRscManifest(manifestPath, content);
+  if (!manifest) return;
 
   // Merge serverResources CSS into buildManifest.css.
   // Keys in serverResources are root-relative (e.g., "app/layout.tsx" or
@@ -174,7 +281,7 @@ export async function mergeRscAssetsManifest(
   }
 }
 
-async function stripJsFromRscAssetsManifests(buildDir: string): Promise<void> {
+export async function stripJsFromRscAssetsManifests(buildDir: string): Promise<void> {
   const manifestName = '__vite_rsc_assets_manifest.js';
   const paths = [join(buildDir, 'rsc', manifestName), join(buildDir, 'ssr', manifestName)];
 
@@ -186,17 +293,29 @@ async function stripJsFromRscAssetsManifests(buildDir: string): Promise<void> {
       continue;
     }
 
+    // Try JSON.parse to check if we can safely re-serialize
     const jsonStr = content.replace(/^export default\s*/, '').replace(/;?\s*$/, '');
-    let manifest: Record<string, unknown>;
+    let isStrictJson = true;
+    let manifest: Record<string, unknown> | null = null;
     try {
       manifest = JSON.parse(jsonStr);
-    } catch (err) {
-      swallow(err, `corrupted RSC assets manifest: ${path}`, { level: 'warn' });
+    } catch {
+      isStrictJson = false;
+    }
+
+    if (!isStrictJson) {
+      // Manifest contains renderBuiltUrl runtime expressions — cannot
+      // safely re-serialize with JSON.stringify. Use targeted text
+      // transforms to clear JS arrays and bootstrapScriptContent.
+      let rewritten = content;
+      rewritten = clearJsArrays(rewritten);
+      rewritten = clearBootstrapScriptContent(rewritten);
+      await writeFile(path, rewritten);
       continue;
     }
 
     // Clear JS from clientReferenceDeps — preserves CSS
-    const deps = manifest.clientReferenceDeps as
+    const deps = manifest?.clientReferenceDeps as
       | Record<string, { js: string[]; css: string[] }>
       | undefined;
     if (deps) {
@@ -205,7 +324,7 @@ async function stripJsFromRscAssetsManifests(buildDir: string): Promise<void> {
       }
     }
 
-    manifest.bootstrapScriptContent = '';
+    if (manifest) manifest.bootstrapScriptContent = '';
 
     await writeFile(path, `export default ${JSON.stringify(manifest, null, 2)};\n`);
   }

package/src/plugins/cache.ts

@@ -1,13 +1,13 @@
 /**
  * timber-cache-transform — Vite plugin that injects stable callsite IDs
- * into `cache()` calls imported from `@timber-js/app/cache`.
+ * into `cache.data()` calls imported from `@timber-js/app/cache`.
  *
  * Detected callsite forms (TIM-1054):
- *   - named imports, including aliases: `import { cache as c }` + `c(fn, opts)`
- *   - namespace imports: `import * as ns` + `ns.cache(fn, opts)`
+ *   - named imports, including aliases: `import { cache as c }` + `c.data(fn, opts)`
+ *   - namespace imports: `import * as ns` + `ns.cache.data(fn, opts)`
  * Forms a per-module transform cannot trace — local variable aliases
  * (`const c = cache`), user re-export wrapper modules, computed access
- * (`ns['cache']`) — fall back to the runtime fnId derived from
+ * (`cache['data']`) — fall back to the runtime fnId derived from
  * fnv1a(fn.toString()) (see cache/timber-cache.ts), which is deterministic
  * across instances and cold starts of the same build. Without either
  * mechanism, an ordinal counter would collide across instances with a shared
@@ -15,8 +15,8 @@
  * data to another.
  *
  * The plugin transforms:
- *   cache(fn, opts)      →  cache(fn, opts, "stable-id")
- *   ns.cache(fn, opts)   →  ns.cache(fn, opts, "stable-id")
+ *   cache.data(fn, opts)          →  cache.data(fn, opts, "stable-id")
+ *   ns.cache.data(fn, opts)       →  ns.cache.data(fn, opts, "stable-id")
  *
  * where stable-id =
  *   fnv1a(relPath + ":cache:" + fnv1a(stmtText) + ":" + fnv1a(callSpanText) + ":" + occurrence)
@@ -34,9 +34,9 @@
  * unrelated edits, while a changed call gets a fresh ID — which is exactly
  * when invalidation is wanted.
  *
- * The enclosing-statement text is included so that byte-identical cache()
+ * The enclosing-statement text is included so that byte-identical cache.data()
  * calls in different scopes — e.g. two factory helpers that each `return
- * cache(fn, { ttl: 60 })` — get distinct, insertion-stable IDs: their
+ * cache.data(fn, { ttl: 60 })` — get distinct, insertion-stable IDs: their
  * enclosing declarations differ by name/body even when the call spans are
  * identical. Without it, a source-order occurrence counter alone would shift
  * when an identical span is inserted above, reassigning IDs across deploys.
@@ -75,41 +75,56 @@ import type {
 } from './callsite-ast.js';
 
 /**
- * Is this callee a reference to the imported `cache` function — either a bare
- * identifier bound by a named import, or `ns.cache` on a namespace import?
- * Computed access (`ns['cache']`) is deliberately not matched; it falls back
+ * Is this callee a `cache.data(...)` call? Matches two forms:
+ *   - Named import: `cache.data(fn, opts)` where `cache` is the imported binding
+ *   - Namespace import: `ns.cache.data(fn, opts)` where `ns` is the namespace
+ * Computed access (`cache['data']`) is deliberately not matched; it falls back
  * to the runtime fnId derivation.
  */
-function isCacheCallee(callee: PositionedNode, bindings: ImportBindings): boolean {
-  if (callee.type === 'Identifier') {
-    return bindings.named.has((callee as IdentifierNode).name);
+function isCacheDataCallee(callee: PositionedNode, bindings: ImportBindings): boolean {
+  if (callee.type !== 'MemberExpression') return false;
+  const member = callee as unknown as MemberExpressionNode;
+  if (member.computed) return false;
+  if (member.property.type !== 'Identifier' || (member.property as IdentifierNode).name !== 'data')
+    return false;
+
+  const obj = member.object;
+  // Named import: `cache.data(...)` — obj is the imported `cache` identifier
+  if (obj.type === 'Identifier') {
+    return bindings.named.has((obj as IdentifierNode).name);
   }
-  if (callee.type === 'MemberExpression') {
-    const member = callee as unknown as MemberExpressionNode;
+  // Namespace import: `ns.cache.data(...)` — obj is `ns.cache`
+  if (obj.type === 'MemberExpression') {
+    const outer = obj as unknown as MemberExpressionNode;
     return (
-      !member.computed &&
-      member.object.type === 'Identifier' &&
-      bindings.namespaces.has((member.object as IdentifierNode).name) &&
-      member.property.type === 'Identifier' &&
-      (member.property as IdentifierNode).name === 'cache'
+      !outer.computed &&
+      outer.object.type === 'Identifier' &&
+      bindings.namespaces.has((outer.object as IdentifierNode).name) &&
+      outer.property.type === 'Identifier' &&
+      (outer.property as IdentifierNode).name === 'cache'
     );
   }
   return false;
 }
 
 /**
- * Extract the local binding name that a cache callee resolves to — the
- * identifier for named imports, or the namespace object for `ns.cache()`.
+ * Extract the local binding name that a cache.data callee resolves to — the
+ * `cache` identifier for named imports, or the namespace object for `ns.cache.data()`.
  */
 function calleeBindingName(callee: PositionedNode, bindings: ImportBindings): string | null {
-  if (callee.type === 'Identifier') {
-    const name = (callee as IdentifierNode).name;
+  if (callee.type !== 'MemberExpression') return null;
+  const member = callee as unknown as MemberExpressionNode;
+  const obj = member.object;
+  // Named import: `cache.data(...)` — binding is `cache`
+  if (obj.type === 'Identifier') {
+    const name = (obj as IdentifierNode).name;
     return bindings.named.has(name) ? name : null;
   }
-  if (callee.type === 'MemberExpression') {
-    const member = callee as unknown as MemberExpressionNode;
-    if (member.object.type === 'Identifier') {
-      const name = (member.object as IdentifierNode).name;
+  // Namespace import: `ns.cache.data(...)` — binding is `ns`
+  if (obj.type === 'MemberExpression') {
+    const outer = obj as unknown as MemberExpressionNode;
+    if (outer.object.type === 'Identifier') {
+      const name = (outer.object as IdentifierNode).name;
       return bindings.namespaces.has(name) ? name : null;
     }
   }
@@ -182,7 +197,7 @@ export function timberCacheTransform(ctx: PluginContext): Plugin {
           stmt,
           (call) =>
             call.arguments.length === 2 &&
-            isCacheCallee(call.callee, cacheBindings) &&
+            isCacheDataCallee(call.callee, cacheBindings) &&
             !isCalleeShadowed(call),
           calls
         );

package/src/plugins/entries.ts

@@ -154,6 +154,7 @@ function generateConfigModule(ctx: PluginContext): string {
     // Per-build deployment ID for version skew detection (TIM-446).
     // Null in dev mode — HMR handles code updates without full reloads.
     deploymentId: ctx.deploymentId ?? null,
+    clientSegmentCache: ctx.config.clientSegmentCache ?? false,
     // Browser log forwarding threshold — used by buildClientScripts to
     // decide whether /@vite/client is needed when clientJavascript is
     // disabled. See TIM-1152.
@@ -174,23 +175,39 @@ function generateConfigModule(ctx: PluginContext): string {
 }
 
 /**
- * Detect the user's instrumentation.ts file at the project root.
+ * Detect a user convention file at both root and src/.
  *
- * Checks for instrumentation.ts, .js, and .mjs — matching the same
- * extensions as timber.config.ts detection.
+ * Root takes precedence over src/, extension priority: .ts > .js > .mjs.
+ * Used for instrumentation.ts, timber.cache.ts, and similar file conventions.
  */
-export function detectInstrumentationFile(root: string): string | null {
+export function detectConventionFile(root: string, basename: string): string | null {
   const extensions = ['.ts', '.js', '.mjs'];
   const dirs = [root, resolve(root, 'src')];
   for (const dir of dirs) {
     for (const ext of extensions) {
-      const candidate = resolve(dir, `instrumentation${ext}`);
+      const candidate = resolve(dir, `${basename}${ext}`);
       if (existsSync(candidate)) return candidate;
     }
   }
   return null;
 }
 
+export function detectInstrumentationFile(root: string): string | null {
+  return detectConventionFile(root, 'instrumentation');
+}
+
+/**
+ * Detect the user's timber.cache file.
+ *
+ * This file holds runtime cache instances (cacheHandler, cdnPurge)
+ * that cannot be JSON-serialized. Separating them from timber.config.ts
+ * prevents the RSC build from pulling build-time deps (adapters, MDX,
+ * rollup) into the runtime bundle. See TIM-1211.
+ */
+export function detectCacheFile(root: string): string | null {
+  return detectConventionFile(root, 'timber.cache');
+}
+
 /**
  * Generate the virtual:timber-instrumentation module source.
  *
@@ -202,9 +219,6 @@ export function detectInstrumentationFile(root: string): string | null {
  */
 export function generateInstrumentationModule(instrumentationPath: string | null): string {
   if (instrumentationPath) {
-    // Use the absolute path so the bundler can resolve and include it.
-    // The dynamic import ensures the file is loaded lazily and errors
-    // in the user's code don't prevent the module from being parsed.
     return [
       '// Auto-generated instrumentation loader — do not edit.',
       '// Generated by timber-entries plugin.',
@@ -226,48 +240,33 @@ export function generateInstrumentationModule(instrumentationPath: string | null
   ].join('\n');
 }
 
-/**
- * Detect the user's timber.config file at the project root.
- * Returns the absolute path or null if not found.
- */
-function detectConfigFile(root: string): string | null {
-  const names = ['timber.config.ts', 'timber.config.js', 'timber.config.mjs'];
-  for (const name of names) {
-    const candidate = resolve(root, name);
-    if (existsSync(candidate)) return candidate;
-  }
-  return null;
-}
-
 /**
  * Generate the virtual:timber-cache-handler module source.
  *
- * When the user's config has a cacheHandler, generates a module that
- * dynamically imports the config file and extracts the cacheHandler.
- * The cacheHandler is a class instance (e.g. RedisCacheHandler) that
- * cannot be JSON-serialized into virtual:timber-config, so it must
- * be loaded at runtime via dynamic import. See TIM-599.
+ * When the user's timber.cache.ts exists, generates a module that
+ * dynamically imports it and extracts cacheHandler and cdnPurge.
+ * These are class instances (e.g. RedisCacheHandler) that cannot be
+ * JSON-serialized into virtual:timber-config, so they must be loaded
+ * at runtime via dynamic import.
+ *
+ * timber.cache.ts exports: default cacheHandler, named cdnPurge.
+ *
+ * See TIM-1211, TIM-599.
  */
-function generateCacheHandlerModule(
-  configPath: string | null,
-  hasCacheHandler: boolean,
-  hasCdnPurge: boolean
-): string {
-  if (configPath && (hasCacheHandler || hasCdnPurge)) {
+export function generateCacheHandlerModule(cachePath: string | null): string {
+  if (cachePath) {
     return [
       '// Auto-generated cache handler loader — do not edit.',
       '// Generated by timber-entries plugin.',
       '',
       `export default async function loadCacheHandler() {`,
-      `  const mod = await import(${JSON.stringify(configPath)});`,
-      `  const config = mod.default ?? mod;`,
-      `  return config.cacheHandler ?? null;`,
+      `  const mod = await import(${JSON.stringify(cachePath)});`,
+      `  return mod.default ?? null;`,
       `}`,
       '',
       `export async function loadCdnPurgeHandler() {`,
-      `  const mod = await import(${JSON.stringify(configPath)});`,
-      `  const config = mod.default ?? mod;`,
-      `  return config.cdnPurge ?? null;`,
+      `  const mod = await import(${JSON.stringify(cachePath)});`,
+      `  return mod.cdnPurge ?? null;`,
       `}`,
     ].join('\n');
   }
@@ -275,7 +274,7 @@ function generateCacheHandlerModule(
   return [
     '// Auto-generated cache handler loader — do not edit.',
     '// Generated by timber-entries plugin.',
-    '// No cacheHandler or cdnPurge configured in timber.config.',
+    '// No timber.cache.ts found.',
     '',
     `export default async function loadCacheHandler() {`,
     `  return null;`,
@@ -352,10 +351,8 @@ export function timberEntries(ctx: PluginContext): Plugin {
         return generateInstrumentationModule(instrumentationPath);
       }
       if (id === RESOLVED_CACHE_HANDLER_ID) {
-        const configPath = detectConfigFile(ctx.root);
-        const hasCacheHandler = ctx.config.cacheHandler != null;
-        const hasCdnPurge = ctx.config.cdnPurge != null;
-        return generateCacheHandlerModule(configPath, hasCacheHandler, hasCdnPurge);
+        const cachePath = detectCacheFile(ctx.root);
+        return generateCacheHandlerModule(cachePath);
       }
       return null;
     },