Make filter-before-parse observable; keep parser diagnostic; harden resolutions fallback

- Inject parse as a jest.fn so a test asserts the node_modules/virtual/out-of-root
  modules never reach the parser. Deleting the guard now fails a test instead of
  silently costing a parse per module.
- Include the parser's own message in the fail-closed error; an actionable error
  that hides the syntax error is only half useful.
- Branch importedIdResolutions on .length rather than nullishness. Rolldown omits
  the property entirely so ?? works today, but a bundler reporting it as [] with a
  populated importedIds would silently yield zero static dependencies.

Author: sdkennedy2

packages/plugins/apps/src/vite/backend-module-graph-collector.test.ts

@@ -20,22 +20,27 @@ const getModuleParsedHook = (collector: ReturnType<typeof createBackendModuleGra
         throw new Error('Expected "moduleParsed" to be a function hook.');
     }
 
-    return (moduleInfo: object) => Reflect.apply(hook, { parse: parseAst }, [moduleInfo]);
+    const parse = jest.fn(parseAst);
+    const callHook = (moduleInfo: object) => Reflect.apply(hook, { parse }, [moduleInfo]);
+
+    return { callHook, parse };
 };
 
 const getEmit = (collector: ReturnType<typeof createBackendModuleGraphCollector>) => {
-    const callHook = getModuleParsedHook(collector);
+    const { callHook, parse } = getModuleParsedHook(collector);
 
-    return (moduleInfo: FakeModuleInfo, importedIds: string[] = []) => {
+    const emit = (moduleInfo: FakeModuleInfo, importedIds: string[] = []) => {
         const importedIdResolutions = importedIds.map((id) => ({ id }));
         callHook({ ...moduleInfo, importedIds, importedIdResolutions });
     };
+
+    return { emit, parse };
 };
 
 describe('Backend Functions - backend module graph collector', () => {
     test('Should collect parsed local module records from moduleParsed hooks', () => {
         const collector = createBackendModuleGraphCollector('/project');
-        const emit = getEmit(collector);
+        const { emit, parse } = getEmit(collector);
 
         emit(
             {
@@ -67,11 +72,15 @@ describe('Backend Functions - backend module graph collector', () => {
                 },
             ],
         });
+        // Filtering happens before the parse, so the skipped modules above never
+        // reach the parser. Without that ordering every `node_modules` module in
+        // the backend graph would be parsed just to be discarded.
+        expect(parse).toHaveBeenCalledTimes(1);
     });
 
     test('Should collect records under a bundler that does not support ModuleInfo#ast', () => {
         const collector = createBackendModuleGraphCollector('/project');
-        const callHook = getModuleParsedHook(collector);
+        const { callHook } = getModuleParsedHook(collector);
 
         // Rolldown, Vite 8's default bundler, keeps `ast` on its Rollup-compat
         // object but stubs the getter to throw. Reading the property at all is

packages/plugins/apps/src/vite/backend-module-graph-collector.ts

@@ -58,8 +58,12 @@ export function createBackendModuleGraphCollector(buildRoot: string): BackendMod
                 let parsed;
                 try {
                     parsed = this.parse(moduleInfo.code);
-                } catch {
-                    throw unsupportedModuleGraphDependency(moduleId, 'unparseable module source');
+                } catch (error) {
+                    const reason = error instanceof Error ? error.message : String(error);
+                    throw unsupportedModuleGraphDependency(
+                        moduleId,
+                        `unparseable module source (${reason})`,
+                    );
                 }
 
                 const record = createParsedModuleRecord(
@@ -88,7 +92,11 @@ function normalizeViteModuleId(id: string): string {
 }
 
 function getStaticDependencyIds(moduleInfo: ModuleInfo): string[] {
-    return moduleInfo.importedIdResolutions?.map(({ id }) => id) ?? [...moduleInfo.importedIds];
+    const resolutions = moduleInfo.importedIdResolutions;
+    if (resolutions?.length) {
+        return resolutions.map(({ id }) => id);
+    }
+    return [...moduleInfo.importedIds];
 }
 
 function isViteVirtualModuleId(id: string): boolean {