@camstack/server 0.1.7 → 0.2.0

package/src/core/logging/logging.service.spec.ts

@@ -1,4 +1,3 @@
-
 import { describe, it, expect, beforeEach, afterEach } from 'vitest'
 import * as fs from 'node:fs'
 import * as path from 'node:path'
@@ -25,19 +24,43 @@ class InMemorySettingsStore implements ISettingsStore {
     this.system = { ...seed }
   }
 
-  getSystem(key: string): unknown { return this.system[key] }
-  setSystem(key: string, value: unknown): void { this.system[key] = value }
-  getAllSystem(): Record<string, unknown> { return { ...this.system } }
-
-  getAllAddon(_addonId: string): Record<string, unknown> { return {} }
-  setAllAddon(_addonId: string, _config: Record<string, unknown>): void { /* no-op */ }
-  getAllProvider(_providerId: string): Record<string, unknown> { return {} }
-  setProvider(_providerId: string, _key: string, _value: unknown): void { /* no-op */ }
-  getAllDevice(_deviceId: string): Record<string, unknown> { return {} }
-  setDevice(_deviceId: string, _key: string, _value: unknown): void { /* no-op */ }
-  getAddonDevice(_addonId: string, _deviceId: string): Record<string, unknown> { return {} }
-  setAddonDevice(_addonId: string, _deviceId: string, _values: Record<string, unknown>): void { /* no-op */ }
-  clearAddonDevice(_addonId: string, _deviceId: string): void { /* no-op */ }
+  getSystem(key: string): unknown {
+    return this.system[key]
+  }
+  setSystem(key: string, value: unknown): void {
+    this.system[key] = value
+  }
+  getAllSystem(): Record<string, unknown> {
+    return { ...this.system }
+  }
+
+  getAllAddon(_addonId: string): Record<string, unknown> {
+    return {}
+  }
+  setAllAddon(_addonId: string, _config: Record<string, unknown>): void {
+    /* no-op */
+  }
+  getAllProvider(_providerId: string): Record<string, unknown> {
+    return {}
+  }
+  setProvider(_providerId: string, _key: string, _value: unknown): void {
+    /* no-op */
+  }
+  getAllDevice(_deviceId: string): Record<string, unknown> {
+    return {}
+  }
+  setDevice(_deviceId: string, _key: string, _value: unknown): void {
+    /* no-op */
+  }
+  getAddonDevice(_addonId: string, _deviceId: string): Record<string, unknown> {
+    return {}
+  }
+  setAddonDevice(_addonId: string, _deviceId: string, _values: Record<string, unknown>): void {
+    /* no-op */
+  }
+  clearAddonDevice(_addonId: string, _deviceId: string): void {
+    /* no-op */
+  }
 }
 
 describe('ScopedLogger', () => {
@@ -147,13 +170,28 @@ describe('LogRingBuffer', () => {
   it('filters by tags (addonId exact match)', () => {
     const buffer = new LogRingBuffer(100)
 
-    buffer.push({ timestamp: new Date(), level: 'info', message: 'a', tags: { addonId: 'stream-broker' } })
-    buffer.push({ timestamp: new Date(), level: 'info', message: 'b', tags: { addonId: 'provider-rtsp' } })
-    buffer.push({ timestamp: new Date(), level: 'info', message: 'c', tags: { addonId: 'stream-broker' } })
+    buffer.push({
+      timestamp: new Date(),
+      level: 'info',
+      message: 'a',
+      tags: { addonId: 'stream-broker' },
+    })
+    buffer.push({
+      timestamp: new Date(),
+      level: 'info',
+      message: 'b',
+      tags: { addonId: 'provider-rtsp' },
+    })
+    buffer.push({
+      timestamp: new Date(),
+      level: 'info',
+      message: 'c',
+      tags: { addonId: 'stream-broker' },
+    })
 
     const result = buffer.query({ tags: { addonId: 'stream-broker' } })
     expect(result).toHaveLength(2)
-    expect(result.map((e) => e.message).sort()).toEqual(['a', 'c'])
+    expect(result.map((e) => e.message).toSorted()).toEqual(['a', 'c'])
   })
 
   it('respects limit', () => {
@@ -190,9 +228,11 @@ describe('LoggingService', () => {
       'utf-8',
     )
     const configService = new ConfigService(configPath)
-    configService.setSettingsStore(new InMemorySettingsStore({
-      'eventBus.ringBufferSize': bufferSize,
-    }))
+    configService.setSettingsStore(
+      new InMemorySettingsStore({
+        'eventBus.ringBufferSize': bufferSize,
+      }),
+    )
     return new LoggingService(configService)
   }
 

package/src/core/logging/logging.service.ts

@@ -25,8 +25,13 @@ export class LoggingService extends LogManager {
   private readonly deviceNames = new Map<number, string>()
 
   constructor(configService: ConfigService) {
-    const bufferSize = configService.get<number>('eventBus.ringBufferSize') ?? 10000
-    super(bufferSize)
+    // The log buffer is now partitioned per addonId (see PartitionedLogBuffer):
+    // this value caps EACH addon's bucket, not the total. A chatty addon evicts
+    // only its own lines, so quiet addons (e.g. a HomeAssistant `image` entity)
+    // keep their sparse history. `eventBus.ringBufferSize` still sizes the
+    // separate system-event ring; logs get their own per-addon cap.
+    const perAddonCapacity = configService.get<number>('eventBus.perAddonLogBufferSize') ?? 5000
+    super(perAddonCapacity)
     // Enriches every emitted LogEntry with `tags.deviceName` before
     // destinations / subscribers see it — works across bundled copies
     // of `@camstack/core` (addon packages) because the mutation
@@ -38,7 +43,12 @@ export class LoggingService extends LogManager {
   setDeviceNames(entries: ReadonlyArray<{ id: number; name: string }>): void {
     this.deviceNames.clear()
     for (const { id, name } of entries) {
-      if (typeof id === 'number' && Number.isFinite(id) && typeof name === 'string' && name.length > 0) {
+      if (
+        typeof id === 'number' &&
+        Number.isFinite(id) &&
+        typeof name === 'string' &&
+        name.length > 0
+      ) {
         this.deviceNames.set(id, name)
       }
     }
@@ -68,7 +78,11 @@ export class LoggingService extends LogManager {
       if (data && typeof data.deviceId === 'number') {
         this.upsertDeviceName(data.deviceId, data.name)
         selfLogger.info('device-name cache upserted', {
-          meta: { deviceId: data.deviceId, name: data.name ?? null, cacheSize: this.deviceNames.size },
+          meta: {
+            deviceId: data.deviceId,
+            name: data.name ?? null,
+            cacheSize: this.deviceNames.size,
+          },
         })
       }
     })
@@ -112,7 +126,7 @@ export class LoggingService extends LogManager {
     const nodeId = entry.nodeId
     const agentId = nodeId?.includes('/') ? nodeId.split('/')[0]! : nodeId
     const mergedTags: LogTags = {
-      ...(entry.tags ?? {}),
+      ...entry.tags,
       addonId: entry.addonId,
       ...(nodeId !== undefined ? { nodeId } : {}),
       ...(agentId !== undefined ? { agentId } : {}),

package/src/core/moleculer/cap-call-fn.spec.ts

@@ -1,10 +1,6 @@
 import { describe, it, expect, vi } from 'vitest'
 import type { CapRoute, CapCallInput } from '@camstack/kernel'
-import {
-  buildCapCallFn,
-  type CapCallFnLocalChild,
-  type CapCallFnResolver,
-} from './cap-call-fn.js'
+import { buildCapCallFn, type CapCallFnLocalChild, type CapCallFnResolver } from './cap-call-fn.js'
 
 /**
  * buildCapCallFn — the per-(cap,node) dispatcher behind every CapabilityRegistry
@@ -84,7 +80,10 @@ describe('buildCapCallFn', () => {
 
     expect(result).toEqual({ from: 'uds' })
     expect(child.callCapOnChildCalls).toEqual([
-      { childId: 'benchmark', input: { capName: 'cap-x', method: 'listPages', args: { deviceId: 7 }, deviceId: 7 } },
+      {
+        childId: 'benchmark',
+        input: { capName: 'cap-x', method: 'listPages', args: { deviceId: 7 }, deviceId: 7 },
+      },
     ])
     expect(resolver.resolveCalls).toEqual([]) // resolver never consulted
     expect(legacy).not.toHaveBeenCalled()
@@ -125,8 +124,12 @@ describe('buildCapCallFn', () => {
     const result = await fn('listPages', { deviceId: 3 })
 
     expect(result).toEqual({ from: 'resolver' })
-    expect(resolver.resolveCalls).toEqual([{ capName: 'cap-x', nodeId: 'dev-agent-0', deviceId: 3 }])
-    expect(resolver.dispatchCalls).toEqual([{ route: REMOTE_ROUTE, method: 'listPages', args: { deviceId: 3 } }])
+    expect(resolver.resolveCalls).toEqual([
+      { capName: 'cap-x', nodeId: 'dev-agent-0', deviceId: 3 },
+    ])
+    expect(resolver.dispatchCalls).toEqual([
+      { route: REMOTE_ROUTE, method: 'listPages', args: { deviceId: 3 } },
+    ])
     expect(legacy).not.toHaveBeenCalled()
   })
 
@@ -144,11 +147,15 @@ describe('buildCapCallFn', () => {
 
     await fn('listPages', undefined, 'dev-agent-1')
 
-    expect(resolver.resolveCalls).toEqual([{ capName: 'cap-x', nodeId: 'dev-agent-1', deviceId: undefined }])
+    expect(resolver.resolveCalls).toEqual([
+      { capName: 'cap-x', nodeId: 'dev-agent-1', deviceId: undefined },
+    ])
   })
 
   it('resolver not yet built → falls back to the legacy broker call', async () => {
-    const legacy = vi.fn<(m: string, p: unknown, n: string) => Promise<unknown>>(async () => ({ from: 'legacy' }))
+    const legacy = vi.fn<(m: string, p: unknown, n: string) => Promise<unknown>>(async () => ({
+      from: 'legacy',
+    }))
     const fn = buildCapCallFn({
       capName: 'cap-x',
       nodeId: 'dev-agent-0',

package/src/core/moleculer/cap-call-fn.ts

@@ -44,7 +44,11 @@ export interface CapCallFnDeps {
   /** Live getter for the resolver (`null` before `onModuleInit` builds it). */
   readonly getResolver: () => CapCallFnResolver | null
   /** Legacy Moleculer call — used ONLY in the pre-init window (no resolver yet). */
-  readonly legacyBrokerCall: (method: string, params: unknown, targetNodeId: string) => Promise<unknown>
+  readonly legacyBrokerCall: (
+    method: string,
+    params: unknown,
+    targetNodeId: string,
+  ) => Promise<unknown>
   /** Optional diagnostic hook fired the first time this cap routes over UDS. */
   readonly onUdsRoute?: (capName: string) => void
 }

package/src/core/moleculer/cap-route-authority.ts

@@ -26,14 +26,21 @@ import type { InProcessProviderRef } from '@camstack/kernel'
  * is required. HubNodeRegistry satisfies this interface structurally.
  */
 export interface NodeRegistryLike {
-  getNodeManifest(nodeId: string): readonly { readonly addonId: string; readonly capabilities: readonly string[] }[] | undefined
+  getNodeManifest(
+    nodeId: string,
+  ): readonly { readonly addonId: string; readonly capabilities: readonly string[] }[] | undefined
   listNodeIds(): readonly string[]
   /**
    * Optional: returns flat (nodeId, addonId, capName, deviceId) native-cap tuples.
    * When provided, `nodeKnowsCap` and `isNativeCap` also consult native caps so
    * device-scoped native caps (ptz, motion-zones, …) are visible to the resolver.
    */
-  listNativeCapEntries?(): readonly { readonly nodeId: string; readonly addonId: string; readonly capName: string; readonly deviceId: number }[]
+  listNativeCapEntries?(): readonly {
+    readonly nodeId: string
+    readonly addonId: string
+    readonly capName: string
+    readonly deviceId: number
+  }[]
 }
 
 // ---------------------------------------------------------------------------
@@ -87,7 +94,10 @@ export function createNodeCapAuthority(
     nodeKnowsCap(nodeId: string, capName: string): boolean {
       // Check system (manifest) caps first
       const manifest = nodeRegistry.getNodeManifest(nodeId)
-      if (manifest !== undefined && manifest.some((addon) => addon.capabilities.includes(capName))) {
+      if (
+        manifest !== undefined &&
+        manifest.some((addon) => addon.capabilities.includes(capName))
+      ) {
         return true
       }
       // Also check device-scoped native caps — these are NOT in the addon manifest
@@ -139,7 +149,9 @@ export function createNodeCapAuthority(
     isNativeCap(nodeId: string, capName: string, deviceId?: number): boolean {
       const nativeEntries = nodeRegistry.listNativeCapEntries?.() ?? []
       if (deviceId !== undefined) {
-        return nativeEntries.some((n) => n.nodeId === nodeId && n.capName === capName && n.deviceId === deviceId)
+        return nativeEntries.some(
+          (n) => n.nodeId === nodeId && n.capName === capName && n.deviceId === deviceId,
+        )
       }
       return nativeEntries.some((n) => n.nodeId === nodeId && n.capName === capName)
     },
@@ -163,8 +175,8 @@ export function createInProcessProviderLookup(
 ): InProcessProviderLookup {
   return (capName: string): InProcessProviderRef | null => {
     const provider =
-      capabilityService.getSingletonForNode?.(capName, 'hub')
-      ?? capabilityService.getSingleton(capName)
+      capabilityService.getSingletonForNode?.(capName, 'hub') ??
+      capabilityService.getSingleton(capName)
     if (provider === null || provider === undefined) return null
 
     const ref: InProcessProviderRef = {

package/src/core/moleculer/moleculer.service.ts

@@ -16,8 +16,37 @@ interface BrokerLike {
   call(action: string, params?: unknown, opts?: unknown): Promise<unknown>
   waitForServices(services: string[], timeout?: number): Promise<unknown>
 }
-import { createBroker, createHubService, createProcessService, isInfraCapability, registerEventBusService, createReadinessServiceForRegistry, createStreamProbeBrokerService, createHwAccelService, createKernelHwAccel, HubNodeRegistry, serializeTypedArrays, callWithServiceDiscovery, hashClusterSecret, LocalChildRegistry, createLocalTransport, localEndpointPath, CapRouteResolver, CapRouteError, capActionName, udsChildLogToWorkerEntry, createUdsEventBridge, createParentUnownedCallHandler } from '@camstack/kernel'
-import type { HubServiceDeps, CallFn, RegisterNodeParams, RegisteredAddonManifest, ChildCapDescriptor } from '@camstack/kernel'
+import {
+  createBroker,
+  createHubService,
+  createProcessService,
+  isInfraCapability,
+  registerEventBusService,
+  createReadinessServiceForRegistry,
+  createStreamProbeBrokerService,
+  createHwAccelService,
+  createKernelHwAccel,
+  HubNodeRegistry,
+  serializeTypedArrays,
+  callWithServiceDiscovery,
+  hashClusterSecret,
+  LocalChildRegistry,
+  createLocalTransport,
+  localEndpointPath,
+  CapRouteResolver,
+  CapRouteError,
+  capActionName,
+  udsChildLogToWorkerEntry,
+  createUdsEventBridge,
+  createParentUnownedCallHandler,
+} from '@camstack/kernel'
+import type {
+  HubServiceDeps,
+  CallFn,
+  RegisterNodeParams,
+  RegisteredAddonManifest,
+  ChildCapDescriptor,
+} from '@camstack/kernel'
 import { buildCapCallFn } from './cap-call-fn.js'
 import { createNodeCapAuthority, createInProcessProviderLookup } from './cap-route-authority.js'
 import { EventCategory, expandCapMethods, ReadinessRegistry, emitReadiness } from '@camstack/types'
@@ -55,7 +84,9 @@ interface AppliedCapEntry {
 export class MoleculerService {
   readonly broker: ServiceBroker
   /** Narrow-typed view of `this.broker` — see `BrokerLike` doc above. */
-  private get brokerSafe(): BrokerLike { return this.broker as unknown as BrokerLike }
+  private get brokerSafe(): BrokerLike {
+    return this.broker as unknown as BrokerLike
+  }
   private readonly logger: ReturnType<LoggingService['createLogger']>
   /**
    * D3 authority: union of every node's manifest delivered via
@@ -148,7 +179,8 @@ export class MoleculerService {
     // moleculer→eventemitter2 whose types are unresolvable at this
     // boundary, so the inference falls to `error` and trips
     // `no-unsafe-assignment`. Going via `unknown` documents the boundary.
-    this.clusterSecret = process.env['CAMSTACK_CLUSTER_SECRET'] ?? this.config.get<string>('cluster.secret')
+    this.clusterSecret =
+      process.env['CAMSTACK_CLUSTER_SECRET'] ?? this.config.get<string>('cluster.secret')
     const broker = createBroker({
       nodeID: 'hub',
       mode: 'hub',
@@ -226,7 +258,9 @@ export class MoleculerService {
       onUnregisterNode: (nodeId) => {
         this.removeNodeFromRegistry(nodeId)
       },
-      expectedClusterSecretHash: this.clusterSecret ? hashClusterSecret(this.clusterSecret) : undefined,
+      expectedClusterSecretHash: this.clusterSecret
+        ? hashClusterSecret(this.clusterSecret)
+        : undefined,
     }
 
     const hubService: unknown = createHubService(hubDeps)
@@ -257,16 +291,55 @@ export class MoleculerService {
         getResolver: () => this.resolver,
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- moleculer types unresolvable; see `broker` getter docstring
         broker: this.broker,
+        // Single capability authority — lets the broker fallback pin a
+        // device-scoped call to its owning node instead of load-balancing it.
+        nodeRegistry: this.nodeRegistry,
+        // Hub-local UDS child dispatcher — routes a device-scoped native cap
+        // owned by a hub-local child (reolink/hikvision cameras) directly over
+        // UDS before any broker fallback. Getter: `this.localChildRegistry` is
+        // assigned later in this method, after the handler is constructed.
+        getLocalDispatcher: () => this.localChildRegistry,
+        // Device-native signal for the registration-race recovery: a forked
+        // child's device-native cap (e.g. `switch` on an export target) can be
+        // briefly absent from the LocalChildRegistry just after a respawn. The
+        // kernel layer has no cap registry, so feed it the `deviceNative` flag
+        // from the cap definition. When true + binding-not-yet-registered, the
+        // handler retries the hub-local route then throws a precise error rather
+        // than the unroutable broker fallback (`switch.switch.getStatus`).
+        isDeviceNativeCap: (capName) =>
+          this.capabilityService.getRegistry()?.getDefinition(capName)?.deviceNative === true,
         logger: {
-          warn: (msg, meta) => logger.warn(msg, meta !== null && meta !== undefined ? { meta: meta as Record<string, unknown> } : undefined),
+          warn: (msg, meta) =>
+            logger.warn(
+              msg,
+              meta !== null && meta !== undefined
+                ? { meta: meta as Record<string, unknown> }
+                : undefined,
+            ),
         },
       })
       const registry = new LocalChildRegistry({
         server: createLocalTransport().createServer(nodeId),
         onUnownedCall,
         logger: {
-          info: (msg, meta) => logger.info(msg, meta !== null && meta !== undefined ? { meta: meta as Record<string, unknown> } : undefined),
+          info: (msg, meta) =>
+            logger.info(
+              msg,
+              meta !== null && meta !== undefined
+                ? { meta: meta as Record<string, unknown> }
+                : undefined,
+            ),
         },
+        // Hand the UDS-routing layer a view into the operator's
+        // active-singleton preference. Without this, when two local
+        // children own the same singleton cap (e.g. two `webrtc-session`
+        // providers), routing returns
+        // the first-registered child by insertion order — silently
+        // bypassing `setActiveSingleton`. The closure reads the live
+        // registry on every call so a runtime swap takes effect
+        // immediately without rebuilding the resolver snapshot.
+        getActiveSingletonAddonId: (capName: string): string | null =>
+          this.capabilityService.getRegistry()?.getSingletonAddonId(capName) ?? null,
       })
       await registry.start()
       // E1: apply child manifest + cleanup from the UDS lifecycle (hub-local children).
@@ -309,10 +382,18 @@ export class MoleculerService {
       parentUdsPath = localEndpointPath(nodeId)
       logger.info('UDS child registry listening', { meta: { path: parentUdsPath } })
     } catch (err) {
-      logger.warn('UDS child registry failed to start; children stay broker-only', { meta: { err: err instanceof Error ? err.message : String(err) } })
+      logger.warn('UDS child registry failed to start; children stay broker-only', {
+        meta: { err: err instanceof Error ? err.message : String(err) },
+      })
     }
 
-    const processService: unknown = createProcessService(this.brokerSafe.nodeID, dataDir, undefined, undefined, parentUdsPath)
+    const processService: unknown = createProcessService(
+      this.brokerSafe.nodeID,
+      dataDir,
+      undefined,
+      undefined,
+      parentUdsPath,
+    )
     this.brokerSafe.createService(processService)
 
     // $addonHost — REMOVED (Sprint 6). Three-level settings are now
@@ -345,10 +426,12 @@ export class MoleculerService {
     // workers). Keeps ffprobe + HTTP-reachability as a single
     // hub-side implementation; see `createStreamProbeBrokerService`
     // for the shape.
-    this.brokerSafe.createService(createStreamProbeBrokerService({
-      probe: (url, options) => this.streamProbe.probe(url, options),
-      probeField: (key, value) => this.streamProbe.probeField(key, value),
-    }))
+    this.brokerSafe.createService(
+      createStreamProbeBrokerService({
+        probe: (url, options) => this.streamProbe.probe(url, options),
+        probeField: (key, value) => this.streamProbe.probeField(key, value),
+      }),
+    )
 
     // Register `$hwaccel` on hub — every node in the cluster does the
     // same so `broker.call('$hwaccel.resolve', params, { nodeID })`
@@ -372,7 +455,8 @@ export class MoleculerService {
       hubLocalRegistry: this.localChildRegistry,
       nodeAuthority: createNodeCapAuthority(this.nodeRegistry, {
         resolveSingleton: (capName, nodeId) =>
-          this.capabilityService.getRegistry()?.resolveSingletonAddonIdForNode(capName, nodeId) ?? null,
+          this.capabilityService.getRegistry()?.resolveSingletonAddonIdForNode(capName, nodeId) ??
+          null,
       }),
       inProcessProviders: createInProcessProviderLookup(this.capabilityService),
     })
@@ -485,12 +569,16 @@ export class MoleculerService {
       // the legacy callFn store. The deviceId hint is a number extracted from the method args.
       const rawDeviceId: unknown =
         params !== null && typeof params === 'object' ? Reflect.get(params, 'deviceId') : undefined
-      const routeDeviceId: number | undefined = typeof rawDeviceId === 'number' ? rawDeviceId : undefined
+      const routeDeviceId: number | undefined =
+        typeof rawDeviceId === 'number' ? rawDeviceId : undefined
       try {
         const route = resolver.resolveCapRoute(capabilityName, { nodeId, deviceId: routeDeviceId })
         return await resolver.dispatch(route, methodName, params)
       } catch (err) {
-        if (err instanceof CapRouteError && (err.reason === 'no-provider' || err.reason === 'node-offline')) {
+        if (
+          err instanceof CapRouteError &&
+          (err.reason === 'no-provider' || err.reason === 'node-offline')
+        ) {
           // Resolver couldn't find the cap — try the legacy callFn store as a
           // fallback. This covers caps registered in nodeCallFns (e.g. agent
           // nodes that registered before the resolver's snapshot was built or
@@ -516,7 +604,8 @@ export class MoleculerService {
       const provider = registry?.getSingleton<Record<string, unknown>>(capabilityName) ?? null
       if (provider !== null) {
         const fn = provider[methodName]
-        if (typeof fn !== 'function') throw new Error(`Method "${methodName}" not found on "${capabilityName}"`)
+        if (typeof fn !== 'function')
+          throw new Error(`Method "${methodName}" not found on "${capabilityName}"`)
         return fn.call(provider, params)
       }
     }
@@ -529,7 +618,9 @@ export class MoleculerService {
     throw new CapRouteError(capabilityName, methodName, {
       reason: 'no-provider',
       nodeId,
-      rejected: [{ kind: 'hub-in-process', why: 'CapRouteResolver not initialised (pre-onModuleInit)' }],
+      rejected: [
+        { kind: 'hub-in-process', why: 'CapRouteResolver not initialised (pre-onModuleInit)' },
+      ],
     })
   }
 
@@ -578,7 +669,10 @@ export class MoleculerService {
    * already; this method handles only `params.addons` (system caps).
    * Native-cap wiring into device-manager is done in a later task.
    */
-  private applyNodeManifest(params: RegisterNodeParams, previousManifest?: readonly RegisteredAddonManifest[]): void {
+  private applyNodeManifest(
+    params: RegisterNodeParams,
+    previousManifest?: readonly RegisteredAddonManifest[],
+  ): void {
     const { nodeId, addons } = params
     const hubNodeId = this.brokerSafe.nodeID
     const isLocalChild = nodeId.startsWith(hubNodeId + '/')
@@ -604,7 +698,9 @@ export class MoleculerService {
     // what is (or would have been) registered. Keyed `${registryKey}::${capName}`.
     // The resolved `capDef` is carried through so the register loop never
     // re-looks it up (and never needs a non-null assertion).
-    const appliedKeys = (manifest: readonly RegisteredAddonManifest[]): Map<string, AppliedCapEntry> => {
+    const appliedKeys = (
+      manifest: readonly RegisteredAddonManifest[],
+    ): Map<string, AppliedCapEntry> => {
       const keys = new Map<string, AppliedCapEntry>()
       for (const addon of manifest) {
         const registryKey = registryKeyFor(addon.addonId)
@@ -736,7 +832,7 @@ export class MoleculerService {
    */
   private removeNodeFromRegistry(nodeId: string): void {
     const manifest = this.nodeRegistry.getNodeManifest(nodeId)
-    if (!manifest) return  // node never sent a handshake — nothing to do
+    if (!manifest) return // node never sent a handshake — nothing to do
 
     const hubNodeId = this.brokerSafe.nodeID
     const isLocalChild = nodeId.startsWith(hubNodeId + '/')
@@ -802,7 +898,6 @@ export class MoleculerService {
     return undefined
   }
 
-
   /**
    * Returns true when a (nodeId, capabilityName) pair is reachable via the
    * legacy fallback paths: either a stored callFn in nodeCallFns, or a
@@ -831,7 +926,10 @@ export class MoleculerService {
    * built unconditionally for hub-local children so `callCapabilityOnNode` can
    * route the actual method call via the resolver's hub-local-uds branch.
    */
-  createCapabilityProxy(capabilityName: string, nodeId: string): Record<string, (params: unknown) => Promise<unknown>> | null {
+  createCapabilityProxy(
+    capabilityName: string,
+    nodeId: string,
+  ): Record<string, (params: unknown) => Promise<unknown>> | null {
     const resolver = this.resolver
     if (resolver !== null) {
       // Use the resolver to determine reachability. If it resolves a route, we
@@ -842,7 +940,10 @@ export class MoleculerService {
         resolver.resolveCapRoute(capabilityName, { nodeId })
         // Resolver found a route — proxy is reachable.
       } catch (err) {
-        if (err instanceof CapRouteError && (err.reason === 'no-provider' || err.reason === 'node-offline')) {
+        if (
+          err instanceof CapRouteError &&
+          (err.reason === 'no-provider' || err.reason === 'node-offline')
+        ) {
           // Check legacy callFn store and hub-local child fallbacks.
           if (!this.isReachableViaLegacy(nodeId, capabilityName)) return null
           // Proxy reachable via fallback paths — fall through to build it.
@@ -857,12 +958,15 @@ export class MoleculerService {
 
     // Build a dynamic proxy: every property access returns a function that
     // routes the call through callCapabilityOnNode (which delegates to the resolver).
-    return new Proxy<Record<string, (params: unknown) => Promise<unknown>>>({}, {
-      get: (_target, methodName: string) => {
-        return (params: unknown): Promise<unknown> =>
-          this.callCapabilityOnNode(nodeId, capabilityName, methodName, params)
+    return new Proxy<Record<string, (params: unknown) => Promise<unknown>>>(
+      {},
+      {
+        get: (_target, methodName: string) => {
+          return (params: unknown): Promise<unknown> =>
+            this.callCapabilityOnNode(nodeId, capabilityName, methodName, params)
+        },
       },
-    })
+    )
   }
 
   /**
@@ -880,6 +984,18 @@ export class MoleculerService {
     return this.nodeRegistry.listNativeCapEntries()
   }
 
+  /**
+   * Per-device slice of {@link listClusterNativeCaps}, served from the
+   * registry's `deviceId → entries` index — O(caps-for-device). Used by the
+   * per-device `getBindings` hot path so `getAllBindings` doesn't flatten the
+   * whole cluster once per device.
+   */
+  listClusterNativeCapsForDevice(
+    deviceId: number,
+  ): readonly import('@camstack/kernel').NodeNativeCapEntry[] {
+    return this.nodeRegistry.listNativeCapEntriesForDevice(deviceId)
+  }
+
   /**
    * E2: Send a `set-log-level` UDS message to a hub-local child identified by
    * `nodeId` (e.g. `hub/provider-reolink`). Extracts the `childId` from the

package/src/core/network/network-quality.service.spec.ts

@@ -32,10 +32,16 @@ describe('NetworkQualityService', () => {
   })
 
   it('should track client stats', () => {
-    service.reportClientStats(1, { rttMs: 50, jitterMs: 5, estimatedBandwidthKbps: 20000 })
+    service.reportClientStats(1, {
+      rttMs: 50,
+      jitterMs: 5,
+      estimatedBandwidthKbps: 20000,
+      packetLossPercent: 3,
+    })
     const stats = service.getDeviceStats(1)
     expect(stats!.client?.rttMs).toBe(50)
     expect(stats!.client?.estimatedBandwidthKbps).toBe(20000)
+    expect(stats!.client?.packetLossPercent).toBe(3)
   })
 
   it('should list all device stats', () => {

package/src/core/notification/notification-wrapper.service.ts

@@ -19,9 +19,7 @@ export class NotificationServiceWrapper {
 
   get service(): NotificationService {
     if (!this._service) {
-      this._service = new NotificationService(
-        this.logging.createLogger('notifications'),
-      )
+      this._service = new NotificationService(this.logging.createLogger('notifications'))
       const registry = this.caps.getRegistry()
       if (registry) {
         this._service.setRegistry(registry)

package/src/core/notification/toast-wrapper.service.ts

@@ -21,11 +21,7 @@ export class ToastServiceWrapper {
     this._service.sendToUser(userId, toast)
   }
 
-  subscribe(
-    connectionId: string,
-    userId: string,
-    callback: (toast: Toast) => void,
-  ): () => void {
+  subscribe(connectionId: string, userId: string, callback: (toast: Toast) => void): () => void {
     return this._service.subscribe(connectionId, userId, callback)
   }
 }