@camstack/server 1.0.0 → 1.0.1

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

@@ -1,143 +0,0 @@
-import { LogManager } from '@camstack/core'
-import type { IScopedLogger, LogTags } from '@camstack/types'
-import { EventCategory } from '@camstack/types'
-import { ConfigService } from '../config/config.service'
-import type { EventBusService } from '../events/event-bus.service'
-
-/** Baseline tags every hub-local logger gets, so console output never
- *  falls back to `?` for the agent slot. Hub-local addons already
- *  re-tag with their addonId; this ensures non-addon scopes (core
- *  services like `AddonRegistry`, `StreamProbeService`, `moleculer`)
- *  render as `hub` in the agent column.
- *
- *  `pid` is the hub renderer's own OS pid. Entries forwarded from
- *  forked workers via `$hub.log` carry their own `tags.pid` which
- *  wins over this baseline (right-biased merge in `writeFromWorker`). */
-const HUB_BASELINE_TAGS: LogTags = { agentId: 'hub', nodeId: 'hub', pid: process.pid }
-
-export class LoggingService extends LogManager {
-  /**
-   * Device-name cache consulted by the formatter when a log line
-   * carries `tags.deviceId` but no explicit `deviceName`. Populated
-   * by `setDeviceNames` whenever device-manager emits registered /
-   * updated / removed events. Missing entries fall back to `#<id>`.
-   */
-  private readonly deviceNames = new Map<number, string>()
-
-  constructor(configService: ConfigService) {
-    // 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
-    // happens upstream of their formatters.
-    this.setDeviceNameLookup((id) => this.deviceNames.get(id) ?? null)
-  }
-
-  /** Bulk-refresh from device-manager snapshot. Replaces every entry. */
-  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
-      ) {
-        this.deviceNames.set(id, name)
-      }
-    }
-  }
-
-  /** Incremental update — called from DeviceRegistered / DeviceUpdated. */
-  upsertDeviceName(id: number, name: string | undefined): void {
-    if (!Number.isFinite(id)) return
-    if (typeof name === 'string' && name.length > 0) this.deviceNames.set(id, name)
-    else this.deviceNames.delete(id)
-  }
-
-  /** Drop on DeviceRemoved. */
-  removeDeviceName(id: number): void {
-    this.deviceNames.delete(id)
-  }
-
-  /**
-   * Subscribe to `device.*` events so the cache stays live: every
-   * DeviceRegistered / updated emit carries `{deviceId, name}` — we
-   * upsert, and DeviceUnregistered clears. Call once at boot.
-   */
-  attachDeviceNameStream(eventBus: EventBusService): void {
-    const selfLogger = this.createLogger('logging').withTags({ addonId: 'logging' })
-    eventBus.subscribe({ category: EventCategory.DeviceRegistered }, (event) => {
-      const data = event.data as { deviceId?: number; name?: string } | undefined
-      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,
-          },
-        })
-      }
-    })
-    eventBus.subscribe({ category: EventCategory.DeviceUnregistered }, (event) => {
-      const data = event.data as { deviceId?: number } | undefined
-      if (data && typeof data.deviceId === 'number') this.removeDeviceName(data.deviceId)
-    })
-  }
-
-  /**
-   * Override — every logger created hub-side comes pre-tagged with
-   * `agentId: 'hub'`. Callers that need per-addon identity chain
-   * `.withTags({ addonId })` on top (the merge is right-biased, so
-   * the explicit tag wins).
-   */
-  override createLogger(scope?: string): IScopedLogger {
-    return super.createLogger(scope).withTags(HUB_BASELINE_TAGS)
-  }
-
-  /**
-   * Write a log entry received from a forked worker / remote agent.
-   * Called by the `$hub.log` action and `log-receiver.ingest` action.
-   *
-   * Tags propagated by the worker (including `deviceId`, `deviceName`,
-   * `integrationId`, `streamId`, etc.) are preserved via `withTags`;
-   * baseline tags (`addonId`, `nodeId`, `agentId`) are always ensured
-   * even if the worker didn't set them explicitly.
-   */
-  writeFromWorker(entry: {
-    addonId: string
-    nodeId?: string
-    level: string
-    message: string
-    scope?: string
-    tags?: LogTags
-    meta?: Record<string, unknown>
-  }): void {
-    // Scope is a single optional sub-component label; addon/node identity
-    // lives in tags, not in scope. Pass through whatever the worker set.
-    let logger = this.createLogger(entry.scope)
-    const nodeId = entry.nodeId
-    const agentId = nodeId?.includes('/') ? nodeId.split('/')[0]! : nodeId
-    const mergedTags: LogTags = {
-      ...entry.tags,
-      addonId: entry.addonId,
-      ...(nodeId !== undefined ? { nodeId } : {}),
-      ...(agentId !== undefined ? { agentId } : {}),
-    }
-    logger = logger.withTags(mergedTags)
-    const level = entry.level as 'info' | 'warn' | 'error' | 'debug'
-    const extras = entry.meta !== undefined ? { meta: entry.meta } : undefined
-    if (typeof logger[level] === 'function') {
-      logger[level](entry.message, extras)
-    } else {
-      logger.info(entry.message, extras)
-    }
-  }
-}

package/src/core/logging/scoped-logger.ts

@@ -1,3 +0,0 @@
-// Re-export from @camstack/core
-export { ScopedLogger } from '@camstack/core'
-export type { IScopedLogger } from '@camstack/core'

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

@@ -1,173 +0,0 @@
-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'
-
-/**
- * buildCapCallFn — the per-(cap,node) dispatcher behind every CapabilityRegistry
- * provider proxy. These specs lock every routing branch so the UDS-migration
- * gap (an agent-hosted provider's cap call falling onto a `broker.call` to a
- * Moleculer node that does not exist → 30s `waitForServices` timeout) cannot
- * regress:
- *   - hub-local child that provides → per-child UDS (collection-safe)
- *   - hub-local child that does NOT provide → fail fast (NEVER Moleculer)
- *   - agent-hosted / remote → delegate to the unified CapRouteResolver
- *   - resolver not built yet → legacy broker fallback
- */
-
-const REMOTE_ROUTE: CapRoute = { kind: 'remote-moleculer', capName: 'cap-x', nodeId: 'dev-agent-0' }
-
-function recordingLocalChild(provides: boolean): {
-  fake: CapCallFnLocalChild
-  childProvidesCalls: Array<{ childId: string; capName: string; deviceId?: number }>
-  callCapOnChildCalls: Array<{ childId: string; input: CapCallInput }>
-} {
-  const childProvidesCalls: Array<{ childId: string; capName: string; deviceId?: number }> = []
-  const callCapOnChildCalls: Array<{ childId: string; input: CapCallInput }> = []
-  return {
-    childProvidesCalls,
-    callCapOnChildCalls,
-    fake: {
-      childProvides: (childId, capName, deviceId) => {
-        childProvidesCalls.push({ childId, capName, deviceId })
-        return provides
-      },
-      callCapOnChild: async (childId, input) => {
-        callCapOnChildCalls.push({ childId, input })
-        return { from: 'uds' }
-      },
-    },
-  }
-}
-
-function recordingResolver(): {
-  fake: CapCallFnResolver
-  resolveCalls: Array<{ capName: string; nodeId?: string; deviceId?: number }>
-  dispatchCalls: Array<{ route: CapRoute; method: string; args: unknown }>
-} {
-  const resolveCalls: Array<{ capName: string; nodeId?: string; deviceId?: number }> = []
-  const dispatchCalls: Array<{ route: CapRoute; method: string; args: unknown }> = []
-  return {
-    resolveCalls,
-    dispatchCalls,
-    fake: {
-      resolveCapRoute: (capName, opts) => {
-        resolveCalls.push({ capName, nodeId: opts.nodeId, deviceId: opts.deviceId })
-        return REMOTE_ROUTE
-      },
-      dispatch: async (route, method, args) => {
-        dispatchCalls.push({ route, method, args })
-        return { from: 'resolver' }
-      },
-    },
-  }
-}
-
-describe('buildCapCallFn', () => {
-  it('hub-local child that provides the cap → routes per-child over UDS', async () => {
-    const child = recordingLocalChild(true)
-    const resolver = recordingResolver()
-    const legacy = vi.fn<(m: string, p: unknown, n: string) => Promise<unknown>>()
-    const fn = buildCapCallFn({
-      capName: 'cap-x',
-      nodeId: 'hub/benchmark',
-      udsChildId: 'benchmark',
-      getLocalChildRegistry: () => child.fake,
-      getResolver: () => resolver.fake,
-      legacyBrokerCall: legacy,
-    })
-
-    const result = await fn('listPages', { deviceId: 7 })
-
-    expect(result).toEqual({ from: 'uds' })
-    expect(child.callCapOnChildCalls).toEqual([
-      {
-        childId: 'benchmark',
-        input: { capName: 'cap-x', method: 'listPages', args: { deviceId: 7 }, deviceId: 7 },
-      },
-    ])
-    expect(resolver.resolveCalls).toEqual([]) // resolver never consulted
-    expect(legacy).not.toHaveBeenCalled()
-  })
-
-  it('hub-local child that does NOT provide → fails fast, never touches Moleculer', async () => {
-    const child = recordingLocalChild(false)
-    const resolver = recordingResolver()
-    const legacy = vi.fn<(m: string, p: unknown, n: string) => Promise<unknown>>()
-    const fn = buildCapCallFn({
-      capName: 'cap-x',
-      nodeId: 'hub/benchmark',
-      udsChildId: 'benchmark',
-      getLocalChildRegistry: () => child.fake,
-      getResolver: () => resolver.fake,
-      legacyBrokerCall: legacy,
-    })
-
-    await expect(fn('listPages', undefined)).rejects.toThrow(/does not currently provide/)
-    expect(child.callCapOnChildCalls).toEqual([])
-    expect(resolver.resolveCalls).toEqual([])
-    expect(resolver.dispatchCalls).toEqual([])
-    expect(legacy).not.toHaveBeenCalled()
-  })
-
-  it('agent-hosted provider → delegates to the resolver (agent-child-forward)', async () => {
-    const resolver = recordingResolver()
-    const legacy = vi.fn<(m: string, p: unknown, n: string) => Promise<unknown>>()
-    const fn = buildCapCallFn({
-      capName: 'cap-x',
-      nodeId: 'dev-agent-0',
-      udsChildId: null, // not hub-local
-      getLocalChildRegistry: () => null,
-      getResolver: () => resolver.fake,
-      legacyBrokerCall: legacy,
-    })
-
-    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(legacy).not.toHaveBeenCalled()
-  })
-
-  it('explicit targetNodeId overrides the registered nodeId in resolution', async () => {
-    const resolver = recordingResolver()
-    const legacy = vi.fn<(m: string, p: unknown, n: string) => Promise<unknown>>()
-    const fn = buildCapCallFn({
-      capName: 'cap-x',
-      nodeId: 'dev-agent-0',
-      udsChildId: null,
-      getLocalChildRegistry: () => null,
-      getResolver: () => resolver.fake,
-      legacyBrokerCall: legacy,
-    })
-
-    await fn('listPages', undefined, 'dev-agent-1')
-
-    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 fn = buildCapCallFn({
-      capName: 'cap-x',
-      nodeId: 'dev-agent-0',
-      udsChildId: null,
-      getLocalChildRegistry: () => null,
-      getResolver: () => null, // pre-init window
-      legacyBrokerCall: legacy,
-    })
-
-    const result = await fn('listPages', { deviceId: 1 })
-
-    expect(result).toEqual({ from: 'legacy' })
-    expect(legacy).toHaveBeenCalledWith('listPages', { deviceId: 1 }, 'dev-agent-0')
-  })
-})

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

@@ -1,107 +0,0 @@
-/**
- * cap-call-fn — the per-(cap, node) dispatcher behind every CapabilityRegistry
- * provider proxy the hub builds in `applyNodeManifest`.
- *
- * Extracted from `MoleculerService` so its routing branches are unit-testable
- * in isolation (the closure that lived inline could only be exercised by
- * standing up a full broker). It closes a UDS-migration gap: the inline
- * version hand-rolled a `broker.call` for any non-hub-local provider, so an
- * AGENT-hosted addon cap (a UDS child of the agent, NOT a Moleculer service)
- * resolved to a Moleculer node that does not exist → `waitForServices` waited
- * its full 30s discovery timeout → "Services waiting is timed out". The fix
- * routes everything that isn't a hub-local child through the unified
- * `CapRouteResolver`, which classifies an agent node as `agent-child-forward`
- * (hub → agent over Moleculer → agent's UDS child) and a direct remote as
- * `remote-moleculer`.
- */
-import type { CallFn, CapRoute, CapRouteOpts, CapCallInput } from '@camstack/kernel'
-
-/** Minimal LocalChildRegistry surface this dispatcher needs (per-child UDS). */
-export interface CapCallFnLocalChild {
-  childProvides(childId: string, capName: string, deviceId?: number): boolean
-  callCapOnChild(childId: string, input: CapCallInput): Promise<unknown>
-}
-
-/** Minimal CapRouteResolver surface this dispatcher needs. */
-export interface CapCallFnResolver {
-  resolveCapRoute(capName: string, opts: CapRouteOpts): CapRoute
-  dispatch(route: CapRoute, method: string, args: unknown): Promise<unknown>
-}
-
-export interface CapCallFnDeps {
-  /** The capability this dispatcher routes. */
-  readonly capName: string
-  /** The registering node's id (the agent node for agent-hosted providers). */
-  readonly nodeId: string
-  /**
-   * Runner id of the hub-local UDS child that owns this provider, or `null`
-   * for agent-hosted / remote providers. Only hub-local children are reachable
-   * over UDS.
-   */
-  readonly udsChildId: string | null
-  /** Live getter for the UDS child registry (`null` if the UDS server is down). */
-  readonly getLocalChildRegistry: () => CapCallFnLocalChild | null
-  /** 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>
-  /** Optional diagnostic hook fired the first time this cap routes over UDS. */
-  readonly onUdsRoute?: (capName: string) => void
-}
-
-/** Extract a numeric `deviceId` routing hint out of arbitrary method args. */
-function extractDeviceId(params: unknown): number | undefined {
-  if (params === null || typeof params !== 'object') return undefined
-  const raw: unknown = Reflect.get(params, 'deviceId')
-  return typeof raw === 'number' ? raw : undefined
-}
-
-/**
- * Build the `CallFn` (`(method, params, targetNodeId?) => Promise`) for one
- * registered provider. See module docs for the routing rationale.
- */
-export function buildCapCallFn(deps: CapCallFnDeps): CallFn {
-  return async (method: string, params: unknown, targetNodeId?: string): Promise<unknown> => {
-    const deviceId = extractDeviceId(params)
-
-    // ── Hub-local child: route per-child over UDS (collection-safe — keyed by
-    //    the specific child, not by capName which would collapse a collection
-    //    cap onto the first child). NEVER fall back to Moleculer: a hub-local
-    //    child is not a Moleculer service, so a broker call would wait the full
-    //    discovery timeout for a node that never appears. If the child isn't
-    //    currently providing the cap, fail fast.
-    if (deps.udsChildId !== null && targetNodeId === undefined) {
-      const registry = deps.getLocalChildRegistry()
-      if (registry !== null && registry.childProvides(deps.udsChildId, deps.capName, deviceId)) {
-        deps.onUdsRoute?.(deps.capName)
-        const input: CapCallInput = {
-          capName: deps.capName,
-          method,
-          args: params,
-          ...(deviceId !== undefined ? { deviceId } : {}),
-        }
-        return registry.callCapOnChild(deps.udsChildId, input)
-      }
-      throw new Error(
-        `hub-local child "${deps.udsChildId}" does not currently provide cap "${deps.capName}"`,
-      )
-    }
-
-    // ── Agent-hosted or explicit remote: delegate to the unified resolver.
-    const resolver = deps.getResolver()
-    if (resolver !== null) {
-      const route = resolver.resolveCapRoute(deps.capName, {
-        nodeId: targetNodeId ?? deps.nodeId,
-        ...(deviceId !== undefined ? { deviceId } : {}),
-      })
-      return resolver.dispatch(route, method, params)
-    }
-
-    // ── Pre-init window (resolver not yet constructed): legacy Moleculer call.
-    return deps.legacyBrokerCall(method, params, targetNodeId ?? deps.nodeId)
-  }
-}

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

@@ -1,194 +0,0 @@
-/**
- * Adapter factories that bridge the server-side registry/service state into the
- * narrow interfaces that CapRouteResolver (in @camstack/kernel) requires.
- *
- * Layer note: this file is in server/backend and may import server-side types.
- * The resolver itself (in @camstack/kernel) must NOT import from here —
- * it depends only on the narrow interfaces (NodeCapAuthority, InProcessProviderLookup)
- * defined in the kernel. These factories are the wiring adapters.
- *
- * nodeIsAgent format rule (from agent-registry.service.ts:74-77):
- *   hub         → 'hub'  → not an agent
- *   hub child   → 'hub/<runnerId>' → not an agent
- *   agent       → bare id with no '/' → agent
- */
-
-import type { NodeCapAuthority, InProcessProviderLookup } from '@camstack/kernel'
-import type { InProcessProviderRef } from '@camstack/kernel'
-
-// ---------------------------------------------------------------------------
-// Minimal interface for the HubNodeRegistry dependency
-// ---------------------------------------------------------------------------
-
-/**
- * Minimal view of HubNodeRegistry that this adapter needs.
- * Keeps the adapter decoupled from the concrete class — only structural match
- * is required. HubNodeRegistry satisfies this interface structurally.
- */
-export interface NodeRegistryLike {
-  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
-  }[]
-}
-
-// ---------------------------------------------------------------------------
-// Minimal interface for the CapabilityService dependency
-// ---------------------------------------------------------------------------
-
-/**
- * Minimal view of CapabilityService that the InProcessProviderLookup adapter needs.
- * The real CapabilityService satisfies this interface structurally.
- */
-export interface CapabilityServiceLike {
-  getSingleton(capability: string): Record<string, unknown> | null
-  /** Resolve the hub-local provider honoring the 'hub' per-node override. */
-  getSingletonForNode?(capability: string, nodeId: string): Record<string, unknown> | null
-}
-
-// ---------------------------------------------------------------------------
-// createNodeCapAuthority
-// ---------------------------------------------------------------------------
-
-/**
- * Optional resolver injected into createNodeCapAuthority so that getAddonId
- * can honor per-node singleton overrides and the cluster-global default,
- * constrained to addons the node actually hosts in its manifest.
- */
-export interface SingletonNodeResolver {
-  /** Bare addonId a node should use for a singleton cap (override→default→first), or null. */
-  resolveSingleton(capName: string, nodeId: string): string | null
-}
-
-/**
- * Build a NodeCapAuthority backed by a HubNodeRegistry.
- *
- * nodeIsAgent rule: a node is an agent when its id is not 'hub' and does not
- * contain '/' (hub children are `hub/<runnerId>`; agents are bare ids).
- *
- * nodeOnline: uses registry membership — per CLAUDE.md "the registry is the
- * union of registerNode manifests minus disconnected nodes" because
- * `removeNode` is called on `$node.disconnected`. Registry membership is the
- * cleanest, cast-free liveness check.
- *
- * getAgentChildId: always returns null — the hub cannot resolve which forked
- * child under an agent provides a cap (the agent flattens its subtree into
- * one merged manifest). The agent resolves its own child locally (Task 6).
- */
-export function createNodeCapAuthority(
-  nodeRegistry: NodeRegistryLike,
-  resolver?: SingletonNodeResolver,
-): NodeCapAuthority {
-  return {
-    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))
-      ) {
-        return true
-      }
-      // Also check device-scoped native caps — these are NOT in the addon manifest
-      const nativeEntries = nodeRegistry.listNativeCapEntries?.() ?? []
-      return nativeEntries.some((n) => n.nodeId === nodeId && n.capName === capName)
-    },
-
-    getAddonId(nodeId: string, capName: string): string | null {
-      // Check system (manifest) caps first
-      const manifest = nodeRegistry.getNodeManifest(nodeId)
-      if (manifest !== undefined) {
-        const manifestAddons = manifest
-          .filter((addon) => addon.capabilities.includes(capName))
-          .map((addon) => addon.addonId)
-        if (manifestAddons.length > 0) {
-          // Per-node override / global-default resolution, constrained to what
-          // the node actually hosts. Falls back to the first manifest match.
-          const resolved = resolver?.resolveSingleton(capName, nodeId) ?? null
-          if (resolved !== null && manifestAddons.includes(resolved)) return resolved
-          return manifestAddons[0] ?? null
-        }
-      }
-      // Check device-scoped native caps (unchanged path)
-      const nativeEntries = nodeRegistry.listNativeCapEntries?.() ?? []
-      const nat = nativeEntries.find((n) => n.nodeId === nodeId && n.capName === capName)
-      return nat?.addonId ?? null
-    },
-
-    nodeIsAgent(nodeId: string): boolean {
-      return nodeId !== 'hub' && !nodeId.includes('/')
-    },
-
-    nodeOnline(nodeId: string): boolean {
-      // O(1) Map lookup — registry membership is the authoritative liveness
-      // check: HubNodeRegistry.removeNode is called on $node.disconnected,
-      // so a defined manifest means the node is connected.
-      return nodeRegistry.getNodeManifest(nodeId) !== undefined
-    },
-
-    listNodeIds(): readonly string[] {
-      return nodeRegistry.listNodeIds()
-    },
-
-    getAgentChildId(_agentNodeId: string, _capName: string): string | null {
-      // The hub cannot resolve the agent's child — the agent resolves locally (Task 6).
-      return null
-    },
-
-    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)
-    },
-  }
-}
-
-// ---------------------------------------------------------------------------
-// createInProcessProviderLookup
-// ---------------------------------------------------------------------------
-
-/**
- * Build an InProcessProviderLookup backed by a CapabilityService.
- *
- * Cast-free design: `getSingleton<Record<string, unknown>>` makes the provider
- * indexable without any `as` casts. `typeof fn === 'function'` narrows to
- * Function (implicit `any` return); calling via `fn.call(provider, args)` is
- * then safe and the result is captured as `unknown`. No `as` casts anywhere.
- */
-export function createInProcessProviderLookup(
-  capabilityService: CapabilityServiceLike,
-): InProcessProviderLookup {
-  return (capName: string): InProcessProviderRef | null => {
-    const provider =
-      capabilityService.getSingletonForNode?.(capName, 'hub') ??
-      capabilityService.getSingleton(capName)
-    if (provider === null || provider === undefined) return null
-
-    const ref: InProcessProviderRef = {
-      invoke: (method: string, args: unknown): Promise<unknown> => {
-        const fn = provider[method]
-        if (typeof fn !== 'function') {
-          return Promise.reject(new Error(`method "${method}" not found on cap "${capName}"`))
-        }
-        const result: unknown = fn.call(provider, args)
-        return Promise.resolve(result)
-      },
-    }
-    return ref
-  }
-}