@camstack/server 0.1.7 → 0.2.0

package/src/__tests__/cap-routers/broker-routing.router.spec.ts

@@ -0,0 +1,177 @@
+/**
+ * Routing regression spec for the `broker` system-collection cap.
+ *
+ * The bug: `broker` is `scope:'system', mode:'collection'`. Two addons
+ * register a `broker` provider, each owning a DISJOINT id set
+ * (mqtt-broker owns `mqtt_*`, provider-homeassistant owns `ha_*`). The
+ * generated collection mount only fans out the array-output methods
+ * (`list` / `listProviders`); every id-keyed method (`get` / `getSettings`
+ * / `remove` / `testConnection` / …) falls through to `providers[0]`
+ * (the FIRST-registered provider = mqtt-broker). So operating on an HA
+ * broker `ha_1` hit mqtt-broker → "broker 'ha_1' not found".
+ *
+ * The fix: each broker carries its owning `addonId`; the admin UI threads
+ * it back as the `{ addonId }` system-collection selector so the call
+ * routes to the OWNING provider via `getProviderByAddonId`. Providers
+ * also return `null` (not throw) for ids they don't own, so the
+ * no-addonId fallback degrades gracefully.
+ *
+ * This spec exercises `createCapRouter_broker` with the SAME selector
+ * the generated mount builds (registry-backed: addonId → provider, else
+ * first-provider aggregate with array methods fanned out). It registers
+ * two mock providers and asserts:
+ *  - `list()` returns both, each tagged with its `addonId`.
+ *  - `get({id:'ha_1'}, addonId:'ha')` routes to the HA provider.
+ *  - `get({id:'ha_1'})` WITHOUT addonId returns null (graceful) — the
+ *    HA-owned id isn't in providers[0]'s registry, so it doesn't throw.
+ *  - `listProviders()` aggregates both providers' entries.
+ */
+import { describe, it, expect } from 'vitest'
+import { createCapRouter_broker } from '../../api/trpc/generated-cap-routers.js'
+import { type IBrokerProvider, type BrokerInfo, type BrokerProviderInfo } from '@camstack/types'
+import { concatCollection } from '../../api/trpc/cap-mount-helpers.js'
+import { makeCtx, invokeProcedure } from './harness.js'
+
+/**
+ * A self-contained mock `broker` provider that owns a fixed set of
+ * broker ids and self-tags every returned record with its `addonId`.
+ * Returns `null` / no-op for ids it does NOT own (never throws) — the
+ * exact graceful-degradation contract the real providers must honour.
+ */
+function makeProvider(addonId: string, ownedIds: readonly string[], kind: string): IBrokerProvider {
+  const owns = (id: string): boolean => ownedIds.includes(id)
+  const infoFor = (id: string): BrokerInfo => ({
+    id,
+    addonId,
+    name: `${kind}-${id}`,
+    kind,
+    status: 'connected',
+    info: {},
+    lastCheckedAt: null,
+    error: null,
+  })
+  return {
+    list: async () => ownedIds.map(infoFor),
+    get: async ({ id }) => (owns(id) ? infoFor(id) : null),
+    listProviders: async (): Promise<BrokerProviderInfo[]> => [
+      { addonId, kinds: [{ kind, label: kind }] },
+    ],
+    add: async () => ({ id: 'new' }),
+    remove: async () => {
+      // no-op for foreign ids (and owned ids in this mock)
+    },
+    testConnection: async ({ id }) =>
+      owns(id) ? { ok: true, latencyMs: 1 } : { ok: false, error: 'unknown broker' },
+    getSettings: async ({ id }) => (owns(id) ? { secret: id } : null),
+    setSettings: async () => {
+      // no-op
+    },
+    getBrokerConfig: async ({ id }) => (owns(id) ? { url: id } : null),
+    getSettingsSchema: async ({ kind: k }) => (k === kind ? { form: kind } : null),
+    testSettings: async () => ({ ok: true }),
+    publish: async () => null,
+    subscribe: async () => ({ subscriptionId: 's' }),
+    unsubscribe: async () => {
+      // no-op
+    },
+    getState: async () => null,
+    getStatus: async () => ({ brokerCount: ownedIds.length, connectedCount: ownedIds.length }),
+  }
+}
+
+/**
+ * Mirror of the generated collection mount selector for `broker`
+ * (`generated-cap-mounts.ts`): addonId → that provider directly; else a
+ * first-provider aggregate whose array-output methods are
+ * `concatCollection`-fanned. Two providers registered in order:
+ * mqtt (owns `mqtt_1`) first, ha (owns `ha_1`) second.
+ */
+function makeSelector(): (addonId?: string) => IBrokerProvider | null {
+  const mqtt = makeProvider('mqtt', ['mqtt_1'], 'mqtt')
+  const ha = makeProvider('ha', ['ha_1'], 'home-assistant')
+  const byAddonId: Record<string, IBrokerProvider> = { mqtt, ha }
+  const providers: readonly IBrokerProvider[] = [mqtt, ha]
+  return (addonId?: string): IBrokerProvider | null => {
+    if (addonId !== undefined) return byAddonId[addonId] ?? null
+    const first = providers[0]!
+    return {
+      ...first,
+      list: concatCollection(providers, 'list') as IBrokerProvider['list'],
+      listProviders: concatCollection(
+        providers,
+        'listProviders',
+      ) as IBrokerProvider['listProviders'],
+    }
+  }
+}
+
+describe('broker cap — addonId ownership routing', () => {
+  it('list() aggregates both providers, each broker tagged with its addonId', async () => {
+    const selector = makeSelector()
+    const router = createCapRouter_broker((_ctx, addonId) => selector(addonId))
+
+    const outcome = await invokeProcedure(router, 'list', makeCtx('admin'), {})
+
+    expect(outcome.ok).toBe(true)
+    if (!outcome.ok) return
+    const rows = outcome.value as BrokerInfo[]
+    const byId = new Map(rows.map((r) => [r.id, r]))
+    expect(byId.get('mqtt_1')?.addonId).toBe('mqtt')
+    expect(byId.get('ha_1')?.addonId).toBe('ha')
+  })
+
+  it('get({id:ha_1}, addonId:ha) routes to the HA provider (not mqtt-broker)', async () => {
+    const selector = makeSelector()
+    const router = createCapRouter_broker((_ctx, addonId) => selector(addonId))
+
+    const outcome = await invokeProcedure(router, 'get', makeCtx('admin'), {
+      id: 'ha_1',
+      addonId: 'ha',
+    })
+
+    expect(outcome.ok).toBe(true)
+    if (!outcome.ok) return
+    const row = outcome.value as BrokerInfo | null
+    expect(row).not.toBeNull()
+    expect(row?.id).toBe('ha_1')
+    expect(row?.addonId).toBe('ha')
+  })
+
+  it('get({id:ha_1}) WITHOUT addonId returns null gracefully (first provider does not own it)', async () => {
+    const selector = makeSelector()
+    const router = createCapRouter_broker((_ctx, addonId) => selector(addonId))
+
+    const outcome = await invokeProcedure(router, 'get', makeCtx('admin'), { id: 'ha_1' })
+
+    expect(outcome.ok).toBe(true)
+    if (!outcome.ok) return
+    expect(outcome.value).toBeNull()
+  })
+
+  it('testConnection({id:ha_1}, addonId:ha) routes to HA provider and succeeds', async () => {
+    const selector = makeSelector()
+    const router = createCapRouter_broker((_ctx, addonId) => selector(addonId))
+
+    const outcome = await invokeProcedure(router, 'testConnection', makeCtx('admin'), {
+      id: 'ha_1',
+      addonId: 'ha',
+    })
+
+    expect(outcome.ok).toBe(true)
+    if (!outcome.ok) return
+    expect(outcome.value).toEqual({ ok: true, latencyMs: 1 })
+  })
+
+  it('listProviders() aggregates both providers entries', async () => {
+    const selector = makeSelector()
+    const router = createCapRouter_broker((_ctx, addonId) => selector(addonId))
+
+    const outcome = await invokeProcedure(router, 'listProviders', makeCtx('admin'))
+
+    expect(outcome.ok).toBe(true)
+    if (!outcome.ok) return
+    const entries = outcome.value as BrokerProviderInfo[]
+    const addonIds = entries.map((e) => e.addonId).toSorted()
+    expect(addonIds).toEqual(['ha', 'mqtt'])
+  })
+})

package/src/__tests__/cap-routers/cap-route-error-formatter.spec.ts

@@ -13,7 +13,9 @@ import { formatTrpcError } from '../../api/trpc/cap-route-error-formatter.js'
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
 /** Minimal DefaultErrorShape stub. */
-function makeShape(overrides: Partial<{ message: string }> = {}): Parameters<typeof formatTrpcError>[0]['shape'] {
+function makeShape(
+  overrides: Partial<{ message: string }> = {},
+): Parameters<typeof formatTrpcError>[0]['shape'] {
   return {
     message: overrides.message ?? 'Something went wrong',
     code: -32603, // INTERNAL_SERVER_ERROR code number

package/src/__tests__/cap-routers/capabilities-node.spec.ts

@@ -15,14 +15,25 @@ import { createCapabilitiesRouter } from '../../api/core/capabilities.router.js'
 import { makeCtx } from './harness.js'
 
 function harness() {
-  const calls: { setActiveSingleton: unknown[][]; clear: unknown[][] } = { setActiveSingleton: [], clear: [] }
+  const calls: { setActiveSingleton: unknown[][]; clear: unknown[][] } = {
+    setActiveSingleton: [],
+    clear: [],
+  }
   const sets: Record<string, unknown> = {}
   const registry = {
-    setActiveSingleton: vi.fn(async (...a: unknown[]) => { calls.setActiveSingleton.push(a) }),
-    clearSingletonNodeOverride: vi.fn((...a: unknown[]) => { calls.clear.push(a) }),
+    setActiveSingleton: vi.fn(async (...a: unknown[]) => {
+      calls.setActiveSingleton.push(a)
+    }),
+    clearSingletonNodeOverride: vi.fn((...a: unknown[]) => {
+      calls.clear.push(a)
+    }),
     listCapabilities: () => [],
   } as unknown as CapabilityRegistry
-  const config = { set: (k: string, v: unknown) => { sets[k] = v } } as unknown as ConfigService
+  const config = {
+    set: (k: string, v: unknown) => {
+      sets[k] = v
+    },
+  } as unknown as ConfigService
   const router = createCapabilitiesRouter(registry, config)
   return { router, calls, sets, registry }
 }
@@ -32,7 +43,9 @@ describe('capabilities.router — per-node singleton', () => {
     const { router, calls, sets } = harness()
     const caller = router.createCaller(makeCtx('admin'))
     await caller.setActiveSingleton({
-      capability: 'webrtc-session', addonId: 'webrtc-native', nodeId: 'dev-agent-0',
+      capability: 'webrtc-session',
+      addonId: 'webrtc-native',
+      nodeId: 'dev-agent-0',
     })
     expect(calls.setActiveSingleton[0]).toEqual(['webrtc-session', 'webrtc-native', 'dev-agent-0'])
     expect(sets['capabilities.singletonNode.webrtc-session.dev-agent-0']).toBe('webrtc-native')

package/src/__tests__/cap-routers/device-link-overlay.spec.ts

@@ -0,0 +1,137 @@
+/**
+ * Tests that `requireDeviceScoped` overlays `getStatus` results via
+ * `device-manager`'s `resolveLinkedStatus` when the device has linked
+ * properties for the requested cap.
+ *
+ * The overlay is transparent (null return = no-op) for the vast majority
+ * of reads; only devices with active links for the cap get the merged
+ * status back.
+ */
+import { describe, it, expect, vi } from 'vitest'
+import type { CapabilityRegistry } from '@camstack/kernel'
+import { requireDeviceScoped } from '../../api/trpc/cap-mount-helpers.js'
+
+// ── Fake registry ────────────────────────────────────────────────────────────
+
+type ResolveLinkedStatus = (i: {
+  deviceId: number
+  cap: string
+  baseStatus: unknown
+}) => Promise<Record<string, unknown> | null>
+
+interface FakeDeviceManager {
+  resolveLinkedStatus: ResolveLinkedStatus
+}
+
+function makeRegistry(opts: {
+  nativeGetStatus: () => Promise<Record<string, unknown>>
+  nativeSetFanSpeed?: (i: unknown) => Promise<void>
+  resolveLinkedStatus: ResolveLinkedStatus
+}): CapabilityRegistry {
+  const nativeProvider = {
+    getStatus: opts.nativeGetStatus,
+    setFanSpeed: opts.nativeSetFanSpeed ?? vi.fn(async () => undefined),
+  }
+  const deviceManager: FakeDeviceManager = {
+    resolveLinkedStatus: opts.resolveLinkedStatus,
+  }
+  return {
+    getNativeProvider<T>(_capName: string, _deviceId: number): T | null {
+      return nativeProvider as unknown as T
+    },
+    getSingleton<T>(capability: string): T | null {
+      if (capability === 'device-manager') {
+        return deviceManager as unknown as T
+      }
+      return null
+    },
+    // Minimal no-op stubs for the rest of the CapabilityRegistry surface
+    // so TypeScript is satisfied without pulling in the real kernel class.
+    listCapabilities: vi.fn(() => []),
+    registerProvider: vi.fn(),
+    unregisterProvider: vi.fn(),
+    getCollection: vi.fn(() => []),
+    getCollectionEntries: vi.fn(() => []),
+    registerNativeProvider: vi.fn(),
+    unregisterNativeProvider: vi.fn(),
+    getProviderForDevice: vi.fn(() => null),
+    getBindings: vi.fn(() => ({ entries: [] })),
+    setActiveSingleton: vi.fn(),
+    getSingletonAddonId: vi.fn(() => null),
+    getAddonIdForProvider: vi.fn(() => null),
+    on: vi.fn(),
+    off: vi.fn(),
+    dispose: vi.fn(),
+  } as unknown as CapabilityRegistry
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+const DEVICE_ID = 668
+const CAP_NAME = 'vacuum-control' as Parameters<typeof requireDeviceScoped>[1]
+
+describe('requireDeviceScoped — getStatus overlay via resolveLinkedStatus', () => {
+  it('returns the overlaid status when resolveLinkedStatus returns a non-null object', async () => {
+    const base = { state: 'idle', battery: 80 }
+    const overlaid = { state: 'paused', cleanWater: { status: 'low', level: null } }
+
+    const registry = makeRegistry({
+      nativeGetStatus: vi.fn(async () => base),
+      resolveLinkedStatus: vi.fn(async () => overlaid),
+    })
+
+    const dispatcher = requireDeviceScoped(registry, CAP_NAME)
+    expect(dispatcher).not.toBeNull()
+
+    // Call via the Proxy — method is resolved lazily
+    const result = await (
+      dispatcher as unknown as { getStatus: (i: { deviceId: number }) => Promise<unknown> }
+    ).getStatus({ deviceId: DEVICE_ID })
+
+    expect(result).toEqual(overlaid)
+    expect(result).not.toEqual(base)
+  })
+
+  it('returns the base provider result unchanged when resolveLinkedStatus returns null (no links)', async () => {
+    const base = { state: 'cleaning', battery: 60 }
+
+    const registry = makeRegistry({
+      nativeGetStatus: vi.fn(async () => base),
+      resolveLinkedStatus: vi.fn(async () => null),
+    })
+
+    const dispatcher = requireDeviceScoped(registry, CAP_NAME)
+    expect(dispatcher).not.toBeNull()
+
+    const result = await (
+      dispatcher as unknown as { getStatus: (i: { deviceId: number }) => Promise<unknown> }
+    ).getStatus({ deviceId: DEVICE_ID })
+
+    expect(result).toEqual(base)
+  })
+
+  it('does NOT call resolveLinkedStatus for non-getStatus methods', async () => {
+    const base = { state: 'idle', battery: 90 }
+    const resolveLinkedStatus = vi.fn(async () => null)
+    const nativeSetFanSpeed = vi.fn(async () => undefined)
+
+    const registry = makeRegistry({
+      nativeGetStatus: vi.fn(async () => base),
+      nativeSetFanSpeed,
+      resolveLinkedStatus,
+    })
+
+    const dispatcher = requireDeviceScoped(registry, CAP_NAME)
+    expect(dispatcher).not.toBeNull()
+
+    await (
+      dispatcher as unknown as {
+        setFanSpeed: (i: { deviceId: number; speed: string }) => Promise<void>
+      }
+    ).setFanSpeed({ deviceId: DEVICE_ID, speed: 'high' })
+
+    expect(nativeSetFanSpeed).toHaveBeenCalledOnce()
+    // The overlay path must NOT be consulted for mutations
+    expect(resolveLinkedStatus).not.toHaveBeenCalled()
+  })
+})

package/src/__tests__/cap-routers/device-manager-aggregate.router.spec.ts

@@ -24,25 +24,54 @@ function makeProvider(): IDeviceManagerProvider {
           title: 'Identity',
           tab: 'general',
           order: 0,
-          fields: [{ type: 'text', key: '_stableId', label: 'Stable ID', readonlyField: true, value: String(deviceId) }],
+          fields: [
+            {
+              type: 'text',
+              key: '_stableId',
+              label: 'Stable ID',
+              readonlyField: true,
+              value: String(deviceId),
+            },
+          ],
         },
         {
           id: 'motion-tuning',
           title: 'Motion Tuning',
           tab: 'detection',
           order: 5,
-          fields: [{ type: 'number', key: 'threshold', label: 'Threshold', writerCapName: 'motion-detection', writerAddonId: 'motion-wasm', source: 'settings', value: 20 }],
+          fields: [
+            {
+              type: 'number',
+              key: 'threshold',
+              label: 'Threshold',
+              writerCapName: 'motion-detection',
+              writerAddonId: 'motion-wasm',
+              source: 'settings',
+              value: 20,
+            },
+          ],
         },
       ],
     })),
     getDeviceLiveInfoAggregate: vi.fn(async ({ deviceId }) => ({
-      sections: [{
-        id: 'orchestrator-live',
-        title: 'Pipeline Status',
-        tab: 'detection',
-        order: 100,
-        fields: [{ type: 'text', key: 'assignedRunner', label: 'Assigned Runner', readonlyField: true, source: 'live', value: deviceId === 1 ? 'hub' : '' }],
-      }],
+      sections: [
+        {
+          id: 'orchestrator-live',
+          title: 'Pipeline Status',
+          tab: 'detection',
+          order: 100,
+          fields: [
+            {
+              type: 'text',
+              key: 'assignedRunner',
+              label: 'Assigned Runner',
+              readonlyField: true,
+              source: 'live',
+              value: deviceId === 1 ? 'hub' : '',
+            },
+          ],
+        },
+      ],
     })),
     updateDeviceField: vi.fn(async () => ({ success: true as const })),
 
@@ -60,14 +89,21 @@ function makeProvider(): IDeviceManagerProvider {
     getStreamSources: vi.fn(async () => []) as IDeviceManagerProvider['getStreamSources'],
     getConfigSchema: vi.fn(async () => []) as IDeviceManagerProvider['getConfigSchema'],
     getSettingsSchema: vi.fn(async () => null) as IDeviceManagerProvider['getSettingsSchema'],
-    updateConfig: vi.fn(async () => ({ success: true as const })) as IDeviceManagerProvider['updateConfig'],
+    updateConfig: vi.fn(async () => ({
+      success: true as const,
+    })) as IDeviceManagerProvider['updateConfig'],
     enable: vi.fn(async () => ({ success: true as const })) as IDeviceManagerProvider['enable'],
     disable: vi.fn(async () => ({ success: true as const })) as IDeviceManagerProvider['disable'],
     remove: vi.fn(async () => ({ success: true as const })) as IDeviceManagerProvider['remove'],
     getStreamProfileMap: vi.fn(async () => ({})) as IDeviceManagerProvider['getStreamProfileMap'],
-    setStreamProfileMap: vi.fn(async () => ({ success: true as const })) as IDeviceManagerProvider['setStreamProfileMap'],
+    setStreamProfileMap: vi.fn(async () => ({
+      success: true as const,
+    })) as IDeviceManagerProvider['setStreamProfileMap'],
     probeStreams: vi.fn(async () => []) as IDeviceManagerProvider['probeStreams'],
-    getBindings: vi.fn(async ({ deviceId }: { deviceId: number }) => ({ deviceId, entries: [] })) as IDeviceManagerProvider['getBindings'],
+    getBindings: vi.fn(async ({ deviceId }: { deviceId: number }) => ({
+      deviceId,
+      entries: [],
+    })) as IDeviceManagerProvider['getBindings'],
     setWrapperActive: vi.fn() as IDeviceManagerProvider['setWrapperActive'],
   }
 }
@@ -78,24 +114,32 @@ describe('device-manager aggregator via tRPC router', () => {
   it('getDeviceSettingsAggregate returns the merged shape for a known device', async () => {
     const provider = makeProvider()
     const router = createCapRouter_deviceManager(() => provider)
-    const result = await invokeProcedure(router, 'getDeviceSettingsAggregate', makeCtx('admin'), { deviceId: DEVICE_ID })
+    const result = await invokeProcedure(router, 'getDeviceSettingsAggregate', makeCtx('admin'), {
+      deviceId: DEVICE_ID,
+    })
 
     expect(result.ok).toBe(true)
     if (!result.ok) return
-    const value = result.value as { sections: readonly { id: string; tab?: string; fields: readonly unknown[] }[] }
-    expect(value.sections.map(s => s.id)).toEqual(['identity', 'motion-tuning'])
+    const value = result.value as {
+      sections: readonly { id: string; tab?: string; fields: readonly unknown[] }[]
+    }
+    expect(value.sections.map((s) => s.id)).toEqual(['identity', 'motion-tuning'])
     expect(provider.getDeviceSettingsAggregate).toHaveBeenCalledWith({ deviceId: DEVICE_ID })
   })
 
   it('getDeviceLiveInfoAggregate returns live sections', async () => {
     const provider = makeProvider()
     const router = createCapRouter_deviceManager(() => provider)
-    const result = await invokeProcedure(router, 'getDeviceLiveInfoAggregate', makeCtx('admin'), { deviceId: DEVICE_ID })
+    const result = await invokeProcedure(router, 'getDeviceLiveInfoAggregate', makeCtx('admin'), {
+      deviceId: DEVICE_ID,
+    })
 
     expect(result.ok).toBe(true)
     if (!result.ok) return
-    const value = result.value as { sections: readonly { fields: readonly { key?: string; value?: unknown }[] }[] }
-    const runner = value.sections[0]!.fields.find(f => f.key === 'assignedRunner')
+    const value = result.value as {
+      sections: readonly { fields: readonly { key?: string; value?: unknown }[] }[]
+    }
+    const runner = value.sections[0]!.fields.find((f) => f.key === 'assignedRunner')
     expect(runner?.value).toBe('hub')
   })
 
@@ -124,7 +168,13 @@ describe('device-manager aggregator via tRPC router', () => {
     const provider = makeProvider()
     const router = createCapRouter_deviceManager(() => provider)
 
-    const payload = { deviceId: DEVICE_ID, writerCapName: 'motion-detection', writerAddonId: 'motion-wasm', key: 'threshold', value: 1 }
+    const payload = {
+      deviceId: DEVICE_ID,
+      writerCapName: 'motion-detection',
+      writerAddonId: 'motion-wasm',
+      key: 'threshold',
+      value: 1,
+    }
     const viewer = await invokeProcedure(router, 'updateDeviceField', makeCtx('user'), payload)
     expect(viewer.ok).toBe(false)
     if (!viewer.ok) expect(viewer.code).toBe('FORBIDDEN')
@@ -135,7 +185,9 @@ describe('device-manager aggregator via tRPC router', () => {
 
   it('router returns PRECONDITION_FAILED when the provider is missing', async () => {
     const router = createCapRouter_deviceManager(() => null)
-    const result = await invokeProcedure(router, 'getDeviceSettingsAggregate', makeCtx('admin'), { deviceId: DEVICE_ID })
+    const result = await invokeProcedure(router, 'getDeviceSettingsAggregate', makeCtx('admin'), {
+      deviceId: DEVICE_ID,
+    })
     expect(result.ok).toBe(false)
     if (!result.ok) expect(result.code).toBe('PRECONDITION_FAILED')
   })

package/src/__tests__/cap-routers/harness.ts

@@ -1,4 +1,3 @@
-
 /**
  * Test harness for codegen'd capability tRPC routers.
  *
@@ -24,7 +23,10 @@ export type AuthLevel = 'public' | 'protected' | 'admin'
 export type TestRole = 'anonymous' | 'user' | 'admin' | 'agent'
 
 /** Build an AuthenticatedAgent stub for a given synthetic identity. */
-export function makeUser(role: Exclude<TestRole, 'anonymous'>, overrides: Partial<AuthenticatedAgent> = {}): AuthenticatedAgent {
+export function makeUser(
+  role: Exclude<TestRole, 'anonymous'>,
+  overrides: Partial<AuthenticatedAgent> = {},
+): AuthenticatedAgent {
   const isAdmin = role === 'admin' || role === 'agent'
   const base: AuthenticatedAgent = {
     id: `user-${role}`,
@@ -111,11 +113,13 @@ export async function checkAuthMatrix(
   procedure: string,
   auth: AuthLevel,
   input?: unknown,
-): Promise<ReadonlyArray<{
-  readonly role: TestRole
-  readonly allowed: boolean
-  readonly outcome: Awaited<ReturnType<typeof invokeProcedure>>
-}>> {
+): Promise<
+  ReadonlyArray<{
+    readonly role: TestRole
+    readonly allowed: boolean
+    readonly outcome: Awaited<ReturnType<typeof invokeProcedure>>
+  }>
+> {
   const results: Array<{
     role: TestRole
     allowed: boolean

package/src/__tests__/cap-routers/metrics-provider.router.spec.ts

@@ -1,4 +1,3 @@
-
 /**
  * Example spec exercising the codegen'd metrics-provider router end-to-end:
  *  - Wires a mock provider into `createCapRouter_metricsProvider`
@@ -14,9 +13,24 @@ function makeMockProvider(overrides: Partial<IMetricsProvider> = {}): IMetricsPr
   return {
     collectSnapshot: async () => ({
       cpu: { total: 0, user: 0, system: 0, irq: 0, nice: 0, loadAvg: [0, 0, 0], cores: 1 },
-      memory: { percent: 0, totalBytes: 0, usedBytes: 0, availableBytes: 0, swapUsedBytes: 0, swapTotalBytes: 0 },
+      memory: {
+        percent: 0,
+        totalBytes: 0,
+        usedBytes: 0,
+        availableBytes: 0,
+        swapUsedBytes: 0,
+        swapTotalBytes: 0,
+      },
       gpu: null,
-      network: { rxBytes: 0, txBytes: 0, rxPackets: 0, txPackets: 0, rxErrors: 0, txErrors: 0, timestampMs: 0 },
+      network: {
+        rxBytes: 0,
+        txBytes: 0,
+        rxPackets: 0,
+        txPackets: 0,
+        rxErrors: 0,
+        txErrors: 0,
+        timestampMs: 0,
+      },
       disk: { readBytes: 0, writeBytes: 0, readOps: 0, writeOps: 0, timestampMs: 0 },
       pressure: { cpu: null, memory: null, io: null },
       process: { openFds: 0, threadCount: 0, activeHandles: 0, activeRequests: 0 },

package/src/__tests__/cap-routers/null-provider-guard.spec.ts

@@ -36,11 +36,12 @@ describe('null-provider guard — all capabilities', () => {
       const router = factory(() => null)
 
       // Find the first method on the router's caller
-      const caller = (router as { createCaller: (ctx: unknown) => Record<string, unknown> })
-        .createCaller(makeCtx('admin'))
+      const caller = (
+        router as { createCaller: (ctx: unknown) => Record<string, unknown> }
+      ).createCaller(makeCtx('admin'))
 
       const methods = Object.keys(caller).filter(
-        k => typeof caller[k] === 'function' && !k.startsWith('_'),
+        (k) => typeof caller[k] === 'function' && !k.startsWith('_'),
       )
 
       if (methods.length === 0) return // No methods — skip
@@ -57,10 +58,7 @@ describe('null-provider guard — all capabilities', () => {
       // caught by codegen guard) or BAD_REQUEST (input validation before guard)
       // or INTERNAL_SERVER_ERROR (provider method call on null).
       // Any of these is acceptable — the important thing is ok !== true.
-      expect(
-        result.ok,
-        `${name}.${firstMethod} returned success with null provider!`,
-      ).toBe(false)
+      expect(result.ok, `${name}.${firstMethod} returned success with null provider!`).toBe(false)
     })
   }
 })