@timber-js/app 0.2.0-alpha.207 → 0.2.0-alpha.209

package/src/plugins/post-build.ts

@@ -0,0 +1,327 @@
+/**
+ * timber-post-build — the post-build phase, as one ordered handler.
+ *
+ * Everything timber does after Vite has built the three environments runs
+ * here, in this order, each step handed what the previous one returned:
+ *
+ *   1. finalize the build manifest — font entries, the RSC assets manifest
+ *      merged in once, JavaScript stripped once when client JS is disabled
+ *   2. prebuilt capture   (cache.component prerender payloads, design/44)
+ *   3. static generation  (output: 'static', design/11)
+ *   4. the build report
+ *   5. assemble `BuildArtifacts` and call the adapter's `buildOutput`
+ *
+ * One `buildApp` hook with `order: 'post'` — so Vite runs the RSC plugin's
+ * buildApp, which orchestrates every environment build and writes the
+ * assets manifests, first. The order above is this function's, not the
+ * plugin array's, and no step reads another's result off the shared
+ * context: sibling plugins contribute through the typed steps they expose
+ * (`FontsBuildStep`, `PrebuiltBuildStep`, `BuildReportStep`), which
+ * `timber()` hands to this plugin directly.
+ *
+ * Design docs: 18-build-system.md §"Post-Build Phase", 11-platform.md
+ * §"Build Artifacts", 49-explicit-subsystem-boundaries.md §B
+ */
+
+import type { Plugin, Rollup } from 'vite';
+import { readdir } from 'node:fs/promises';
+import { join, relative, resolve } from 'node:path';
+import { adapterConfig, contextAdapter, type PluginContext } from '../plugin-context.ts';
+import type { BuildArtifacts, DirectoryArtifact } from '../adapters/types.ts';
+import type { BuildManifest } from '../server/build-manifest.ts';
+import type { FontsBuildStep } from './fonts.ts';
+import type { PrebuiltBuildStep } from './prebuilt.ts';
+import type { BuildReportStep } from './build-report.ts';
+import { runStaticGeneration, type StaticSite } from './static-build.ts';
+import { mergeRscAssetsManifest, stripJsFromRscAssetsManifests } from './rsc-assets-manifest.ts';
+
+/** The Vite environments whose output adapters consume. */
+const ARTIFACT_ENVIRONMENTS = ['client', 'rsc', 'ssr'] as const;
+type ArtifactEnvironment = (typeof ARTIFACT_ENVIRONMENTS)[number];
+
+function isArtifactEnvironment(name: string): name is ArtifactEnvironment {
+  return (ARTIFACT_ENVIRONMENTS as readonly string[]).includes(name);
+}
+
+/** Each environment's output directory, as its own `writeBundle` recorded it. */
+export type EnvironmentOutputs = Partial<Record<ArtifactEnvironment, DirectoryArtifact>>;
+
+/** The steps sibling plugins own. */
+export interface PostBuildSteps {
+  fonts: FontsBuildStep;
+  prebuilt: PrebuiltBuildStep;
+  report: BuildReportStep;
+}
+
+export function timberPostBuild(ctx: PluginContext, steps: PostBuildSteps): Plugin {
+  const environments: EnvironmentOutputs = {};
+  /** What the client environment's bundle wrote, from its `writeBundle`. */
+  let clientOutput: ClientOutput = { assetsDir: '', emitted: new Set() };
+
+  return {
+    name: 'timber-post-build',
+
+    // Record each environment's output directory as it is written, so the
+    // phase learns what exists from the build rather than by probing for
+    // it. The RSC plugin's scan builds run with `write: false` and never
+    // reach this hook; only the real bundles do.
+    writeBundle(options, bundle) {
+      if (ctx.dev) return;
+      const env = this.environment;
+      if (!isArtifactEnvironment(env.name)) return;
+      environments[env.name] = { path: resolve(env.config.root, env.config.build.outDir) };
+      if (env.name === 'client') {
+        clientOutput = {
+          assetsDir: hashedAssetsDir(env.config.build.assetsDir, options),
+          emitted: new Set(Object.keys(bundle)),
+        };
+      }
+    },
+
+    buildApp: {
+      order: 'post' as const,
+      async handler() {
+        if (ctx.dev) return;
+        await runPostBuild(ctx, steps, environments, clientOutput);
+      },
+    },
+  };
+}
+
+/**
+ * The client bundle's assets directory, in the artifacts' form (no leading
+ * or trailing slash) — or `''` when its files are not all content-hashed.
+ *
+ * `assetsDir` names where Vite writes; it is the naming patterns that decide
+ * whether a file name carries a hash. Vite's defaults do
+ * (`<assetsDir>/[name]-[hash].js`), but an app can set
+ * `assetFileNames: 'static/[name][extname]'`, and marking that directory
+ * immutable would pin a changed image under an unchanged URL for a year. A
+ * pattern given as a function cannot be inspected, so it counts as unhashed:
+ * those files fall back to the revalidating per-file rule.
+ *
+ * @internal Exported for testing.
+ */
+export function hashedAssetsDir(
+  assetsDir: string,
+  output: Pick<
+    Rollup.NormalizedOutputOptions,
+    'entryFileNames' | 'chunkFileNames' | 'assetFileNames'
+  >
+): string {
+  const dir = assetsDir.replace(/^\/+|\/+$/g, '');
+  const patterns = [output.entryFileNames, output.chunkFileNames, output.assetFileNames];
+  const hashed = patterns.every((p) => typeof p === 'string' && p.includes('[hash'));
+  return hashed ? dir : '';
+}
+
+/** The client bundle as its own `writeBundle` saw it. */
+interface ClientOutput {
+  /** From `hashedAssetsDir` — `''` when the naming patterns are not all hashed. */
+  assetsDir: string;
+  /** Every file name the bundle emitted, relative to the client output directory. */
+  emitted: ReadonlySet<string>;
+}
+
+/**
+ * Keep only the directories whose every file the client bundle emitted.
+ *
+ * A producer knows it hashes what *it* writes, not what else lands beside it:
+ * Vite copies `public/` into the client output verbatim, so `public/assets/logo.png`
+ * sits in `assets/` under a stable name, and `public/_rsc/…` would sit among
+ * the hashed payloads. A directory holding any file the bundle did not emit
+ * is not content-hashed as a whole, and marking it immutable would pin that
+ * file for a year — so it is dropped, and its files take the per-file rule.
+ *
+ * @internal Exported for testing.
+ */
+export async function onlyEmittedDirs(
+  clientDir: string,
+  dirs: readonly string[],
+  emitted: ReadonlySet<string>
+): Promise<string[]> {
+  const kept: string[] = [];
+  for (const dir of dirs) {
+    const root = join(clientDir, dir);
+    const entries = await readdir(root, { recursive: true, withFileTypes: true }).catch(() => []);
+    const foreign = entries.some(
+      (entry) =>
+        entry.isFile() &&
+        !emitted.has(relative(clientDir, join(entry.parentPath, entry.name)).replace(/\\/g, '/'))
+    );
+    if (!foreign) kept.push(dir);
+  }
+  return kept;
+}
+
+async function runPostBuild(
+  ctx: PluginContext,
+  steps: PostBuildSteps,
+  environments: EnvironmentOutputs,
+  clientOutput: ClientOutput
+): Promise<void> {
+  const output = ctx.config.output ?? 'server';
+  const rsc = requireEnvironment(environments, 'rsc');
+  const ssr = requireEnvironment(environments, 'ssr');
+
+  // 1. The manifest is complete before anything renders with it. Published
+  // for the steps that import the built bundle in this process — the same
+  // value `manifestInit` carries to production. Assigned, never `??=`: a
+  // second build in one process must not render with the first one's.
+  const manifest = await finalizeBuildManifest(ctx, steps.fonts, rsc, ssr);
+  if (manifest) Reflect.set(globalThis, '__TIMBER_BUILD_MANIFEST__', manifest);
+
+  // 2–3. Each writes its own output and returns what it wrote.
+  const prebuilt = await steps.prebuilt.capture(rsc.path);
+  const site = output === 'static' ? await runStaticGeneration(ctx, rsc.path) : undefined;
+
+  // 4.
+  steps.report.print(prebuilt);
+
+  // 5.
+  const adapter = contextAdapter(ctx);
+  if (!adapter || typeof adapter.buildOutput !== 'function') return;
+
+  await adapter.buildOutput(
+    adapterConfig(ctx),
+    assembleBuildArtifacts({
+      output,
+      outputDir: ctx.buildDir,
+      environments,
+      immutableDirs: await onlyEmittedDirs(
+        requireEnvironment(environments, 'client').path,
+        [
+          ...(clientOutput.assetsDir ? [clientOutput.assetsDir] : []),
+          ...steps.fonts.immutableDirs(),
+          ...(site?.immutableDirs ?? []),
+        ],
+        clientOutput.emitted
+      ),
+      prebuilt: prebuilt?.artifact,
+      site,
+      manifestInit: manifest ? serializeManifestInit(manifest) : undefined,
+    })
+  );
+}
+
+function requireEnvironment(
+  environments: EnvironmentOutputs,
+  name: ArtifactEnvironment
+): DirectoryArtifact {
+  const artifact = environments[name];
+  if (!artifact) {
+    throw new Error(`[timber] Build output: the ${name} environment wrote no bundle`);
+  }
+  return artifact;
+}
+
+/**
+ * Step 1: bring the build manifest to its final shape, once.
+ *
+ * `timber-build-manifest` creates it from the client bundle; this adds what
+ * only exists once every environment is built — the font entries and the
+ * per-route CSS and modulepreloads in the RSC plugin's assets manifest —
+ * and then, when client JavaScript is disabled, removes every JavaScript
+ * reference, from the manifest and from the assets manifests on disk. The
+ * manifest's `js` / `modulepreload` are cleared after the merge has written
+ * into them, so nothing the merge adds survives.
+ *
+ * Returns null only when no client bundle produced a manifest.
+ *
+ * @internal Exported for testing.
+ */
+export async function finalizeBuildManifest(
+  ctx: PluginContext,
+  fonts: FontsBuildStep,
+  rsc: DirectoryArtifact,
+  ssr: DirectoryArtifact
+): Promise<BuildManifest | null> {
+  const manifest = ctx.buildManifest;
+  if (manifest) {
+    fonts.contributeManifest(manifest);
+    // Per-route CSS and client reference JS, for <link rel="stylesheet">
+    // and <link rel="modulepreload"> on server component routes (TIM-1014).
+    await mergeRscAssetsManifest(rsc.path, ctx.root, manifest, ctx.routeClientRefKeys);
+  }
+  if (ctx.clientJavascript.disabled) {
+    // Those files are not served, so hints for them are useless.
+    if (manifest) {
+      manifest.js = {};
+      manifest.modulepreload = {};
+    }
+    await stripJsFromRscAssetsManifests([rsc.path, ssr.path]);
+  }
+  return manifest;
+}
+
+/**
+ * The build manifest as a JS module that sets the global. Adapters write
+ * it as `_timber-manifest-init.js` (or prepend it to the entry) and
+ * evaluate it before the RSC handler, so `virtual:timber-build-manifest`
+ * finds it.
+ */
+function serializeManifestInit(manifest: BuildManifest): string {
+  return `globalThis.__TIMBER_BUILD_MANIFEST__ = ${JSON.stringify(manifest)};\n`;
+}
+
+/**
+ * Dedupe the producers' directories and drop any that sits inside another.
+ *
+ * Two producers can name overlapping directories — a custom `assetsDir` of
+ * `_timber` beside the fonts' `_timber/fonts`. Cloudflare and Netlify apply
+ * every matching `_headers` rule, so emitting both would send two
+ * `Cache-Control` values for one file; the outer directory already covers
+ * the inner one.
+ */
+function canonicalImmutableDirs(dirs: readonly string[]): string[] {
+  const unique = [...new Set(dirs)];
+  return unique.filter(
+    (dir) => !unique.some((other) => other !== dir && dir.startsWith(`${other}/`))
+  );
+}
+
+/**
+ * Assemble the adapter's view of the build from what each step returned.
+ *
+ * Not a validator: every field is copied from the phase that produced it.
+ * The throws are the states the union cannot represent — a Vite environment
+ * that wrote no bundle, a static build with no site. Each means an earlier
+ * phase failed without failing the build, and a deploy missing its SSR
+ * bundle fails on the first request rather than here.
+ *
+ * @internal Exported for testing.
+ */
+export function assembleBuildArtifacts(input: {
+  output: 'server' | 'static';
+  outputDir: string;
+  environments: EnvironmentOutputs;
+  immutableDirs: readonly string[];
+  prebuilt?: DirectoryArtifact;
+  site?: StaticSite;
+  manifestInit?: string;
+}): BuildArtifacts {
+  const { output, outputDir, environments } = input;
+  const client = requireEnvironment(environments, 'client');
+  const immutableDirs = canonicalImmutableDirs(input.immutableDirs);
+
+  if (output === 'static') {
+    if (!input.site) {
+      throw new Error(
+        "[timber] Build output: output is 'static' but static generation recorded no site"
+      );
+    }
+    const { pages, contentTypes } = input.site;
+    return { output, outputDir, client, immutableDirs, pages, contentTypes };
+  }
+
+  return {
+    output,
+    outputDir,
+    client,
+    immutableDirs,
+    rsc: requireEnvironment(environments, 'rsc'),
+    ssr: requireEnvironment(environments, 'ssr'),
+    prebuilt: input.prebuilt,
+    manifestInit: input.manifestInit,
+  };
+}

package/src/plugins/prebuilt-capture.ts

@@ -1,8 +1,8 @@
 /**
  * Post-build prebuilt capture — Node-side orchestration (TIM-1119).
  *
- * Runs from timber-prebuilt's `buildApp` post hook, after Vite's 5-step
- * build sequence. Imports the BUILT `rsc/index.js` (the bundle carries
+ * Runs as the capture step of the post-build phase (plugins/post-build.ts),
+ * after Vite's 5-step build sequence and the manifest finalization step. Imports the BUILT `rsc/index.js` (the bundle carries
  * the react-server condition resolved at build time, so a plain dynamic
  * import works) and calls its `__timber_capturePrebuilt` export — the
  * capture itself must run inside the bundle's module graph, where the
@@ -25,11 +25,12 @@
  * prebuilt components.
  */
 
-import { existsSync } from 'node:fs';
-import { mkdir, rename, rm, writeFile } from 'node:fs/promises';
+import { mkdir, rm } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { writeFileAtomic } from '../utils/write-file-atomic.ts';
 
+import type { DirectoryArtifact } from '../adapters/types.ts';
 import type { PluginContext } from '../plugin-context.ts';
 import type { CaptureOptions, CaptureSummary, CapturedEntry } from '../server/prebuilt-builder.ts';
 import type { PrebuiltManifest } from '../server/prebuilt/payload-source.ts';
@@ -50,13 +51,6 @@ export interface PrebuiltArtifactWriter {
   finalize(): Promise<number>;
 }
 
-/** Write a file atomically: temp sibling + rename. */
-async function writeFileAtomic(path: string, data: Uint8Array | string): Promise<void> {
-  const tmp = `${path}.tmp`;
-  await writeFile(tmp, data);
-  await rename(tmp, path);
-}
-
 /**
  * Create the writer for `.timber/dist/prebuilt/`. Storage layout per
  * design/44 §Storage: one directory per component ID, one `.flight` file
@@ -105,13 +99,20 @@ export function createPrebuiltArtifactWriter(prebuiltDir: string): PrebuiltArtif
   };
 }
 
+/** What a capture pass produced. */
+export interface PrebuiltCaptureResult {
+  summary: CaptureSummary;
+  /** The payload directory — present only when the pass wrote a payload. */
+  artifact?: DirectoryArtifact;
+}
+
 /**
  * Remove any `prebuilt/` output left by a previous build in this
  * directory (watch mode, `emptyOutDir: false`). A stale manifest would
  * make adapters ship payloads from an OLD build — reviving them serves
  * outdated content with that build's chunk references instead of the
  * intended miss → live render. Runs unconditionally at the start of the
- * post-build hook, BEFORE the capture decision: a build whose app no
+ * capture step, BEFORE the capture decision: a build whose app no
  * longer declares any prebuilt components must also shed the artifacts
  * (codex P2 on PR #836).
  */
@@ -133,28 +134,19 @@ interface CaptureModule {
  * component). Per-entry data errors skip-and-report per design/44
  * §Build-Phase Error Handling.
  */
-export async function runPrebuiltCapture(ctx: PluginContext): Promise<CaptureSummary> {
+export async function runPrebuiltCapture(
+  ctx: PluginContext,
+  rscDir: string
+): Promise<PrebuiltCaptureResult> {
   const routeComponents = ctx.routePrebuiltComponents;
   if (!routeComponents || routeComponents.size === 0) {
-    return { captured: 0, skipped: [], hardErrors: [], nestingWarnings: 0 };
-  }
-
-  const entryPath = join(ctx.buildDir, 'rsc', 'index.js');
-  if (!existsSync(entryPath)) {
-    throw new Error(
-      `[timber] prebuilt capture: built RSC entry not found at ${entryPath} — ` +
-        `the app declares cache.component({ prerender: true }) call sites but the ` +
-        `RSC build output is missing`
-    );
+    return { summary: { captured: 0, skipped: [], hardErrors: [], nestingWarnings: 0 } };
   }
+  const entryPath = join(rscDir, 'index.js');
 
-  // The same globals the adapter entry sets before importing the handler
-  // (adapter-build.ts). The bundle's virtual:timber-build-manifest falls
-  // back to an empty manifest, but set the real values when available so
-  // capture-time behavior matches production startup.
+  // The build manifest global the bundle reads is published by the
+  // post-build phase before this step runs (plugins/post-build.ts).
   const g = globalThis as Record<string, unknown>;
-  if (ctx.buildManifest) g.__TIMBER_BUILD_MANIFEST__ ??= ctx.buildManifest;
-  if (ctx.deploymentId) g.__TIMBER_DEPLOYMENT_ID__ ??= ctx.deploymentId;
 
   console.log('[timber] cache.component: capturing prebuilt flight payloads…');
 
@@ -173,6 +165,7 @@ export async function runPrebuiltCapture(ctx: PluginContext): Promise<CaptureSum
     const entryUrl = `${pathToFileURL(entryPath).href}?t=${Date.now()}`;
     mod = (await import(/* @vite-ignore */ entryUrl)) as CaptureModule;
   } catch (error) {
+    // A missing entry lands here too: the import is the existence check.
     throw new Error(
       `[timber] prebuilt capture: failed to load the built RSC entry (${entryPath}). ` +
         `The capture pass runs the production server module inside the build process — ` +
@@ -188,7 +181,8 @@ export async function runPrebuiltCapture(ctx: PluginContext): Promise<CaptureSum
     );
   }
 
-  const writer = createPrebuiltArtifactWriter(join(ctx.buildDir, 'prebuilt'));
+  const prebuiltDir = join(ctx.buildDir, 'prebuilt');
+  const writer = createPrebuiltArtifactWriter(prebuiltDir);
   const summary = await capture({
     fileComponentMap: Object.fromEntries(routeComponents),
     callSiteProps: ctx.prebuiltCallSiteProps
@@ -206,12 +200,14 @@ export async function runPrebuiltCapture(ctx: PluginContext): Promise<CaptureSum
     );
   }
 
-  await writer.finalize();
+  // The manifest is written only when a payload was, so this is the one
+  // point that knows whether prebuilt/ is a product of this build.
+  const written = await writer.finalize();
 
   const total = summary.captured + summary.skipped.length;
   console.log(
     `[timber] Prebuilt ${summary.captured}/${total} entries.` +
       (summary.skipped.length > 0 ? ` ${summary.skipped.length} skipped due to errors.` : '')
   );
-  return summary;
+  return written > 0 ? { summary, artifact: { path: prebuiltDir } } : { summary };
 }

package/src/plugins/prebuilt.ts

@@ -71,6 +71,7 @@ import {
 import { collectJsxUsages, recordCallSiteProps } from './callsite-jsx.ts';
 import { mayPrerender, unwrapExpression } from './prebuilt-options-analysis.ts';
 import { cleanPrebuiltDir, runPrebuiltCapture } from './prebuilt-capture.ts';
+import type { PrebuiltCaptureResult } from './prebuilt-capture.ts';
 import type {
   CallExpressionNode,
   IdentifierNode,
@@ -263,12 +264,11 @@ const DEFAULT_SENTINEL = '\0default';
 
 async function collectCrossModuleProps(
   ctx: PluginContext,
+  bindingNames: ReadonlyMap<string, ReadonlyMap<string, string>>,
   moduleId: string,
   getInfo: (id: string) => PrebuiltModuleInfo | null,
   resolve: (source: string, importer: string) => Promise<string | null>
 ): Promise<void> {
-  const bindingNames = ctx.prebuiltBindingNames!;
-
   const info = getInfo(moduleId);
   if (!info) return;
 
@@ -362,10 +362,53 @@ async function collectCrossModuleProps(
   }
 }
 
-export function timberPrebuilt(ctx: PluginContext): Plugin {
+/**
+ * What the post-build phase asks of the prebuilt plugin (plugins/post-build.ts).
+ */
+export interface PrebuiltBuildStep {
+  /**
+   * Run the capture pass against the built RSC bundle in `rscDir`. Always
+   * removes the previous build's `prebuilt/` first — even when this build
+   * captures nothing, a stale manifest must never ship. Returns null when
+   * there was nothing to capture: no prerender call site is reachable from a
+   * route, or `output: 'static'` already renders everything at build time.
+   */
+  capture(rscDir: string): Promise<PrebuiltCaptureResult | null>;
+}
+
+export function timberPrebuilt(ctx: PluginContext): Plugin & { api: PrebuiltBuildStep } {
+  /**
+   * Module ID → prerender-capable component IDs declared in it. Recorded by
+   * the RSC transform, read by the RSC `generateBundle` module-graph walk
+   * that computes `ctx.routePrebuiltComponents`. Build only.
+   */
+  const moduleComponents = new Map<string, string[]>();
+  /**
+   * Module ID → variable name → component ID, for the prebuilt components
+   * that module declares. Read at `generateBundle` time to trace imports in
+   * other modules back to component IDs (cross-module call-site props).
+   */
+  const bindingNames = new Map<string, Map<string, string>>();
+
   return {
     name: 'timber-prebuilt',
 
+    api: {
+      async capture(rscDir) {
+        await cleanPrebuiltDir(ctx.buildDir);
+        if (!ctx.routePrebuiltComponents || ctx.routePrebuiltComponents.size === 0) return null;
+        if (ctx.config.output === 'static') {
+          // design/44 §output: 'static' — everything already renders at
+          // build time there; the wrapper is a no-op, not an error.
+          console.log(
+            `[timber] cache.component: skipped prerender capture (output: 'static' renders all components at build time)`
+          );
+          return null;
+        }
+        return runPrebuiltCapture(ctx, rscDir);
+      },
+    },
+
     transform(code, id) {
       // Drop this module's stale attribution first — in a long-lived
       // `vite build --watch` process the plugin context outlives builds,
@@ -374,7 +417,8 @@ export function timberPrebuilt(ctx: PluginContext): Plugin {
       // below (codex P2 on PR #836). Re-recorded at the bottom if the
       // edited module still has prerender-capable call sites.
       if (!ctx.dev && this?.environment?.name === 'rsc') {
-        ctx.prebuiltModuleComponents?.delete(id);
+        moduleComponents.delete(id);
+        bindingNames.delete(id);
       }
       if (!code.includes('@timber-js/app/cache') && !code.includes('timber/cache')) return;
       // Skip node_modules (don't transform third-party code)
@@ -432,8 +476,7 @@ export function timberPrebuilt(ctx: PluginContext): Plugin {
       // Record this module's component IDs for the RSC generateBundle
       // module-graph walk (route → component attribution, TIM-1119).
       if (!ctx.dev && componentIds.length > 0 && this?.environment?.name === 'rsc') {
-        ctx.prebuiltModuleComponents ??= new Map();
-        ctx.prebuiltModuleComponents.set(id, componentIds);
+        moduleComponents.set(id, componentIds);
 
         // Record binding name → component ID mapping for cross-module
         // prop detection at generateBundle time (TIM-1142).
@@ -485,8 +528,7 @@ export function timberPrebuilt(ctx: PluginContext): Plugin {
         }
 
         if (bindingMap.size > 0) {
-          ctx.prebuiltBindingNames ??= new Map();
-          ctx.prebuiltBindingNames.set(id, bindingMap);
+          bindingNames.set(id, bindingMap);
         }
 
         // Same-module JSX usages: if a prebuilt component is declared AND
@@ -542,8 +584,8 @@ export function timberPrebuilt(ctx: PluginContext): Plugin {
       if (ctx.dev) return;
       if (this?.environment?.name !== 'rsc') return;
       ctx.routePrebuiltComponents = undefined;
-      const moduleComponents = ctx.prebuiltModuleComponents;
-      if (!moduleComponents || moduleComponents.size === 0 || !ctx.routeTree) return;
+      ctx.prebuiltLazyChunks = undefined;
+      if (moduleComponents.size === 0 || !ctx.routeTree) return;
 
       const self = this as unknown as {
         getModuleInfo?: (id: string) => PrebuiltModuleInfo | null;
@@ -592,7 +634,7 @@ export function timberPrebuilt(ctx: PluginContext): Plugin {
         // for JSX usages of prebuilt components — not just the route files
         // themselves. A component used in a helper (page → Shell → <BlogBody>)
         // must have its props captured from wherever the JSX lives.
-        if (ctx.prebuiltBindingNames && ctx.prebuiltBindingNames.size > 0) {
+        if (bindingNames.size > 0) {
           const scannedModules = new Set<string>();
           for (const filePath of routeComponents.keys()) {
             const visited = new Set<string>();
@@ -603,7 +645,7 @@ export function timberPrebuilt(ctx: PluginContext): Plugin {
               visited.add(modId);
               if (!scannedModules.has(modId)) {
                 scannedModules.add(modId);
-                await collectCrossModuleProps(ctx, modId, getInfo, resolveFn);
+                await collectCrossModuleProps(ctx, bindingNames, modId, getInfo, resolveFn);
               }
               const modInfo = getInfo(modId);
               if (!modInfo) continue;
@@ -624,32 +666,5 @@ export function timberPrebuilt(ctx: PluginContext): Plugin {
         );
       }
     },
-
-    /**
-     * Post-build capture (design/44 §Build Phase). `order: 'post'` runs
-     * after the RSC plugin's buildApp — all five build steps are complete —
-     * and BEFORE timber-adapter-build's post hook (plugin array order), so
-     * `prebuilt/` exists when the adapter assembles its output (TIM-1122).
-     */
-    buildApp: {
-      order: 'post' as const,
-      async handler() {
-        if (ctx.dev) return;
-        ctx.captureSummary = undefined;
-        // Always shed a previous build's artifacts first — even when THIS
-        // build captures nothing, a stale manifest must never ship.
-        await cleanPrebuiltDir(ctx.buildDir);
-        if (!ctx.routePrebuiltComponents || ctx.routePrebuiltComponents.size === 0) return;
-        if (ctx.config.output === 'static') {
-          // design/44 §output: 'static' — everything already renders at
-          // build time there; the wrapper is a no-op, not an error.
-          console.log(
-            `[timber] cache.component: skipped prerender capture (output: 'static' renders all components at build time)`
-          );
-          return;
-        }
-        ctx.captureSummary = await runPrebuiltCapture(ctx);
-      },
-    },
   };
 }

package/src/plugins/prerender-sugar.ts

@@ -227,10 +227,6 @@ export function timberPrerenderSugar(ctx: PluginContext): Plugin {
         if (declText.includes('.component(')) return;
       }
 
-      // Record this page as desugared for downstream attribution
-      ctx.prerenderSugarPages ??= new Set();
-      ctx.prerenderSugarPages.add(id);
-
       const s = new MagicString(code);
       const optionsSource = buildOptionsSource(value);