bake: keep a route failed when the "use client" file it imports fails to bundle

src/bundler/bundle_v2.rs

@@ -5883,6 +5883,27 @@ pub mod bv2_impl {
                 bun_core::scoped_log!(Bundle, "failed with error: {}", err.name());
                 resolve_result.resolve_queue.clear();
 
+                // With a separate SSR graph, a "use client" file is parsed for
+                // the browser even when a server file imported it (see
+                // `ParseTask`), so its resolution failures were reported to the
+                // client graph. The server-side half of the boundary is only
+                // created on success (`on_parse_task_complete`), so tell the
+                // dev server now; otherwise the server importers have nothing
+                // to attach to and the failure is unreachable from their routes.
+                if let Some(dev) = this.dev_server {
+                    if result.use_directive == crate::UseDirective::Client
+                        && target == Target::Browser
+                        && this
+                            .framework
+                            .as_ref()
+                            .and_then(|framework| framework.server_components.as_ref())
+                            .is_some_and(|sc| sc.separate_ssr_graph)
+                    {
+                        dev.handle_client_component_boundary_failure(result.source.path.text)
+                            .expect("oom");
+                    }
+                }
+
                 // Preserve the parsed import_records on the graph so any plugin
                 // onResolve tasks already dispatched for *other* records in this
                 // same file can still dereference

src/bundler/lib.rs

@@ -325,6 +325,7 @@ bun_dispatch::link_interface! {
         fn log_for_resolution_failures(abs_path: &[u8], graph: bake_types::Graph) -> *mut bun_ast::Log;
         fn finalize_bundle(bv2: *mut bundle_v2::BundleV2<'_>, result: *mut bundle_v2::DevServerOutput<'_>) -> Result<(), crate::Error>;
         fn handle_parse_task_failure(err: crate::Error, graph: bake_types::Graph, abs_path: &[u8], log: *const bun_ast::Log, bv2: *mut bundle_v2::BundleV2<'_>) -> Result<(), crate::Error>;
+        fn handle_client_component_boundary_failure(abs_path: &[u8]) -> Result<(), crate::Error>;
         fn put_or_overwrite_asset(path: *const (), contents: &[u8], content_hash: u64) -> Result<(), crate::Error>;
         fn track_resolution_failure(import_source: &[u8], specifier: &[u8], renderer: bake_types::Graph, loader: bun_ast::Loader) -> Result<(), crate::Error>;
         fn is_file_cached(abs_path: &[u8], side: bake_types::Graph) -> Option<bake_types::CacheEntry>;

src/runtime/bake/DevServer.rs

@@ -2251,6 +2251,10 @@ fn check_route_failures(
     resp: DevResponse,
 ) -> crate::Result<CheckResult> {
     let mut gts = dev.init_graph_trace_state(0)?;
+    // The trace below collects into `failures_added`, which still holds the
+    // failures of the last bundle (it is only reset when the next one starts).
+    // Those may belong to files this route never imports.
+    dev.incremental_result.failures_added.clear();
     // Note: erase to a raw pointer so the deferred cleanup only fires on
     // scope exit when no other borrow of `dev` is live.
     let dev_ptr = std::ptr::from_mut::<DevServer>(dev);
@@ -4388,13 +4392,19 @@ pub(super) fn finalize_bundle(
         dev.incremental_result.html_routes_soft_affected.clear();
         ctx.gts.clear();
 
-        for index in &dev.incremental_result.client_components_affected {
+        // `trace_dependencies` appends every boundary it visits to this same
+        // list (their trace bit is set at that point, so visiting them again
+        // below is a no-op), so it must not be iterated through a borrow.
+        let mut i = 0;
+        while i < dev.incremental_result.client_components_affected.len() {
+            let index = dev.incremental_result.client_components_affected[i];
             dev.server_graph.trace_dependencies(
-                *index,
+                index,
                 ctx.gts,
                 incremental_graph::TraceDependencyGoal::NoStop,
-                *index,
+                index,
             )?;
+            i += 1;
         }
 
         for request in &dev.incremental_result.framework_routes_affected {
@@ -4984,6 +4994,42 @@ impl DevServer {
         Ok(())
     }
 
+    /// A "use client" file whose own imports failed to resolve. The failure
+    /// belongs to the client graph (the file was parsed for the browser, see
+    /// `get_log_for_resolution_failures`), but a boundary that bundles gets a
+    /// node on both sides: server-side importers attach their edges to the
+    /// server node, whose boundary flag makes import traces continue into the
+    /// client graph, and the client node is an HMR root so dependency traces
+    /// cross back to the server side. `finalize_bundle` only sets this up for
+    /// files that bundled, so do it here for the failed one; otherwise the
+    /// routes importing the file are never associated with its failure and get
+    /// served as if it had bundled.
+    pub(crate) fn handle_client_component_boundary_failure(
+        &mut self,
+        abs_path: &[u8],
+    ) -> Result<(), AllocError> {
+        let _g = self.graph_safety_lock.guard();
+
+        // This only looks the client node up: it was created for the
+        // resolution log, and its failure (inserted once the bundle finishes)
+        // is what marks it stale.
+        let client_index = self.client_graph.insert_stale(abs_path, false)?;
+        self.client_graph.bundled_files.values_mut()[client_index.get() as usize].is_hmr_root =
+            true;
+
+        // Nothing gets bundled for the server node until the file is fixed, so
+        // it must stay stale (`insert_stale` alone cannot set the bit for an
+        // index past the bitset's current length).
+        let server_index = self.server_graph.insert_stale(abs_path, false)?;
+        self.server_graph.ensure_stale_bit_capacity(true)?;
+        self.server_graph
+            .stale_files
+            .set(server_index.get() as usize);
+        self.server_graph.bundled_files.values_mut()[server_index.get() as usize]
+            .is_client_component_boundary = true;
+        Ok(())
+    }
+
     /// Return a log to write resolution failures into.
     pub(crate) fn get_log_for_resolution_failures(
         &mut self,

src/runtime/bake/dev_server/mod.rs

@@ -1171,6 +1171,11 @@ bun_bundler::link_impl_DevServerHandle! {
                 .handle_parse_task_failure(&err.into(), graph, abs_path, &*log, &mut *bv2)
                 .map_err(Into::into)
         },
+        handle_client_component_boundary_failure(abs_path) => {
+            (*this)
+                .handle_client_component_boundary_failure(abs_path)
+                .map_err(Into::into)
+        },
         put_or_overwrite_asset(path, contents, content_hash) => {
             // `path` was erased from `&bun_resolver::fs::Path<'_>` at the
             // `DevServerHandle::put_or_overwrite_asset_erased` call site. Re-wrap

test/bake/dev/bundle.test.ts

@@ -865,3 +865,160 @@ devTest("barrel optimization: namespace re-export cycle through a star-exported
     await c.expectMessage("result: object Y KEEP DEEP OTHER");
   },
 });
+
+const separateSSRGraphFramework = {
+  ...minimalFramework,
+  serverComponents: {
+    ...minimalFramework.serverComponents!,
+    separateSSRGraph: true,
+  },
+};
+
+/** The response for a framework route whose bundle has errors. */
+async function expectBuildFailed(response: Promise<Response>, error: string) {
+  const res = await response;
+  const html = await res.text();
+  expect(html.match(/<title>(.*)<\/title>/)?.[1]).toBe("Bun - Build Failed");
+  // The page embeds the serialized failures as base64; the messages are
+  // stored as plain text inside of it.
+  const serializedFailures = atob(html.match(/atob\("([^"]*)"\)/)![1]);
+  expect(serializedFailures).toContain(error);
+  expect(res.status).toBe(500);
+}
+
+// A "use client" file with a separate SSR graph is bundled for the browser
+// even when a server file imports it, so its errors are owned by the client
+// graph. The route importing it still has to be associated with them: both
+// right away and after unrelated hot updates, and regardless of whether the
+// route is re-bundled on request (BUN_ASSUME_PERFECT_INCREMENTAL=0) or the
+// graph is trusted (=1). Before the fix, the first hot update made the route
+// run against a server module that was never emitted ("Failed to load bundled
+// module 'components/Sibling.ts'").
+for (const mode of ["0", "1"]) {
+  devTest(`route importing a failing "use client" file (BUN_ASSUME_PERFECT_INCREMENTAL=${mode})`, {
+    framework: separateSSRGraphFramework,
+    env: { BUN_ASSUME_PERFECT_INCREMENTAL: mode },
+    files: {
+      "routes/index.ts": `
+        import { good } from '../good';
+        import '../components/Sibling';
+        export default function (req, meta) {
+          return new Response('page: ' + good);
+        }
+      `,
+      "good.ts": `export const good = "v1";`,
+      "components/Sibling.ts": `
+        "use client";
+        import './sibling-missing';
+        export const sibling = 1;
+      `,
+    },
+    async test(dev) {
+      const error = `Could not resolve: "./sibling-missing"`;
+      await expectBuildFailed(dev.fetch("/"), error);
+      await expectBuildFailed(dev.fetch("/"), error);
+
+      await dev.write("good.ts", `export const good = "v2";`, { errors: null });
+      await expectBuildFailed(dev.fetch("/"), error);
+
+      // Creating the missing file re-bundles Sibling.ts through the
+      // directory watcher, this time as a working client component.
+      await dev.write("components/sibling-missing.ts", `export {};`, { errors: null });
+      await dev.fetch("/").equals("page: v2");
+
+      // The same thing for a component that has already been bundled once.
+      const otherError = `Could not resolve: "./other-missing"`;
+      await dev.write(
+        "components/Sibling.ts",
+        `
+          "use client";
+          import './other-missing';
+          export const sibling = 2;
+        `,
+        { errors: null },
+      );
+      await expectBuildFailed(dev.fetch("/"), otherError);
+      await dev.write("good.ts", `export const good = "v3";`, { errors: null });
+      await expectBuildFailed(dev.fetch("/"), otherError);
+      await dev.write("components/other-missing.ts", `export {};`, { errors: null });
+      await dev.fetch("/").equals("page: v3");
+    },
+  });
+}
+// Here the failing file is only reachable through another client component.
+// Both boundaries end up in `client_components_affected`, and tracing them in
+// `finalize_bundle` appends to that list while it is being walked; walking it
+// through a slice read the list's old buffer after it grew (fails under ASAN).
+devTest('"use client" file that fails to bundle, imported from another "use client" file', {
+  framework: separateSSRGraphFramework,
+  files: {
+    "routes/index.ts": `
+      import '../components/Comp';
+      export default function (req, meta) {
+        return new Response('page');
+      }
+    `,
+    "components/Comp.ts": `
+      "use client";
+      import './Sibling';
+      export const comp = 1;
+    `,
+    "components/Sibling.ts": `
+      "use client";
+      import './sibling-missing';
+      export const sibling = 1;
+    `,
+  },
+  async test(dev) {
+    const error = `Could not resolve: "./sibling-missing"`;
+    await expectBuildFailed(dev.fetch("/"), error);
+    await dev.patch("routes/index.ts", { find: "'page'", replace: "'page2'", errors: null });
+    await expectBuildFailed(dev.fetch("/"), error);
+    await dev.write("components/sibling-missing.ts", `export {};`, { errors: null });
+    await dev.fetch("/").equals("page2");
+  },
+});
+// `checkRouteFailures` collects the errors reachable from a route into the
+// list that also holds the previous bundle's new errors. Without clearing it
+// first, a route that was marked as possibly failing by an earlier bundle
+// reports whatever the most recent bundle failed on, even when it does not
+// import any of it. (With BUN_ASSUME_PERFECT_INCREMENTAL=0 the stale entries
+// only cause a needless rebuild of the route.)
+devTest("route marked by an earlier failure does not report another route's errors", {
+  framework: minimalFramework,
+  env: { BUN_ASSUME_PERFECT_INCREMENTAL: "1" },
+  files: {
+    "routes/a.ts": `
+      import { shared } from '../shared';
+      import { a } from '../a';
+      export default function (req, meta) {
+        return new Response('a: ' + shared + a);
+      }
+    `,
+    "routes/b.ts": `
+      import { shared } from '../shared';
+      export default function (req, meta) {
+        return new Response('b: ' + shared);
+      }
+    `,
+    "shared.ts": `export const shared = "s";`,
+    "a.ts": `export const a = "a";`,
+  },
+  async test(dev) {
+    await dev.fetch("/a").equals("a: sa");
+    await dev.fetch("/b").equals("b: s");
+
+    // Both routes import shared.ts, so both get marked as possibly failing.
+    await dev.write("shared.ts", `import './missing'; export const shared = "s";`, { errors: null });
+    await expectBuildFailed(dev.fetch("/a"), `shared.ts`);
+    await expectBuildFailed(dev.fetch("/b"), `shared.ts`);
+
+    // Fixing it does not revisit the routes; they stay marked until requested.
+    await dev.write("shared.ts", `export const shared = "s";`, { errors: null });
+    // Only /a imports a.ts.
+    await dev.write("a.ts", `import './missing'; export const a = "a";`, { errors: null });
+
+    await dev.fetch("/b").equals("b: s");
+    await expectBuildFailed(dev.fetch("/a"), `a.ts`);
+  },
+});