fix: also match top-level component_id and gate fallback on peer source

- filterAppsByComponent now also matches `app.component_id` directly
  (not only `x-medkit.component_id` and `_links.is-located-on`) so the
  helper remains robust if future transforms lift component_id to the
  top level.
- Add isPeerSourcedComponent helper and gate the /apps fallback on it,
  so legitimate empty manifest/plugin components do not trigger a full
  app-list fetch on every expand. Components with unknown source
  metadata still trigger the fallback to err on the side of completeness.

Author: bburda

src/lib/store-helpers.test.ts

@@ -20,6 +20,7 @@ import {
     inferEntityTypeFromDepth,
     parseTreePath,
     filterAppsByComponent,
+    isPeerSourcedComponent,
 } from './store';
 import type { SovdEntity, EntityTreeNode } from './types';
 
@@ -425,10 +426,16 @@ describe('filterAppsByComponent', () => {
         { id: 'local-app', 'x-medkit': { component_id: 'ecu-primary' } },
         { id: 'data_viewer', 'x-medkit': { component_id: 'ecu-rtmaps' } },
         { id: 'lidar_sim', _links: { 'is-located-on': '/api/v1/components/ecu-rtmaps' } },
+        { id: 'top-level-app', component_id: 'ecu-tesla' },
         { id: 'orphan-app', 'x-medkit': {} },
         { id: 'bare-app' },
     ];
 
+    it('matches apps by top-level component_id', () => {
+        const result = filterAppsByComponent(apps, 'ecu-tesla');
+        expect(result.map((a) => a.id)).toEqual(['top-level-app']);
+    });
+
     it('matches apps by x-medkit.component_id', () => {
         const result = filterAppsByComponent(apps, 'ecu-primary');
         expect(result.map((a) => a.id)).toEqual(['local-app']);
@@ -457,3 +464,26 @@ describe('filterAppsByComponent', () => {
         expect(result).toEqual([]);
     });
 });
+
+// =============================================================================
+// isPeerSourcedComponent
+// =============================================================================
+
+describe('isPeerSourcedComponent', () => {
+    it('returns true for peer-sourced components', () => {
+        expect(isPeerSourcedComponent({ 'x-medkit': { source: 'peer:ecu-rtmaps' } })).toBe(true);
+    });
+
+    it('returns false for manifest-sourced components', () => {
+        expect(isPeerSourcedComponent({ 'x-medkit': { source: 'manifest' } })).toBe(false);
+    });
+
+    it('returns false for plugin-sourced components', () => {
+        expect(isPeerSourcedComponent({ 'x-medkit': { source: 'plugin' } })).toBe(false);
+    });
+
+    it('returns true when source metadata is missing (err on the side of completeness)', () => {
+        expect(isPeerSourcedComponent({})).toBe(true);
+        expect(isPeerSourcedComponent({ 'x-medkit': {} })).toBe(true);
+    });
+});

src/lib/store.ts

@@ -615,20 +615,38 @@ export function parseTreePath(path: string): {
 
 /**
  * Filter apps that belong to a given component by checking
- * `x-medkit.component_id` or `_links.is-located-on`.
+ * the top-level `component_id` field, `x-medkit.component_id`,
+ * or `_links.is-located-on`.
  *
  * Used as a fallback when `/components/{id}/hosts` returns empty
  * (peer-sourced components).
  */
 export function filterAppsByComponent(apps: Record<string, unknown>[], componentId: string): Record<string, unknown>[] {
     return apps.filter((app) => {
+        if (app['component_id'] === componentId) return true;
         const xMedkit = app['x-medkit'] as Record<string, unknown> | undefined;
         if (xMedkit?.component_id === componentId) return true;
         const links = app['_links'] as Record<string, string> | undefined;
         return links?.['is-located-on']?.endsWith(`/components/${componentId}`);
     });
 }
 
+/**
+ * Detect whether a component node is peer-sourced (aggregated from a
+ * remote gateway). Peer-sourced components have `x-medkit.source`
+ * starting with `"peer:"`.
+ *
+ * Components with unknown source metadata are treated as peer-sourced
+ * so the fallback still discovers their apps; this errs on the side of
+ * completeness over saving one extra request.
+ */
+export function isPeerSourcedComponent(node: Record<string, unknown>): boolean {
+    const xMedkit = node['x-medkit'] as Record<string, unknown> | undefined;
+    const source = xMedkit?.source;
+    if (typeof source !== 'string') return true;
+    return source.startsWith('peer:');
+}
+
 /** Fallback: fetch entity details from API when not in tree */
 async function fetchEntityFromApi(
     path: string,
@@ -1016,7 +1034,13 @@ export const useAppStore = create<AppState>()(
                             // Fallback for peer-sourced components: /hosts may return
                             // empty while apps still reference this component via
                             // x-medkit.component_id. Fetch all apps and filter.
-                            if (rawApps.length === 0) {
+                            // Gated on isPeerSourcedComponent so we don't pay the
+                            // full /apps fetch for components that legitimately
+                            // have no apps (e.g. manifest or plugin components).
+                            if (
+                                rawApps.length === 0 &&
+                                isPeerSourcedComponent(node as unknown as Record<string, unknown>)
+                            ) {
                                 const allAppsRes = await client.GET('/apps').catch(() => ({ data: undefined }));
                                 const allApps = allAppsRes.data
                                     ? unwrapItems<Record<string, unknown>>(allAppsRes.data)