@camstack/server 0.1.7 → 0.2.0

package/src/__tests__/bulk-update-coordinator.spec.ts

@@ -22,9 +22,11 @@ function makeRig(opts?: { failItems?: ReadonlySet<string> }): TestRig {
   const updateAddon = vi.fn(async (input: { name: string; version: string }) => {
     if (fail.has(input.name)) throw new Error(`mock fail ${input.name}`)
   })
-  const updateFrameworkPackage = vi.fn(async (input: { packageName: string; version: string; deferRestart: boolean }) => {
-    if (fail.has(input.packageName)) throw new Error(`mock fail fw ${input.packageName}`)
-  })
+  const updateFrameworkPackage = vi.fn(
+    async (input: { packageName: string; version: string; deferRestart: boolean }) => {
+      if (fail.has(input.packageName)) throw new Error(`mock fail fw ${input.packageName}`)
+    },
+  )
   const restartServer = vi.fn(async () => {
     // simulates the real restartServer: in a real run the process dies
   })
@@ -40,7 +42,12 @@ function makeRig(opts?: { failItems?: ReadonlySet<string> }): TestRig {
     updateAddon,
     updateFrameworkPackage,
     restartServer,
-    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() } as unknown as BulkUpdateCoordinatorDeps['logger'],
+    logger: {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+    } as unknown as BulkUpdateCoordinatorDeps['logger'],
     clock: () => clock++,
   }
 
@@ -55,8 +62,12 @@ function makeRig(opts?: { failItems?: ReadonlySet<string> }): TestRig {
 }
 
 describe('BulkUpdateCoordinator', () => {
-  beforeEach(() => { vi.useFakeTimers() })
-  afterEach(() => { vi.useRealTimers() })
+  beforeEach(() => {
+    vi.useFakeTimers()
+  })
+  afterEach(() => {
+    vi.useRealTimers()
+  })
 
   it('regular-only happy path: processes 3 addons in order, no restart', async () => {
     const rig = makeRig()
@@ -75,7 +86,7 @@ describe('BulkUpdateCoordinator', () => {
     expect(final.completed).toBe(3)
     expect(final.failed).toBe(0)
     expect(final.phase).toBe('finalizing')
-    expect(final.items.every(i => i.status === 'done')).toBe(true)
+    expect(final.items.every((i) => i.status === 'done')).toBe(true)
     expect(rig.restartServer).not.toHaveBeenCalled()
     expect(rig.updateAddon).toHaveBeenCalledTimes(3)
   })
@@ -98,15 +109,19 @@ describe('BulkUpdateCoordinator', () => {
     expect(final.completed).toBe(4)
     expect(rig.updateAddon).toHaveBeenCalledTimes(2)
     expect(rig.updateFrameworkPackage).toHaveBeenCalledTimes(2)
-    expect(rig.updateFrameworkPackage).toHaveBeenCalledWith(expect.objectContaining({ deferRestart: true }))
+    expect(rig.updateFrameworkPackage).toHaveBeenCalledWith(
+      expect.objectContaining({ deferRestart: true }),
+    )
     expect(rig.restartServer).toHaveBeenCalledOnce()
 
     // Verify ordering via event sequence: regular items reach 'updating' before any system item
-    const updatingNames = rig.events
-      .map(s => s.current)
-      .filter((n): n is string => n !== null)
-    const firstSystemIdx = updatingNames.findIndex(n => n === '@camstack/types' || n === '@camstack/kernel')
-    const lastRegularIdx = updatingNames.findLastIndex(n => n === '@camstack/addon-a' || n === '@camstack/addon-b')
+    const updatingNames = rig.events.map((s) => s.current).filter((n): n is string => n !== null)
+    const firstSystemIdx = updatingNames.findIndex(
+      (n) => n === '@camstack/types' || n === '@camstack/kernel',
+    )
+    const lastRegularIdx = updatingNames.findLastIndex(
+      (n) => n === '@camstack/addon-a' || n === '@camstack/addon-b',
+    )
     expect(firstSystemIdx).toBeGreaterThan(lastRegularIdx)
   })
 
@@ -125,17 +140,19 @@ describe('BulkUpdateCoordinator', () => {
 
     const final = rig.coordinator.get(id)!
     expect(final.failed).toBe(1)
-    expect(final.items.find(i => i.name === '@camstack/addon-b')?.status).toBe('failed')
-    expect(final.items.find(i => i.name === '@camstack/addon-b')?.error).toContain('mock fail')
-    expect(final.items.find(i => i.name === '@camstack/addon-a')?.status).toBe('done')
-    expect(final.items.find(i => i.name === '@camstack/addon-c')?.status).toBe('done')
+    expect(final.items.find((i) => i.name === '@camstack/addon-b')?.status).toBe('failed')
+    expect(final.items.find((i) => i.name === '@camstack/addon-b')?.error).toContain('mock fail')
+    expect(final.items.find((i) => i.name === '@camstack/addon-a')?.status).toBe('done')
+    expect(final.items.find((i) => i.name === '@camstack/addon-c')?.status).toBe('done')
   })
 
   it('cancel pre-restart: loop exits, no restart, queued items remain queued', async () => {
     const rig = makeRig()
     rig.updateAddon.mockImplementation(async () => {
       // Slow enough that cancel fires before item 2
-      await new Promise<void>(resolve => { setTimeout(resolve, 50) })
+      await new Promise<void>((resolve) => {
+        setTimeout(resolve, 50)
+      })
     })
 
     const { id } = rig.coordinator.start({
@@ -157,21 +174,21 @@ describe('BulkUpdateCoordinator', () => {
     expect(final.cancelled).toBe(true)
     expect(rig.restartServer).not.toHaveBeenCalled()
     // At least one item should still be queued (we cancelled before item 2 ran)
-    expect(final.items.filter(i => i.status === 'queued').length).toBeGreaterThanOrEqual(1)
+    expect(final.items.filter((i) => i.status === 'queued').length).toBeGreaterThanOrEqual(1)
   })
 
   it('cancel ignored during restarting phase', async () => {
     const rig = makeRig()
     rig.restartServer.mockImplementation(async () => {
       // Hang briefly so we can attempt cancel during restart
-      await new Promise<void>(resolve => { setTimeout(resolve, 50) })
+      await new Promise<void>((resolve) => {
+        setTimeout(resolve, 50)
+      })
     })
 
     const { id } = rig.coordinator.start({
       nodeId: 'hub',
-      items: [
-        { name: '@camstack/types', version: '0.1.40', isSystem: true },
-      ],
+      items: [{ name: '@camstack/types', version: '0.1.40', isSystem: true }],
     })
 
     // Let it reach restarting
@@ -191,15 +208,13 @@ describe('BulkUpdateCoordinator', () => {
 
     const { id } = rig.coordinator.start({
       nodeId: 'hub',
-      items: [
-        { name: '@camstack/types', version: '0.1.40', isSystem: true },
-      ],
+      items: [{ name: '@camstack/types', version: '0.1.40', isSystem: true }],
     })
 
     await vi.runAllTimersAsync()
 
     const final = rig.coordinator.get(id)!
-    const typesItem = final.items.find(i => i.name === '@camstack/types')!
+    const typesItem = final.items.find((i) => i.name === '@camstack/types')!
     expect(typesItem.status).toBe('done')
     expect(typesItem.error).toContain('Restart failed')
   })
@@ -211,10 +226,12 @@ describe('BulkUpdateCoordinator', () => {
       items: [{ name: '@camstack/addon-a', version: '1.0.1', isSystem: false }],
     })
 
-    expect(() => rig.coordinator.start({
-      nodeId: 'hub',
-      items: [{ name: '@camstack/addon-b', version: '2.0.1', isSystem: false }],
-    })).toThrow(/already in progress/i)
+    expect(() =>
+      rig.coordinator.start({
+        nodeId: 'hub',
+        items: [{ name: '@camstack/addon-b', version: '2.0.1', isSystem: false }],
+      }),
+    ).toThrow(/already in progress/i)
   })
 
   it('auto-cleanup: state purged 5 min after completedAt', async () => {

package/src/__tests__/cap-ownership-authority.spec.ts

@@ -21,7 +21,11 @@
  */
 
 import { describe, it, expect, vi } from 'vitest'
-import type { NodeCapAuthority, HubLocalChildDispatcher, CapRouteResolverDeps } from '@camstack/kernel'
+import type {
+  NodeCapAuthority,
+  HubLocalChildDispatcher,
+  CapRouteResolverDeps,
+} from '@camstack/kernel'
 import { CapRouteResolver, CapRouteError } from '@camstack/kernel'
 
 // ---------------------------------------------------------------------------
@@ -40,8 +44,15 @@ import { CapRouteResolver, CapRouteError } from '@camstack/kernel'
 function buildConsolidatedNativeFallback(opts: {
   readonly resolver: CapRouteResolver | null
   readonly hubNodeId: string
-  readonly resolveNativeCapOwnerSync: (capName: string, deviceId: number) => { addonId: string; nodeId: string } | null
-  readonly buildNativeCapProxy: (addonId: string, capName: string, deviceId: number) => Record<string, unknown>
+  readonly resolveNativeCapOwnerSync: (
+    capName: string,
+    deviceId: number,
+  ) => { addonId: string; nodeId: string } | null
+  readonly buildNativeCapProxy: (
+    addonId: string,
+    capName: string,
+    deviceId: number,
+  ) => Record<string, unknown>
 }): (capName: string, deviceId: number) => unknown | null {
   const { resolver, hubNodeId, resolveNativeCapOwnerSync, buildNativeCapProxy } = opts
 
@@ -152,7 +163,9 @@ function makeNodeAuthority(
     getAgentChildId: (): string | null => null,
     isNativeCap: (nodeId: string, capName: string, deviceId?: number): boolean => {
       if (deviceId !== undefined) {
-        return nativeCaps.some((n) => n.nodeId === nodeId && n.capName === capName && n.deviceId === deviceId)
+        return nativeCaps.some(
+          (n) => n.nodeId === nodeId && n.capName === capName && n.deviceId === deviceId,
+        )
       }
       return nativeCaps.some((n) => n.nodeId === nodeId && n.capName === capName)
     },
@@ -171,9 +184,18 @@ describe('G2 — (a) hub-local device-scoped native cap: resolver is consulted f
       new Map([['ptz', new Map([[7, 'provider-reolink']])]]),
     )
     const nativeCaps: NativeCapSpec[] = [
-      { nodeId: 'hub/provider-reolink', addonId: 'addon-provider-reolink', capName: 'ptz', deviceId: 7 },
+      {
+        nodeId: 'hub/provider-reolink',
+        addonId: 'addon-provider-reolink',
+        capName: 'ptz',
+        deviceId: 7,
+      },
     ]
-    const nodeAuthority = makeNodeAuthority(new Map(), new Set(['hub/provider-reolink']), nativeCaps)
+    const nodeAuthority = makeNodeAuthority(
+      new Map(),
+      new Set(['hub/provider-reolink']),
+      nativeCaps,
+    )
 
     const deps: CapRouteResolverDeps = {
       hubNodeId: HUB_NODE_ID,
@@ -211,9 +233,18 @@ describe('G2 — (a) hub-local device-scoped native cap: resolver is consulted f
       new Map([['ptz', new Map([[7, 'provider-reolink']])]]),
     )
     const nativeCaps: NativeCapSpec[] = [
-      { nodeId: 'hub/provider-reolink', addonId: 'addon-provider-reolink', capName: 'ptz', deviceId: 7 },
+      {
+        nodeId: 'hub/provider-reolink',
+        addonId: 'addon-provider-reolink',
+        capName: 'ptz',
+        deviceId: 7,
+      },
     ]
-    const nodeAuthority = makeNodeAuthority(new Map(), new Set(['hub/provider-reolink']), nativeCaps)
+    const nodeAuthority = makeNodeAuthority(
+      new Map(),
+      new Set(['hub/provider-reolink']),
+      nativeCaps,
+    )
 
     const deps: CapRouteResolverDeps = {
       hubNodeId: HUB_NODE_ID,

package/src/__tests__/cap-providers/cap-providers-location-import.spec.ts

@@ -0,0 +1,206 @@
+/**
+ * cap-providers-location-import.spec.ts
+ *
+ * Verifies that `buildIntegrationsProvider().getAvailableTypes()` correctly
+ * surfaces the `supportsLocationImport` flag:
+ *   - A `device-adoption` addon whose manifest declares `supportsLocationImport: true`
+ *     → returned entry has `supportsLocationImport === true`.
+ *   - A `device-adoption` addon WITHOUT the flag
+ *     → returned entry has `supportsLocationImport === false`.
+ *   - A `device-provider` addon (non-adoption kind), regardless of the flag
+ *     → returned entry has `supportsLocationImport === false`.
+ *
+ * Harness mirrors integrations-delete-cascade.spec.ts in the same directory.
+ */
+import { describe, it, expect, vi } from 'vitest'
+import { buildIntegrationsProvider } from '../../api/core/cap-providers.js'
+
+// ── Minimal stubs ────────────────────────────────────────────────────────────
+
+function makeIntegrationRegistry() {
+  return {
+    listIntegrations: vi.fn(async () => []),
+    getIntegration: vi.fn(async (_id: string) => null),
+    deleteIntegration: vi.fn(async (_id: string) => undefined),
+    createIntegration: vi.fn(),
+    updateIntegration: vi.fn(),
+    getIntegrationByAddonId: vi.fn(),
+    getIntegrationSettings: vi.fn(),
+    setIntegrationSettings: vi.fn(),
+  }
+}
+
+type FakeAddonRow = {
+  manifest: {
+    id: string
+    name: string
+    description: string
+    capabilities: Array<{ name: string }>
+    supportsLocationImport?: boolean
+    brokerKind?: string
+    instanceMode?: string
+    icon?: string
+    color?: string
+  }
+  declaration?: {
+    supportsLocationImport?: boolean
+    brokerKind?: string
+    instanceMode?: string
+    icon?: string
+    color?: string
+  }
+  process?: { state: string }
+}
+
+function makeAddonRegistry(addons: FakeAddonRow[] = []) {
+  const integrationReg = makeIntegrationRegistry()
+  return {
+    getIntegrationRegistry: vi.fn(() => integrationReg),
+    listAddons: vi.fn(() => addons),
+    restartAddon: vi.fn(),
+    getCapabilityRegistry: vi.fn(() => ({
+      getProviderByAddon: vi.fn(() => null),
+    })),
+  }
+}
+
+function makeEventBus() {
+  return { emit: vi.fn() }
+}
+
+function makeLogger() {
+  return {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  }
+}
+
+function makeLoggingService() {
+  const log = makeLogger()
+  return { createLogger: vi.fn(() => log) }
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('getAvailableTypes — supportsLocationImport flag', () => {
+  it('returns supportsLocationImport=true for a device-adoption addon that declares it in the manifest', async () => {
+    const addon: FakeAddonRow = {
+      manifest: {
+        id: 'provider-homeassistant',
+        name: 'Home Assistant Provider',
+        description: 'Adopt HA devices',
+        capabilities: [{ name: 'device-adoption' }],
+        supportsLocationImport: true,
+        brokerKind: 'home-assistant',
+        instanceMode: 'multiple',
+      },
+    }
+    const ar = makeAddonRegistry([addon])
+    const provider = buildIntegrationsProvider(
+      ar as never,
+      makeEventBus() as never,
+      makeLoggingService() as never,
+      null,
+    )
+    const types = await provider.getAvailableTypes()
+
+    expect(types).toHaveLength(1)
+    expect(types[0]).toMatchObject({
+      addonId: 'provider-homeassistant',
+      kind: 'device-adoption',
+      supportsLocationImport: true,
+    })
+  })
+
+  it('returns supportsLocationImport=false for a device-adoption addon that omits the flag', async () => {
+    const addon: FakeAddonRow = {
+      manifest: {
+        id: 'provider-test-adoption',
+        name: 'Test Adoption Provider',
+        description: 'Adoption without location import',
+        capabilities: [{ name: 'device-adoption' }],
+        brokerKind: 'test-broker',
+        instanceMode: 'multiple',
+      },
+    }
+    const ar = makeAddonRegistry([addon])
+    const provider = buildIntegrationsProvider(
+      ar as never,
+      makeEventBus() as never,
+      makeLoggingService() as never,
+      null,
+    )
+    const types = await provider.getAvailableTypes()
+
+    expect(types).toHaveLength(1)
+    expect(types[0]).toMatchObject({
+      addonId: 'provider-test-adoption',
+      kind: 'device-adoption',
+      supportsLocationImport: false,
+    })
+  })
+
+  it('returns supportsLocationImport=false for a device-provider addon even when the flag is set on manifest', async () => {
+    const addon: FakeAddonRow = {
+      manifest: {
+        id: 'provider-reolink',
+        name: 'Reolink Provider',
+        description: 'Classic device provider',
+        capabilities: [{ name: 'device-provider' }],
+        // Hypothetical: even if someone mistakenly sets this on a device-provider
+        supportsLocationImport: true,
+        instanceMode: 'single',
+      },
+    }
+    const ar = makeAddonRegistry([addon])
+    const provider = buildIntegrationsProvider(
+      ar as never,
+      makeEventBus() as never,
+      makeLoggingService() as never,
+      null,
+    )
+    const types = await provider.getAvailableTypes()
+
+    expect(types).toHaveLength(1)
+    expect(types[0]).toMatchObject({
+      addonId: 'provider-reolink',
+      kind: 'device-provider',
+      supportsLocationImport: false,
+    })
+  })
+
+  it('prefers declaration.supportsLocationImport over manifest when declaration is present', async () => {
+    const addon: FakeAddonRow = {
+      manifest: {
+        id: 'provider-homeassistant',
+        name: 'Home Assistant Provider',
+        description: 'Adopt HA devices',
+        capabilities: [{ name: 'device-adoption' }],
+        supportsLocationImport: false,
+        brokerKind: 'home-assistant',
+        instanceMode: 'multiple',
+      },
+      declaration: {
+        supportsLocationImport: true,
+        brokerKind: 'home-assistant',
+        instanceMode: 'multiple',
+      },
+    }
+    const ar = makeAddonRegistry([addon])
+    const provider = buildIntegrationsProvider(
+      ar as never,
+      makeEventBus() as never,
+      makeLoggingService() as never,
+      null,
+    )
+    const types = await provider.getAvailableTypes()
+
+    expect(types).toHaveLength(1)
+    expect(types[0]).toMatchObject({
+      addonId: 'provider-homeassistant',
+      kind: 'device-adoption',
+      supportsLocationImport: true,
+    })
+  })
+})

package/src/__tests__/cap-providers/cap-usage-graph.spec.ts

@@ -3,13 +3,27 @@ import { __resetCapUsageRegistryForTests, getCapUsageRegistry } from '@camstack/
 import { buildNodesProvider } from '../../api/core/cap-providers'
 
 describe('nodes.getCapUsageGraph provider', () => {
-  beforeEach(() => { __resetCapUsageRegistryForTests() })
+  beforeEach(() => {
+    __resetCapUsageRegistryForTests()
+  })
 
   it('returns recorded edges projected through the cap-usage registry', async () => {
     const reg = getCapUsageRegistry()
     const t0 = Date.now() - 5_000
-    reg.recordCall({ callerAddonId: 'A', providerAddonId: 'B', capName: 'foo', methodName: 'm', atMs: t0 })
-    reg.recordCall({ callerAddonId: 'A', providerAddonId: 'B', capName: 'foo', methodName: 'm', atMs: t0 + 1000 })
+    reg.recordCall({
+      callerAddonId: 'A',
+      providerAddonId: 'B',
+      capName: 'foo',
+      methodName: 'm',
+      atMs: t0,
+    })
+    reg.recordCall({
+      callerAddonId: 'A',
+      providerAddonId: 'B',
+      capName: 'foo',
+      methodName: 'm',
+      atMs: t0 + 1000,
+    })
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const provider = buildNodesProvider({} as any, { broker: { call: vi.fn() } } as any)

package/src/__tests__/cap-providers/compute-topology-categories.spec.ts

@@ -6,7 +6,17 @@ function makeAgentRegistry(): { listNodes: () => Promise<unknown[]> } {
   return {
     listNodes: async () => [
       {
-        info: { id: 'hub', name: 'hub', hostname: 'hub', platform: 'darwin', arch: 'arm64', cpuModel: 'M2', cpuCores: 8, memoryMB: 16384, pythonRuntimes: [] },
+        info: {
+          id: 'hub',
+          name: 'hub',
+          hostname: 'hub',
+          platform: 'darwin',
+          arch: 'arm64',
+          cpuModel: 'M2',
+          cpuCores: 8,
+          memoryMB: 16384,
+          pythonRuntimes: [],
+        },
         status: { cpuPercent: 12, memoryPercent: 30 },
         isHub: true,
         isOnline: true,
@@ -22,10 +32,34 @@ function makeAgentRegistry(): { listNodes: () => Promise<unknown[]> } {
 function makeAddonRegistry(): { listAddons: () => readonly unknown[] } {
   return {
     listAddons: () => [
-      { manifest: { id: 'provider-hikvision' }, declaration: { id: 'provider-hikvision', category: 'providers', capabilities: [{ name: 'stream-params' }] } },
-      { manifest: { id: 'provider-onvif' },     declaration: { id: 'provider-onvif',     category: 'providers', capabilities: [{ name: 'device-provider' }] } },
-      { manifest: { id: 'stream-broker' },      declaration: { id: 'stream-broker',      category: 'pipeline',  capabilities: [{ name: 'stream-broker' }] } },
-      { manifest: { id: 'sqlite-settings' },    declaration: { id: 'sqlite-settings',                          capabilities: [{ name: 'settings-store' }] } },
+      {
+        manifest: { id: 'provider-hikvision' },
+        declaration: {
+          id: 'provider-hikvision',
+          category: 'providers',
+          capabilities: [{ name: 'stream-params' }],
+        },
+      },
+      {
+        manifest: { id: 'provider-onvif' },
+        declaration: {
+          id: 'provider-onvif',
+          category: 'providers',
+          capabilities: [{ name: 'device-provider' }],
+        },
+      },
+      {
+        manifest: { id: 'stream-broker' },
+        declaration: {
+          id: 'stream-broker',
+          category: 'pipeline',
+          capabilities: [{ name: 'stream-broker' }],
+        },
+      },
+      {
+        manifest: { id: 'sqlite-settings' },
+        declaration: { id: 'sqlite-settings', capabilities: [{ name: 'settings-store' }] },
+      },
     ],
   }
 }
@@ -36,12 +70,17 @@ describe('computeTopology categories[] aggregation', () => {
     const nodes = await computeTopology(makeAgentRegistry() as any, makeAddonRegistry() as any)
     expect(nodes).toHaveLength(1)
     const cats = nodes[0]!.categories
-    const byId = new Map(cats.map(c => [c.category, c]))
+    const byId = new Map(cats.map((c) => [c.category, c]))
     expect(byId.get('providers')?.total).toBe(2)
     expect(byId.get('providers')?.healthy).toBe(2)
-    expect(byId.get('providers')?.addons.map(a => a.id).sort()).toEqual(['provider-hikvision', 'provider-onvif'])
+    expect(
+      byId
+        .get('providers')
+        ?.addons.map((a) => a.id)
+        .toSorted(),
+    ).toEqual(['provider-hikvision', 'provider-onvif'])
     expect(byId.get('pipeline')?.total).toBe(1)
-    expect(byId.get('system')?.addons.map(a => a.id)).toEqual(['sqlite-settings'])
+    expect(byId.get('system')?.addons.map((a) => a.id)).toEqual(['sqlite-settings'])
   })
 
   it('counts a non-running addon as not-healthy', async () => {
@@ -49,13 +88,20 @@ describe('computeTopology categories[] aggregation', () => {
     // Force the addon registry to return one stopped + one running provider.
     const addonReg = {
       listAddons: () => [
-        { manifest: { id: 'provider-rtsp' },      declaration: { id: 'provider-rtsp',      category: 'providers', capabilities: [] } },
-        { manifest: { id: 'provider-hikvision' }, declaration: { id: 'provider-hikvision', category: 'providers', capabilities: [] }, status: 'failed' },
+        {
+          manifest: { id: 'provider-rtsp' },
+          declaration: { id: 'provider-rtsp', category: 'providers', capabilities: [] },
+        },
+        {
+          manifest: { id: 'provider-hikvision' },
+          declaration: { id: 'provider-hikvision', category: 'providers', capabilities: [] },
+          status: 'failed',
+        },
       ],
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const nodes = await computeTopology(agentReg as any, addonReg as any)
-    const providers = nodes[0]!.categories.find(c => c.category === 'providers')!
+    const providers = nodes[0]!.categories.find((c) => c.category === 'providers')!
     expect(providers.total).toBe(2)
     // The current TopologyNode `addons[].status` is always `'running'` per existing code;
     // failed addons would surface through subProcesses[].state. Document the current contract: