@camstack/server 0.1.7 → 0.2.0

package/src/__tests__/cap-providers/integrations-delete-cascade.spec.ts

@@ -0,0 +1,292 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { buildIntegrationsProvider } from '../../api/core/cap-providers'
+import type { CapabilityRegistry } from '@camstack/kernel'
+import type { Integration } from '@camstack/types'
+
+// ── Minimal stubs ────────────────────────────────────────────────────────────
+
+const INTEGRATION_ID = 'integ-abc-123'
+const ADDON_ID = 'provider-test'
+
+function makeIntegration(id = INTEGRATION_ID): Integration {
+  return {
+    id,
+    addonId: ADDON_ID,
+    name: 'Test Integration',
+    enabled: true,
+    info: null,
+    settings: null,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  } as unknown as Integration
+}
+
+function makeIntegrationRegistry(integration: Integration | null = makeIntegration()) {
+  return {
+    getIntegration: vi.fn(async (_id: string) => integration),
+    deleteIntegration: vi.fn(async (_id: string) => undefined),
+    listIntegrations: vi.fn(async () => (integration ? [integration] : [])),
+    createIntegration: vi.fn(),
+    updateIntegration: vi.fn(),
+    getIntegrationByAddonId: vi.fn(),
+    getIntegrationSettings: vi.fn(),
+    setIntegrationSettings: vi.fn(),
+  }
+}
+
+function makeAddonRegistry(reg = makeIntegrationRegistry()) {
+  return {
+    getIntegrationRegistry: vi.fn(() => reg),
+    listAddons: vi.fn(() => []),
+    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(log = makeLogger()) {
+  return { createLogger: vi.fn(() => log) }
+}
+
+function makeCapabilityRegistry(
+  removeByIntegration:
+    | ((input: { integrationId: string }) => Promise<{ removed: number }>)
+    | null = vi.fn(async () => ({ removed: 2 })),
+): CapabilityRegistry {
+  return {
+    getSingleton: vi.fn((_cap: string) => (removeByIntegration ? { removeByIntegration } : null)),
+  } as unknown as CapabilityRegistry
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('integrations.delete cascade-removes devices via removeByIntegration', () => {
+  let integrationReg: ReturnType<typeof makeIntegrationRegistry>
+  let addonReg: ReturnType<typeof makeAddonRegistry>
+  let eb: ReturnType<typeof makeEventBus>
+  let log: ReturnType<typeof makeLogger>
+  let loggingService: ReturnType<typeof makeLoggingService>
+
+  beforeEach(() => {
+    integrationReg = makeIntegrationRegistry()
+    addonReg = makeAddonRegistry(integrationReg)
+    eb = makeEventBus()
+    log = makeLogger()
+    loggingService = makeLoggingService(log)
+  })
+
+  it('calls removeByIntegration with the integration id before deleteIntegration', async () => {
+    const removeByIntegration = vi.fn(async () => ({ removed: 3 }))
+    const capReg = makeCapabilityRegistry(removeByIntegration)
+
+    const provider = buildIntegrationsProvider(
+      addonReg as never,
+      eb as never,
+      loggingService as never,
+      capReg,
+    )
+    await provider.delete({ id: INTEGRATION_ID })
+
+    expect(removeByIntegration).toHaveBeenCalledOnce()
+    expect(removeByIntegration).toHaveBeenCalledWith({ integrationId: INTEGRATION_ID })
+  })
+
+  it('still deletes the integration record and emits integration.deleted after the cascade', async () => {
+    const capReg = makeCapabilityRegistry()
+
+    const provider = buildIntegrationsProvider(
+      addonReg as never,
+      eb as never,
+      loggingService as never,
+      capReg,
+    )
+    const result = await provider.delete({ id: INTEGRATION_ID })
+
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledOnce()
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledWith(INTEGRATION_ID)
+
+    expect(eb.emit).toHaveBeenCalledOnce()
+    expect(eb.emit).toHaveBeenCalledWith(
+      expect.objectContaining({
+        category: 'integration.deleted',
+        data: expect.objectContaining({ integrationId: INTEGRATION_ID }),
+      }),
+    )
+
+    expect(result).toEqual({ success: true, deletedId: INTEGRATION_ID })
+  })
+
+  it('logs the removed count from removeByIntegration', async () => {
+    const removeByIntegration = vi.fn(async () => ({ removed: 5 }))
+    const capReg = makeCapabilityRegistry(removeByIntegration)
+
+    const provider = buildIntegrationsProvider(
+      addonReg as never,
+      eb as never,
+      loggingService as never,
+      capReg,
+    )
+    await provider.delete({ id: INTEGRATION_ID })
+
+    expect(log.info).toHaveBeenCalledWith(
+      'cascade-removed devices',
+      expect.objectContaining({ meta: expect.objectContaining({ removed: 5 }) }),
+    )
+  })
+
+  it('does NOT abort the integration delete when removeByIntegration throws (best-effort)', async () => {
+    const removeByIntegration = vi.fn(async () => {
+      throw new Error('device-manager transient error')
+    })
+    const capReg = makeCapabilityRegistry(removeByIntegration)
+
+    const provider = buildIntegrationsProvider(
+      addonReg as never,
+      eb as never,
+      loggingService as never,
+      capReg,
+    )
+
+    // Should NOT throw
+    await expect(provider.delete({ id: INTEGRATION_ID })).resolves.toEqual({
+      success: true,
+      deletedId: INTEGRATION_ID,
+    })
+
+    // Integration record deletion and event still fire
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledOnce()
+    expect(eb.emit).toHaveBeenCalledOnce()
+
+    // A warning is logged
+    expect(log.warn).toHaveBeenCalledWith(
+      'device cascade-remove failed (best-effort — continuing)',
+      expect.anything(),
+    )
+  })
+
+  it('warns and skips cascade when capabilityRegistry is null', async () => {
+    const provider = buildIntegrationsProvider(
+      addonReg as never,
+      eb as never,
+      loggingService as never,
+      null,
+    )
+    await provider.delete({ id: INTEGRATION_ID })
+
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledOnce()
+    expect(eb.emit).toHaveBeenCalledOnce()
+    expect(log.warn).toHaveBeenCalledWith(
+      'device-manager not available — skipping cascade device removal',
+      expect.anything(),
+    )
+  })
+
+  it('warns and skips cascade when device-manager singleton is not registered', async () => {
+    const capReg = makeCapabilityRegistry(null)
+
+    const provider = buildIntegrationsProvider(
+      addonReg as never,
+      eb as never,
+      loggingService as never,
+      capReg,
+    )
+    await provider.delete({ id: INTEGRATION_ID })
+
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledOnce()
+    expect(log.warn).toHaveBeenCalledWith(
+      'device-manager not available — skipping cascade device removal',
+      expect.anything(),
+    )
+  })
+
+  it('stamps legacy un-tagged devices of the addon BEFORE cascade so they are removed too', async () => {
+    const removeByIntegration = vi.fn(async () => ({ removed: 1 }))
+    const setIntegrationId = vi.fn(
+      async (_input: { deviceId: number; integrationId: string }) => undefined,
+    )
+    // One un-tagged top-level device of the integration's addon (claimable),
+    // one already-tagged (skip), one child (skip), one other-addon (skip).
+    const listAll = vi.fn(async () => [
+      { id: 4, addonId: ADDON_ID, parentDeviceId: null },
+      { id: 5, addonId: ADDON_ID, parentDeviceId: null, integrationId: INTEGRATION_ID },
+      { id: 6, addonId: ADDON_ID, parentDeviceId: 4 },
+      { id: 7, addonId: 'provider-other', parentDeviceId: null },
+    ])
+    const capReg = {
+      getSingleton: vi.fn(() => ({ removeByIntegration, listAll, setIntegrationId })),
+    } as unknown as CapabilityRegistry
+
+    const provider = buildIntegrationsProvider(
+      addonReg as never,
+      eb as never,
+      loggingService as never,
+      capReg,
+    )
+    await provider.delete({ id: INTEGRATION_ID })
+
+    // Only device 4 is claimed (untagged, top-level, this addon's single integration).
+    expect(setIntegrationId).toHaveBeenCalledOnce()
+    expect(setIntegrationId).toHaveBeenCalledWith({ deviceId: 4, integrationId: INTEGRATION_ID })
+    // Cascade still runs after the claim.
+    expect(removeByIntegration).toHaveBeenCalledWith({ integrationId: INTEGRATION_ID })
+  })
+
+  it('claim failure does not abort the integration delete (best-effort)', async () => {
+    const removeByIntegration = vi.fn(async () => ({ removed: 0 }))
+    const setIntegrationId = vi.fn(async () => {
+      throw new Error('stamp boom')
+    })
+    const listAll = vi.fn(async () => [{ id: 4, addonId: ADDON_ID, parentDeviceId: null }])
+    const capReg = {
+      getSingleton: vi.fn(() => ({ removeByIntegration, listAll, setIntegrationId })),
+    } as unknown as CapabilityRegistry
+
+    const provider = buildIntegrationsProvider(
+      addonReg as never,
+      eb as never,
+      loggingService as never,
+      capReg,
+    )
+    await expect(provider.delete({ id: INTEGRATION_ID })).resolves.toEqual({
+      success: true,
+      deletedId: INTEGRATION_ID,
+    })
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledOnce()
+    expect(log.warn).toHaveBeenCalledWith(
+      'legacy device claim failed (best-effort — continuing)',
+      expect.anything(),
+    )
+  })
+
+  it('throws when the integration is not found (guard still fires before cascade)', async () => {
+    integrationReg = makeIntegrationRegistry(null)
+    addonReg = makeAddonRegistry(integrationReg)
+    const capReg = makeCapabilityRegistry()
+
+    const provider = buildIntegrationsProvider(
+      addonReg as never,
+      eb as never,
+      loggingService as never,
+      capReg,
+    )
+
+    await expect(provider.delete({ id: 'missing-id' })).rejects.toThrow('not found')
+
+    // Nothing should have been cleaned up
+    expect(integrationReg.deleteIntegration).not.toHaveBeenCalled()
+    expect(eb.emit).not.toHaveBeenCalled()
+  })
+})

package/src/__tests__/cap-providers-bulk-update.spec.ts

@@ -233,7 +233,18 @@ describe('buildAddonsProvider — BulkUpdateCoordinator delegation', () => {
 
   it('listActiveBulkUpdates delegates to coordinator.list with nodeId and returns its value', async () => {
     const mockList = [
-      { id: 'bulk-1', nodeId: 'hub', startedAtMs: 1000, total: 1, completed: 0, failed: 0, current: 'pkg-a', phase: 'regular' as const, cancelled: false, items: [] },
+      {
+        id: 'bulk-1',
+        nodeId: 'hub',
+        startedAtMs: 1000,
+        total: 1,
+        completed: 0,
+        failed: 0,
+        current: 'pkg-a',
+        phase: 'regular' as const,
+        cancelled: false,
+        items: [],
+      },
     ]
     stubs.list.mockReturnValue(mockList)
 
@@ -318,15 +329,15 @@ describe('buildAddonsProvider — listUpdates isSystem field', () => {
     const result = await env.provider.listUpdates({ nodeId: 'hub' })
 
     expect(result).toHaveLength(2)
-    const typesRow = result.find(r => r.name === '@camstack/types')
-    const fooRow = result.find(r => r.name === '@camstack/addon-foo')
+    const typesRow = result.find((r) => r.name === '@camstack/types')
+    const fooRow = result.find((r) => r.name === '@camstack/addon-foo')
     expect(typesRow?.isSystem).toBe(true)
     expect(fooRow?.isSystem).toBe(false)
   })
 
   it('all FRAMEWORK_PACKAGE_ALLOWLIST members get isSystem: true', async () => {
     env.psMock['checkUpdates']!.mockResolvedValue(
-      FRAMEWORK_PACKAGE_ALLOWLIST.map(name => ({
+      FRAMEWORK_PACKAGE_ALLOWLIST.map((name) => ({
         name,
         currentVersion: '0.1.0',
         latestVersion: '0.1.1',
@@ -360,7 +371,10 @@ describe('buildAddonsProvider — updateFrameworkPackage deferRestart propagatio
     })
 
     expect(env.psMock['updateFrameworkPackage']).toHaveBeenCalledOnce()
-    const callArg = env.psMock['updateFrameworkPackage']!.mock.calls[0]![0] as Record<string, unknown>
+    const callArg = env.psMock['updateFrameworkPackage']!.mock.calls[0]![0] as Record<
+      string,
+      unknown
+    >
     expect(callArg['deferRestart']).toBe(true)
   })
 
@@ -371,7 +385,10 @@ describe('buildAddonsProvider — updateFrameworkPackage deferRestart propagatio
       deferRestart: false,
     })
 
-    const callArg = env.psMock['updateFrameworkPackage']!.mock.calls[0]![0] as Record<string, unknown>
+    const callArg = env.psMock['updateFrameworkPackage']!.mock.calls[0]![0] as Record<
+      string,
+      unknown
+    >
     expect(callArg['deferRestart']).toBe(false)
   })
 
@@ -381,7 +398,10 @@ describe('buildAddonsProvider — updateFrameworkPackage deferRestart propagatio
       version: '0.1.40',
     })
 
-    const callArg = env.psMock['updateFrameworkPackage']!.mock.calls[0]![0] as Record<string, unknown>
+    const callArg = env.psMock['updateFrameworkPackage']!.mock.calls[0]![0] as Record<
+      string,
+      unknown
+    >
     // Either undefined or not present — both are acceptable
     expect(callArg['deferRestart']).toBeUndefined()
   })

package/src/__tests__/cap-route-adapter.spec.ts

@@ -52,9 +52,7 @@ function makeNodeRegistry(nodes: ReadonlyMap<string, readonly StubNodeEntry[]>)
 // Helpers for stub CapabilityService
 // ---------------------------------------------------------------------------
 
-function makeCapabilityService(
-  providers: ReadonlyMap<string, Record<string, unknown>>,
-) {
+function makeCapabilityService(providers: ReadonlyMap<string, Record<string, unknown>>) {
   return {
     getSingleton<T>(capability: string): T | null {
       return (providers.get(capability) as T) ?? null
@@ -68,7 +66,10 @@ function makeCapabilityService(
 
 describe('createNodeCapAuthority', () => {
   const nodes = new Map([
-    ['hub/stream-broker', [{ addonId: 'addon-stream-broker', capabilities: ['stream-broker', 'stream-params'] }]],
+    [
+      'hub/stream-broker',
+      [{ addonId: 'addon-stream-broker', capabilities: ['stream-broker', 'stream-params'] }],
+    ],
     ['dev-agent-0', [{ addonId: 'addon-detection-pipeline', capabilities: ['pipeline-executor'] }]],
   ])
   const registry = makeNodeRegistry(nodes)
@@ -86,7 +87,9 @@ describe('createNodeCapAuthority', () => {
 
   it('getAddonId returns the addonId for a known cap', () => {
     expect(authority.getAddonId('hub/stream-broker', 'stream-broker')).toBe('addon-stream-broker')
-    expect(authority.getAddonId('dev-agent-0', 'pipeline-executor')).toBe('addon-detection-pipeline')
+    expect(authority.getAddonId('dev-agent-0', 'pipeline-executor')).toBe(
+      'addon-detection-pipeline',
+    )
   })
 
   it('getAddonId returns null for missing nodes or caps', () => {
@@ -126,10 +129,13 @@ describe('createNodeCapAuthority', () => {
 describe('createNodeCapAuthority — per-node singleton override', () => {
   it('getAddonId honors the per-node singleton override when available', () => {
     const nodeRegistry = {
-      getNodeManifest: (id: string) => id === 'dev-agent-0'
-        ? [{ addonId: 'webrtc-native', capabilities: ['webrtc-session'] },
-           { addonId: 'stream-broker', capabilities: ['webrtc-session'] }]
-        : undefined,
+      getNodeManifest: (id: string) =>
+        id === 'dev-agent-0'
+          ? [
+              { addonId: 'webrtc-native', capabilities: ['webrtc-session'] },
+              { addonId: 'stream-broker', capabilities: ['webrtc-session'] },
+            ]
+          : undefined,
       listNodeIds: () => ['hub', 'dev-agent-0'],
     }
     const authority = createNodeCapAuthority(nodeRegistry, {
@@ -141,9 +147,10 @@ describe('createNodeCapAuthority — per-node singleton override', () => {
 
   it('getAddonId falls back to first manifest match without an override', () => {
     const nodeRegistry = {
-      getNodeManifest: (id: string) => id === 'dev-agent-0'
-        ? [{ addonId: 'webrtc-native', capabilities: ['webrtc-session'] }]
-        : undefined,
+      getNodeManifest: (id: string) =>
+        id === 'dev-agent-0'
+          ? [{ addonId: 'webrtc-native', capabilities: ['webrtc-session'] }]
+          : undefined,
       listNodeIds: () => ['hub', 'dev-agent-0'],
     }
     const authority = createNodeCapAuthority(nodeRegistry, { resolveSingleton: () => null })
@@ -186,7 +193,9 @@ describe('createInProcessProviderLookup', () => {
     expect(ref).not.toBeNull()
 
     await expect(ref!.invoke('notAFn', {})).rejects.toThrow(/method "notAFn" not found/)
-    await expect(ref!.invoke('missingMethod', {})).rejects.toThrow(/method "missingMethod" not found/)
+    await expect(ref!.invoke('missingMethod', {})).rejects.toThrow(
+      /method "missingMethod" not found/,
+    )
   })
 })
 
@@ -201,7 +210,9 @@ describe('Resolver + adapters — end-to-end dispatch', () => {
     return vi.fn(async (_childId: string, _input: unknown) => ({ ok: true, from: 'uds' }))
   }
 
-  function makeHubLocalRegistry(caps: ReadonlyMap<string, string>): HubLocalChildDispatcher & { callSpy: ReturnType<typeof vi.fn> } {
+  function makeHubLocalRegistry(
+    caps: ReadonlyMap<string, string>,
+  ): HubLocalChildDispatcher & { callSpy: ReturnType<typeof vi.fn> } {
     const callSpy = makeCallCapOnChildSpy()
     return {
       resolveChildId: (capName: string) => caps.get(capName) ?? null,
@@ -284,6 +295,8 @@ describe('Resolver + adapters — end-to-end dispatch', () => {
     expect(thrown).toBeInstanceOf(CapRouteError)
     expect((thrown as CapRouteError).reason).toBe('no-provider')
     // Must NOT be the old opaque string
-    expect((thrown as CapRouteError).message).not.toContain('Capability "ghost-cap" not available on node')
+    expect((thrown as CapRouteError).message).not.toContain(
+      'Capability "ghost-cap" not available on node',
+    )
   })
 })

package/src/__tests__/cap-routers/_meta.spec.ts

@@ -1,4 +1,3 @@
- 
 /**
  * Meta-test: ensures that every capability with methods has a corresponding
  * `<cap-name>.router.spec.ts` file in this directory. This prevents new caps
@@ -40,7 +39,7 @@ function collectCapabilitiesWithMethods(): readonly CapabilityDefinition[] {
     if (Object.keys(value.methods).length === 0) continue
     out.push(value)
   }
-  return out.sort((a, b) => a.name.localeCompare(b.name))
+  return out.toSorted((a, b) => a.name.localeCompare(b.name))
 }
 
 function specFileNameFor(capName: string): string {
@@ -51,7 +50,7 @@ describe('cap-routers meta', () => {
   const caps = collectCapabilitiesWithMethods()
   const specDir = path.dirname(new URL(import.meta.url).pathname)
   const existingSpecs = new Set(
-    fs.readdirSync(specDir).filter(f => f.endsWith('.router.spec.ts')),
+    fs.readdirSync(specDir).filter((f) => f.endsWith('.router.spec.ts')),
   )
 
   it('discovers at least one capability with methods', () => {
@@ -79,7 +78,7 @@ describe('cap-routers meta', () => {
   })
 
   it('ALLOWED_MISSING only references real capabilities', () => {
-    const names = new Set(caps.map(c => c.name))
+    const names = new Set(caps.map((c) => c.name))
     for (const name of ALLOWED_MISSING) {
       expect(names, `ALLOWED_MISSING references unknown cap "${name}"`).toContain(name)
     }
@@ -180,8 +179,8 @@ describe('cap-routers meta', () => {
       expect(
         outputCount,
         `output-validation codegen drift — expected at least ${procedureCount} .output() ` +
-        `calls (one per query/mutation), found ${outputCount}. ` +
-        `Re-run: npx tsx scripts/generate-cap-routers.ts`,
+          `calls (one per query/mutation), found ${outputCount}. ` +
+          `Re-run: npx tsx scripts/generate-cap-routers.ts`,
       ).toBeGreaterThanOrEqual(procedureCount)
     })
 
@@ -193,7 +192,7 @@ describe('cap-routers meta', () => {
       const outputCount = (generatedSource.match(/\.output\(/g) ?? []).length
       console.log(
         `[output-validation codegen] queries=${queryCount} mutations=${mutationCount} ` +
-        `subscriptions=${subscriptionCount} outputs=${outputCount}`,
+          `subscriptions=${subscriptionCount} outputs=${outputCount}`,
       )
     })
   })

package/src/__tests__/cap-routers/addon-settings.router.spec.ts

@@ -31,9 +31,12 @@ describe('addon-settings cap router', () => {
   it('getGlobalSettings returns schema', async () => {
     const provider = makeMockProvider()
     const router = createCapRouter_addonSettings(() => provider)
-    const result = await invokeProcedure(router, 'getGlobalSettings', makeCtx('admin'), { addonId: 'test' })
+    const result = await invokeProcedure(router, 'getGlobalSettings', makeCtx('admin'), {
+      addonId: 'test',
+    })
     expect(result.ok).toBe(true)
-    if (result.ok) expect(result.value).toEqual({ sections: [{ id: 'g', title: 'Global', fields: [] }] })
+    if (result.ok)
+      expect(result.value).toEqual({ sections: [{ id: 'g', title: 'Global', fields: [] }] })
     expect(provider.getGlobalSettings).toHaveBeenCalledWith({ addonId: 'test' })
   })
 
@@ -41,7 +44,8 @@ describe('addon-settings cap router', () => {
     const provider = makeMockProvider()
     const router = createCapRouter_addonSettings(() => provider)
     const result = await invokeProcedure(router, 'updateGlobalSettings', makeCtx('admin'), {
-      addonId: 'test', patch: { volume: 50 },
+      addonId: 'test',
+      patch: { volume: 50 },
     })
     expect(result.ok).toBe(true)
     if (result.ok) expect(result.value).toEqual({ success: true })
@@ -51,7 +55,8 @@ describe('addon-settings cap router', () => {
     const provider = makeMockProvider()
     const router = createCapRouter_addonSettings(() => provider)
     await invokeProcedure(router, 'getDeviceSettings', makeCtx('admin'), {
-      addonId: 'test', deviceId: 1,
+      addonId: 'test',
+      deviceId: 1,
     })
     expect(provider.getDeviceSettings).toHaveBeenCalledWith({ addonId: 'test', deviceId: 1 })
   })
@@ -60,16 +65,22 @@ describe('addon-settings cap router', () => {
     const provider = makeMockProvider()
     const router = createCapRouter_addonSettings(() => provider)
     await invokeProcedure(router, 'updateDeviceSettings', makeCtx('admin'), {
-      addonId: 'test', deviceId: 1, patch: { enabled: false },
+      addonId: 'test',
+      deviceId: 1,
+      patch: { enabled: false },
     })
     expect(provider.updateDeviceSettings).toHaveBeenCalledWith({
-      addonId: 'test', deviceId: 1, patch: { enabled: false },
+      addonId: 'test',
+      deviceId: 1,
+      patch: { enabled: false },
     })
   })
 
   it('returns PRECONDITION_FAILED when provider is null', async () => {
     const router = createCapRouter_addonSettings(() => null)
-    const result = await invokeProcedure(router, 'getGlobalSettings', makeCtx('admin'), { addonId: 'x' })
+    const result = await invokeProcedure(router, 'getGlobalSettings', makeCtx('admin'), {
+      addonId: 'x',
+    })
     expect(result.ok).toBe(false)
     if (!result.ok) expect(result.code).toBe('PRECONDITION_FAILED')
   })
@@ -78,9 +89,7 @@ describe('addon-settings cap router', () => {
     const provider = makeMockProvider()
     const router = createCapRouter_addonSettings(() => provider)
     for (const method of ['getGlobalSettings', 'getDeviceSettings']) {
-      const input = method.includes('Device')
-        ? { addonId: 'x', deviceId: 1 }
-        : { addonId: 'x' }
+      const input = method.includes('Device') ? { addonId: 'x', deviceId: 1 } : { addonId: 'x' }
       const results = await checkAuthMatrix(router, method, 'protected', input)
       for (const r of results) {
         if (r.allowed) expect(r.outcome.ok).toBe(true)