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

package/src/dev-tools/overlay.ts

@@ -4,51 +4,15 @@
  * Integrates with Vite's built-in error overlay (`server.hot.send`) rather
  * than implementing a custom overlay.
  *
- * Stack trace source-mapping uses the correct Vite environment module graph:
- * RSC errors use `server.environments.rsc.moduleGraph`, SSR/other errors use
- * `server.environments.ssr.moduleGraph`. `server.ssrFixStacktrace()` is NOT
- * used because it hardcodes the SSR module graph, which doesn't contain
- * source maps for RSC modules (separate Vite environment with its own
- * module graph). This caused RSC errors to show transpiled line numbers
- * instead of original source positions.
+ * Stacks are shown as they arrive: Vite's module runner already reports
+ * source positions for the code it runs, and a second mapping pass moves
+ * them (TIM-1555).
  *
- * Design doc: 21-dev-server.md §"Error Overlay"
+ * Design doc: 21-dev-server.md §"Error Overlay", §"RSC Source-Mapping"
  */
 
-import type { ViteDevServer, DevEnvironment } from 'vite';
-import { createRequire } from 'node:module';
-import { resolve, dirname } from 'node:path';
-import { classifyFrame, type FrameType } from './stack-classifier.ts';
-
-// ─── Trace Mapping (lazy-loaded) ─────────────────────────────────────────────
-
-interface TraceMappingModule {
-  TraceMap: new (map: unknown) => unknown;
-  originalPositionFor: (
-    map: unknown,
-    needle: { line: number; column: number }
-  ) => { source: string | null; line: number | null; column: number | null };
-}
-
-let _traceMapping: TraceMappingModule | null = null;
-
-/**
- * Lazy-load @jridgewell/trace-mapping from Vite's dependency tree.
- * Vite bundles it internally; we resolve from Vite's package to avoid
- * adding a direct dependency.
- */
-function getTraceMapping(): TraceMappingModule {
-  if (_traceMapping) return _traceMapping;
-  // Resolve from Vite's package location so we pick up its transitive
-  // @jridgewell/trace-mapping without declaring it as a direct dependency.
-  // createRequire(import.meta.url) gives us ESM-compatible require (TIM-796),
-  // then we hop to Vite's path to reach its dependency tree (TIM-804).
-  const esmRequire = createRequire(import.meta.url);
-  const vitePath = esmRequire.resolve('vite');
-  const viteRequire = createRequire(vitePath);
-  _traceMapping = viteRequire('@jridgewell/trace-mapping') as TraceMappingModule;
-  return _traceMapping;
-}
+import type { ViteDevServer } from 'vite';
+import { classifyFrame } from './stack-classifier.ts';
 
 // ─── Types ──────────────────────────────────────────────────────────────────
 
@@ -164,200 +128,13 @@ export function classifyErrorPhase(error: Error, projectRoot: string): ErrorPhas
 import { formatTerminalError as _formatTerminalError } from './terminal.ts';
 export const formatTerminalError = _formatTerminalError;
 
-// ─── Module Runner Offset ───────────────────────────────────────────────────
-
-/**
- * Dynamically compute the line offset that Vite's module runner adds
- * when wrapping modules in an async function.
- *
- * Vite's `calculateOffsetOnce()` uses the same technique: create a new
- * AsyncFunction, throw from line 1, and check where the engine reports
- * the error. The difference between the reported line and 1 is the offset.
- *
- * This is engine-dependent (currently 2 on Node 18-22) and could change
- * in future Node.js or V8 versions. Computing it at runtime ensures we
- * always match the actual behavior.
- */
-let _cachedOffset: number | null = null;
-
-export function calculateModuleRunnerOffset(): number {
-  if (_cachedOffset !== null) return _cachedOffset;
-
-  try {
-    // Parse the AsyncFunction source to count wrapper lines before the body.
-    // AsyncFunction.toString() returns something like:
-    //   "async function anonymous(\n) {\nBODY\n}"
-    // The number of newlines before BODY is the offset Vite's module runner adds.
-    // eslint-disable-next-line no-new-func -- intentional: mirrors Vite's technique
-    const AsyncFunction = async function () {}.constructor as typeof Function;
-    const wrapper = new AsyncFunction('BODY');
-    const src = wrapper.toString();
-    const bodyIndex = src.indexOf('BODY');
-    if (bodyIndex === -1) {
-      _cachedOffset = 2; // fallback
-      return _cachedOffset;
-    }
-    const beforeBody = src.slice(0, bodyIndex);
-    const newlineCount = (beforeBody.match(/\n/g) || []).length;
-    _cachedOffset = newlineCount;
-  } catch (e) {
-    console.debug(
-      '[timber] overlay offset calculation failed:',
-      e instanceof Error ? e.message : e
-    );
-    _cachedOffset = 2; // fallback to known-good value
-  }
-
-  return _cachedOffset;
-}
-
-// ─── Stack Trace Source-Mapping ──────────────────────────────────────────────
-
-/**
- * Phases where the error originated in the RSC environment.
- * These use `server.environments.rsc.moduleGraph` for source-mapping.
- */
-const RSC_PHASES: ReadonlySet<ErrorPhase> = new Set(['render', 'access', 'middleware', 'handler']);
-
-/**
- * Rewrite an error's stack trace using the correct Vite environment module graph.
- *
- * `server.ssrFixStacktrace()` hardcodes `server.environments.ssr.moduleGraph`,
- * but RSC errors have stack frames pointing to modules loaded in the RSC
- * environment — a separate Vite module graph with separate transform results
- * and source maps. Using the SSR module graph silently fails to find the
- * modules, leaving transpiled/bundled line numbers in the stack trace.
- *
- * This function picks the RSC module graph for render-phase errors and falls
- * back to SSR for module-transform/proxy errors. If the first pass doesn't
- * rewrite any frames (e.g., mixed RSC+SSR stack), it tries the other graph.
- */
-function fixStacktraceForEnvironment(server: ViteDevServer, error: Error, phase: ErrorPhase): void {
-  if (!error.stack) return;
-
-  // Pick the primary environment based on error phase
-  const primaryEnvName = RSC_PHASES.has(phase) ? 'rsc' : 'ssr';
-  const fallbackEnvName = primaryEnvName === 'rsc' ? 'ssr' : 'rsc';
-
-  const primaryEnv = server.environments[primaryEnvName] as DevEnvironment | undefined;
-  const fallbackEnv = server.environments[fallbackEnvName] as DevEnvironment | undefined;
-
-  // Try primary environment first
-  if (primaryEnv?.moduleGraph) {
-    const rewritten = rewriteStacktrace(error.stack, primaryEnv.moduleGraph);
-    if (rewritten.changed) {
-      error.stack = rewritten.stack;
-      return;
-    }
-  }
-
-  // Fall back to the other environment if primary didn't rewrite anything
-  if (fallbackEnv?.moduleGraph) {
-    const rewritten = rewriteStacktrace(error.stack, fallbackEnv.moduleGraph);
-    if (rewritten.changed) {
-      error.stack = rewritten.stack;
-      return;
-    }
-  }
-}
-
-/**
- * Rewrite stack trace frames using source maps from an environment's module graph.
- *
- * Mirrors Vite's internal `ssrRewriteStacktrace` logic but works with any
- * `EnvironmentModuleGraph`, not just the SSR one.
- *
- * Returns the rewritten stack and whether any frames were actually changed.
- */
-function rewriteStacktrace(
-  stack: string,
-  moduleGraph: DevEnvironment['moduleGraph']
-): { stack: string; changed: boolean } {
-  let changed = false;
-
-  const result = stack
-    .split('\n')
-    .map((line) => {
-      return line.replace(
-        /^ {4}at (?:(\S.*?)\s\()?(.+?):(\d+)(?::(\d+))?\)?/,
-        (input, varName, id, lineStr, colStr) => {
-          if (!id) return input;
-
-          const mod = moduleGraph.getModuleById(id);
-          const rawSourceMap = mod?.transformResult?.map;
-          if (!rawSourceMap) return input;
-
-          // Vite's module runner wraps each module in an async function,
-          // adding N lines before the module body. The offset is computed
-          // dynamically to match the actual engine behavior (see TIM-783).
-          const OFFSET = calculateModuleRunnerOffset();
-          const origLine = Number(lineStr) - OFFSET;
-          const origCol = Number(colStr) - 1;
-          if (origLine <= 0 || origCol < 0) return input;
-
-          // Use @jridgewell/trace-mapping resolved from Vite's dependency tree.
-          // Vite bundles it internally; we resolve from Vite's package location
-          // to avoid adding a direct dependency.
-          let pos: { source: string | null; line: number | null; column: number | null };
-          try {
-            const { TraceMap: TM, originalPositionFor: opf } = getTraceMapping();
-            const traced = new TM(rawSourceMap);
-            pos = opf(traced, { line: origLine, column: origCol });
-          } catch (e) {
-            console.debug(
-              '[timber] source map tracing failed:',
-              e instanceof Error ? e.message : e
-            );
-            return input;
-          }
-
-          if (!pos.source || pos.line == null) return input;
-
-          changed = true;
-          const source = `${resolve(dirname(id), pos.source)}:${pos.line}:${(pos.column ?? 0) + 1}`;
-          const trimmedVarName = varName?.trim();
-          if (!trimmedVarName || trimmedVarName === 'eval') return `    at ${source}`;
-          return `    at ${trimmedVarName} (${source})`;
-        }
-      );
-    })
-    .join('\n');
-
-  return { stack: result, changed };
-}
-
-// ─── Error Source-Mapping (exported for use by fallback-error.ts) ────────────
-
-/**
- * Source-map an error's stack trace using the Vite dev server's module graph.
- *
- * Exported so that the fallback error renderer (fallback-error.ts) can
- * source-map errors before rendering the dev error page. Without this,
- * the dev error page shows transpiled positions (e.g. page.tsx:1:1 instead
- * of page.tsx:4:9).
- *
- * See TIM-811.
- */
-export function fixErrorStacktrace(server: ViteDevServer, error: Error, phase?: ErrorPhase): void {
-  fixStacktraceForEnvironment(
-    server,
-    error,
-    phase ?? classifyErrorPhase(error, server.config.root)
-  );
-}
-
 // ─── Overlay Integration ────────────────────────────────────────────────────
 
 /**
  * Send an error to Vite's browser overlay and log it to stderr.
  *
- * Uses `server.ssrFixStacktrace()` to map stack traces back to source,
- * then sends the error via `server.hot.send()` for the browser overlay.
- *
- * When `rscDebugComponents` is provided (dev mode only), the server
- * component tree context is appended to the error message. This helps
- * developers identify which server component caused the error without
- * exposing source code.
+ * Reads `error` and never writes it: the pipeline may render the same object
+ * on the fallback error page after reporting it here.
  *
  * The dev server remains running — errors are handled, not fatal.
  */
@@ -367,13 +144,6 @@ export function sendErrorToOverlay(
   phase: ErrorPhase,
   projectRoot: string
 ): void {
-  // Fix stack trace to use source-mapped positions.
-  // Use the RSC environment's module graph for render/access/middleware errors
-  // (which originate in the RSC environment), and fall back to SSR for others.
-  // server.ssrFixStacktrace() is NOT used — it hardcodes the SSR module graph
-  // which doesn't contain source maps for RSC-loaded modules.
-  fixStacktraceForEnvironment(server, error, phase);
-
   // Log to stderr with frame dimming
   const formatted = formatTerminalError(error, phase, projectRoot);
   process.stderr.write(`${formatted}\n`);

package/src/index.ts

@@ -37,7 +37,7 @@ import { timberRequestDep } from './plugins/request-dep/index.ts';
 import { timberPrebuilt } from './plugins/prebuilt.ts';
 import { timberPrerenderSugar } from './plugins/prerender-sugar.ts';
 import { timberCloudflareWasm } from './plugins/cloudflare-wasm.ts';
-import { timberAdapterBuild } from './plugins/adapter-build.ts';
+import { timberPostBuild } from './plugins/post-build.ts';
 import { timberBuildReport } from './plugins/build-report.ts';
 import { createNoopTimer } from './utils/startup-timer.ts';
 import {
@@ -289,11 +289,11 @@ export function timber(config?: TimberUserConfig): PluginOption[] {
       // ── Resolve build output directory ─────────────────────────
       // Priority: timber.config.ts `buildDir` > Vite `build.outDir` > .timber/dist
       // Set Vite's build.outDir so the RSC plugin and all environment
-      // builds write to the correct location.
-      const viteOutDir = userConfig.build?.outDir;
-      const timberBuildDir = ctx.config.buildDir;
+      // builds write to the correct location. ctx.buildDir is read back
+      // from Vite in configResolved, so there is one answer to where the
+      // build went.
       const resolvedRoot = resolve(userConfig.root ?? process.cwd());
-      ctx.buildDir = resolveBuildDir(resolvedRoot, timberBuildDir, viteOutDir);
+      const buildDir = resolveBuildDir(resolvedRoot, ctx.config.buildDir, userConfig.build?.outDir);
 
       // Warn if the Vite root differs from cwd and the re-loaded config
       // has reactCompiler but the early cwd-based load missed it. In this
@@ -386,9 +386,9 @@ export function timber(config?: TimberUserConfig): PluginOption[] {
         resolvedDevPortExplicit = start.explicit;
       }
 
-      // Derive relative buildOutDir from the absolute ctx.buildDir (set above)
+      // Derive relative buildOutDir from the absolute buildDir (set above)
       // so Vite's config receives a root-relative path.
-      const buildOutDir = relative(resolvedRoot, ctx.buildDir);
+      const buildOutDir = relative(resolvedRoot, buildDir);
 
       // Set per-environment build.outDir so Vite's RSC plugin writes
       // each environment to the correct subdirectory under our buildDir.
@@ -500,8 +500,10 @@ export function timber(config?: TimberUserConfig): PluginOption[] {
       // The watcher.add() call in dev-server.ts ensures the files are
       // watched even if created after server start.
 
-      // Sync buildDir from Vite's resolved build.outDir. Vite keeps
-      // outDir as-is (may be relative), so resolve against root.
+      // The build directory is what Vite resolved build.outDir to — the
+      // config hook's value after every other plugin and the user config had
+      // their say. Vite keeps outDir as-is (may be relative), so resolve
+      // against root.
       ctx.buildDir = resolve(resolved.root, resolved.build.outDir);
       // In production builds, swap to a no-op timer to avoid overhead
       if (!ctx.dev) {
@@ -552,6 +554,14 @@ export function timber(config?: TimberUserConfig): PluginOption[] {
   // We do NOT set customBuildApp — the RSC plugin's orchestration is correct
   // and handles bundle ordering, asset manifest generation, and environment
   // imports manifest. See @vitejs/plugin-rsc's buildApp implementation.
+  //
+  // Everything after it runs in timber-post-build, in the order that plugin
+  // states. The plugins that own a post-build step expose it as their `api`
+  // and are handed to it here, so no step's order depends on where a plugin
+  // sits in this array. See design/18-build-system.md §"Post-Build Phase".
+  const fonts = timberFonts(ctx);
+  const prebuilt = timberPrebuilt(ctx);
+  const buildReport = timberBuildReport(ctx);
   return [
     rootSync,
     timberReactResolve(),
@@ -570,19 +580,19 @@ export function timber(config?: TimberUserConfig): PluginOption[] {
     timberRouting(ctx),
     timberEntries(ctx),
     timberBuildManifest(ctx),
-    timberFonts(ctx),
+    fonts,
     timberMdx(ctx),
     timberRequestDep(ctx),
     timberCacheTransform(ctx),
     timberPrerenderSugar(ctx), // export const prerender → cache.component() desugaring
-    timberPrebuilt(ctx), // cache.component() → __prebuilt() callsite rewrite
-    timberStaticBuild(ctx), // Static mode: validate + post-build HTML generation
+    prebuilt, // cache.component() → __prebuilt() callsite rewrite
+    timberStaticBuild(ctx), // Static mode: validate dynamic API usage
     timberContent(ctx),
     timberServerBundle(), // Bundle all deps in server environments for prod
     timberCloudflareWasm(ctx), // Externalize WASM for Cloudflare Workers
     timberChunks(ctx),
-    timberBuildReport(ctx), // Post-build: route table with bundle sizes
-    timberAdapterBuild(ctx), // Post-build: invoke adapter.buildOutput()
+    buildReport, // Route table with bundle sizes, printed by timber-post-build
+    timberPostBuild(ctx, { fonts: fonts.api, prebuilt: prebuilt.api, report: buildReport.api }),
     timberDevLogs(ctx), // Dev-only: forward server console.* to browser console
     timberDevServer(ctx), // Must be last — configureServer post-hook runs after all watchers
   ];

package/src/plugin-context.ts

@@ -14,13 +14,13 @@ import { createRequire } from 'node:module';
 import { parseAst } from 'vite';
 import type { RouteTree } from './routing/types.ts';
 import type { BuildManifest } from './server/build-manifest.ts';
-import type { CaptureSummary } from './server/prebuilt-builder.ts';
 import type { StartupTimer } from './utils/startup-timer.ts';
 import { createStartupTimer } from './utils/startup-timer.ts';
 import type { TimberUserConfig, ClientJavascriptConfig } from './config-types.ts';
-import type { RscManifest } from './plugins/static-build.ts';
 import type { HoldingServer } from './dev-tools/holding-server.ts';
 import type { ProgramNode } from './plugins/callsite-ast.ts';
+import type { TimberConfig, TimberPlatformAdapter } from './adapters/types.ts';
+import { normalizeBasePath } from './shared/base-path.ts';
 
 // Re-export for sub-plugin convenience — they import from plugin-context.ts
 export type { TimberUserConfig, ClientJavascriptConfig } from './config-types.ts';
@@ -88,7 +88,11 @@ export interface PluginContext {
    * does). See TIM-1261.
    */
   base: string;
-  /** CSS build manifest (populated by adapter after client build, null in dev) */
+  /**
+   * The build manifest. Created by timber-build-manifest from the client
+   * bundle and finalized by the post-build phase (plugins/post-build.ts),
+   * which is the only reader. Null in dev.
+   */
   buildManifest: BuildManifest | null;
   /** Per-build deployment ID for version skew detection (null in dev) */
   deploymentId: string | null;
@@ -103,13 +107,16 @@ export interface PluginContext {
    * `timber.config.ts` `buildDir` or Vite's `build.outDir`.
    * Timber config takes precedence when both are set.
    *
-   * Used by adapter-build and cli preview.
+   * The `config` hook resolves it into Vite's `build.outDir`, and
+   * `configResolved` reads it back from Vite — the one assignment after
+   * construction, so what the build writes to and what `timber preview`
+   * serves (through {@link TimberPluginApi}) are the same directory.
    */
   buildDir: string;
   /**
    * Per-route client reference keys captured during the RSC build.
    * Maps absolute route file paths to the set of client reference
-   * hash keys they transitively import. Used by adapter-build to
+   * hash keys they transitively import. Used by the post-build phase to
    * populate per-route modulepreload entries from clientReferenceDeps.
    */
   routeClientRefKeys?: Map<string, Set<string>>;
@@ -138,19 +145,6 @@ export interface PluginContext {
    * See design/27-chunking-strategy.md, TIM-1107.
    */
   sharedModuleFacades?: Map<string, string[]>;
-  /**
-   * Module ID → prebuilt component IDs declared in it. Recorded by the
-   * timber-prebuilt transform (RSC environment, production builds only),
-   * consumed by the RSC `generateBundle` module-graph walk that computes
-   * `routePrebuiltComponents`. See design/44-render-at-build-time.md.
-   */
-  prebuiltModuleComponents?: Map<string, string[]>;
-  /**
-   * Module ID → mapping of variable name to component ID for the prebuilt
-   * components declared in that module. Used at `generateBundle` time to
-   * trace imports from other modules back to specific component IDs.
-   */
-  prebuiltBindingNames?: Map<string, Map<string, string>>;
   /**
    * Component ID → distinct static call-site prop objects captured from
    * JSX usage sites during the transform and generateBundle phases.
@@ -165,12 +159,6 @@ export interface PluginContext {
    * components to render under which route's param combos.
    */
   routePrebuiltComponents?: Map<string, string[]>;
-  /**
-   * Page file paths that were desugared from `export const prerender` by
-   * timber-prerender-sugar. The prebuilt transform uses this to verify
-   * the generated `cache.component(...)` call was picked up.
-   */
-  prerenderSugarPages?: Set<string>;
   /**
    * Component ID → built chunk file name for prebuilt-declaring modules
    * that are only reachable via dynamic imports (import.meta.glob, lazy
@@ -179,8 +167,6 @@ export interface PluginContext {
    * RSC generateBundle alongside routePrebuiltComponents.
    */
   prebuiltLazyChunks?: Map<string, string>;
-  /** Post-build prebuilt capture summary (populated by timber-prebuilt, consumed by build-report). */
-  captureSummary?: CaptureSummary;
   /**
    * Content-keyed AST parse memo shared across cache/prebuilt/prerender-sugar
    * transforms. Collapses both cross-plugin and cross-environment duplicate
@@ -192,18 +178,6 @@ export interface PluginContext {
    * ranges and rewrite CODE via MagicString; the AST itself is never mutated.
    */
   parseCached?: ParseMemo;
-  /**
-   * Content-Type mappings for extensionless static API route outputs.
-   * Populated during static generation, consumed by adapter-build to
-   * write per-path Content-Type rules in _headers. See TIM-1241.
-   */
-  staticContentTypes?: Record<string, string>;
-  /**
-   * RSC flight payload manifest mapping unhashed → hashed URLs.
-   * Populated during static generation, consumed by adapters to set
-   * immutable cache headers for `_rsc/` files. See TIM-1254.
-   */
-  rscManifest?: RscManifest;
 }
 
 // ── AST parse memo ───────────────────────────────────────────────────────
@@ -274,6 +248,30 @@ export function isTimberPluginApi(api: unknown): api is TimberPluginApi {
   );
 }
 
+/**
+ * The configured platform adapter. `adapter` is typed `unknown` on the user
+ * config so that `timber.config.ts` does not depend on the adapter types; the
+ * adapter factories are what produce values of this shape.
+ */
+export function contextAdapter(ctx: PluginContext): TimberPlatformAdapter | undefined {
+  return ctx.config.adapter as TimberPlatformAdapter | undefined;
+}
+
+/**
+ * The configuration an adapter is handed, derived once from the resolved
+ * context — by the post-build phase for `buildOutput` and by `timber preview`
+ * for `preview`.
+ */
+export function adapterConfig(ctx: PluginContext): TimberConfig {
+  return {
+    root: ctx.root,
+    // Normalized once here, not in each adapter: the platform files
+    // adapters write address deployed-URL space (TIM-1274).
+    base: normalizeBasePath(ctx.base),
+    clientJavascriptDisabled: ctx.clientJavascript.disabled,
+  };
+}
+
 /**
  * Resolve the app directory. Checks (in order):
  * 1. Explicit `configAppDir` from timber.config.ts
@@ -439,8 +437,9 @@ export function loadTimberConfigFile(root: string): TimberUserConfig | null {
 
 /**
  * Detect config keys set in both inline (vite.config.ts) and file (timber.config.ts)
- * and warn the user. The `output` key is excluded because it defaults to 'server'
- * in createPluginContext and would always appear as an inline key.
+ * and warn the user. Only keys the inline config actually sets count — the
+ * `output` default is applied after the merge (timber-root-sync), so it never
+ * appears here as an inline key.
  *
  * Returns the list of conflicting key names (for testing).
  */

package/src/plugins/build-manifest.ts

@@ -418,7 +418,7 @@ export function timberBuildManifest(ctx: PluginContext): Plugin {
 
       // RSC environment: walk the module graph to find which client
       // references each route file transitively imports. Store the
-      // mapping in ctx so the adapter-build post hook can cross-reference
+      // mapping in ctx so the post-build phase can cross-reference
       // with clientReferenceDeps to populate per-route modulepreloads.
       if (envName === 'rsc' && ctx.routeTree) {
         const clientRefIndex = buildClientRefIndex(bundle);
@@ -475,17 +475,10 @@ export function timberBuildManifest(ctx: PluginContext): Plugin {
 
         // When client JavaScript is disabled, strip JS chunks from the bundle
         // so Rollup never writes them to disk. CSS assets are preserved —
-        // they're still needed for server-rendered HTML.
-        //
-        // This is an optimization: adapter-build.ts still strips JS from the
-        // build manifest and RSC assets manifest as a defense-in-depth fallback.
+        // they're still needed for server-rendered HTML. The JS references
+        // in the manifest are stripped once, by the post-build phase, after
+        // it has merged in everything else (plugins/post-build.ts).
         if (ctx.clientJavascript.disabled) {
-          // Clear JS and modulepreload from the manifest (they'd be stripped
-          // by adapter-build.ts anyway, but doing it here avoids the round-trip).
-          ctx.buildManifest.js = {};
-          ctx.buildManifest.modulepreload = {};
-
-          // Remove JS chunks from the Rollup bundle — prevents disk writes.
           for (const [fileName, item] of Object.entries(bundle)) {
             if (item.type === 'chunk') {
               delete bundle[fileName];