@camstack/server 0.1.5 → 0.1.7

package/src/core/addon/addon-settings-provider.ts

@@ -1,46 +1,30 @@
 /**
  * Hub-side singleton provider for the `addon-settings` capability.
  *
- * Acts as a gateway: resolves `addonId` to the target addon and
- * delegates the settings call. For hub-local addons, calls the
- * addon instance directly. For remote agents, proxies via the
- * per-addon Moleculer service (`<addonId>.settings.<method>`).
- *
- * Replaces the `$addonHost` Moleculer service.
+ * Resolves `addonId` and delegates the settings call. In-process hub builtins
+ * are called directly; every FORKED addon (hub-local child over UDS, or remote
+ * agent over Moleculer) routes through the shared {@link AddonCallGateway} —
+ * the SAME centralised router routes/custom-actions use. Settings used to live
+ * on its own Moleculer-only path here, which is why forked hub-local addons'
+ * panels went empty after the UDS migration; that path is gone.
  */
 import type { ICamstackAddon, ConfigUISchemaWithValues } from '@camstack/types'
 import type { IAddonSettingsProvider } from '@camstack/types'
-
-/**
- * Minimal structural view of the Moleculer broker this provider needs
- * (`call` + `registry`). Typed locally — mirroring the
- * `ReconcileBrokerLike` pattern in `agent-registry.service.ts` —
- * because the lint type-checker cannot resolve Moleculer's
- * `ServiceBroker` type, which left every `broker.*` access `any`-typed.
- */
-interface SettingsBroker {
-  readonly registry: unknown
-  call(
-    action: string,
-    params: Record<string, unknown>,
-    opts?: { readonly nodeID?: string; readonly timeout?: number },
-  ): Promise<unknown>
-}
+import type { AddonSettingsMethod } from '@camstack/kernel'
+import type { AddonCallGateway } from './addon-call-gateway.js'
 
 // ── Dependency interfaces ────────────────────────────────────────────
 
 /** Resolve an addon by id. Returns null if not loaded on this node. */
 type AddonLookup = (addonId: string) => ICamstackAddon | null
 
-/** Resolve which node hosts a given addon. Returns 'hub' for local. */
-type NodeResolver = (addonId: string) => string
-
 // ── Input types (match the cap definition's z.infer) ─────────────────
 
 interface AddonIdInput {
   readonly addonId: string
   readonly nodeId?: string
   readonly overlay?: Record<string, unknown>
+  readonly cap?: string
 }
 
 interface AddonPatchInput {
@@ -121,98 +105,42 @@ function isServiceNotFoundError(err: unknown): boolean {
 // ── Provider factory ─────────────────────────────────────────────────
 
 interface AddonSettingsProviderDeps {
-  /** Look up a loaded addon by id on this hub node. */
+  /** Look up a loaded IN-PROCESS addon by id (the `@camstack/core` builtins). */
   readonly getAddon: AddonLookup
-  /** Resolve which node hosts a given addon. Defaults to 'hub'. */
-  readonly resolveNode: NodeResolver
-  /** Moleculer broker for remote calls. */
-  readonly broker: SettingsBroker
-  /** This hub's node ID (for local short-circuit). */
-  readonly hubNodeId: string
+  /** Shared router for forked addon-level calls (hub-local-child / remote). */
+  readonly gateway: AddonCallGateway
 }
 
 function createAddonSettingsProvider(deps: AddonSettingsProviderDeps): IAddonSettingsProvider {
-  const { getAddon, resolveNode, broker, hubNodeId } = deps
-
-  function isLocal(addonId: string, explicitNodeId?: string): boolean {
-    // `resolveNode` is consulted FIRST: it knows whether the addon
-    // runs in-process on the hub or as a forkable worker. An explicit
-    // `nodeId: 'hub'` from the caller is treated as "target the hub
-    // cluster" — NOT "force local dispatch" — so for forkable addons
-    // we still route via Moleculer to `hub/<addonId>`. Without this
-    // check the hub-side stub (which never had `initialize()` run and
-    // has no `_ctx.settings`) would respond with defaults only and
-    // silently drop every `updateGlobalSettings` patch.
-    const resolved = resolveNode(addonId)
-    if (resolved !== 'hub' && resolved !== hubNodeId) return false
-    const nodeId = explicitNodeId ?? resolved
-    return nodeId === 'hub' || nodeId === hubNodeId
-  }
-
-  // ── Remote call helpers ──────────────────────────────────────────
-
-  // Resolve the Moleculer nodeID that actually hosts an addon's
-  // `<addonId>.settings.*` service. Forkable addons register under
-  // `${baseNodeId}/${addonId}`; in-process addons register under the
-  // base nodeId itself. Walk the Moleculer registry and pick the
-  // first node whose id matches either convention.
-  function resolveWorkerNodeId(addonId: string, baseNodeId: string): string | null {
-    const registry = broker.registry
-    const services = (registry as unknown as {
-      getServiceList: (opts: { onlyAvailable: boolean }) => readonly { name: string; nodeID: string }[]
-    }).getServiceList({ onlyAvailable: true })
-    // Find the node that actually hosts the `<addonId>` service (the
-    // moleculer service factory registers addons under their id). The
-    // baseNodeId is a hint — we trust the registry's ground truth
-    // instead. Forkable addons live at `<parent>/<addonId>`;
-    // in-process addons live at `<parent>`.
-    const exactNode = `${baseNodeId}/${addonId}`
-    const preferred = services.find((s) => s.name === addonId && s.nodeID === exactNode)
-    if (preferred) return preferred.nodeID
-    const anyForBase = services.find((s) => s.name === addonId && s.nodeID === baseNodeId)
-    if (anyForBase) return anyForBase.nodeID
-    const anyWithName = services.find((s) => s.name === addonId)
-    return anyWithName?.nodeID ?? null
-  }
+  const { getAddon, gateway } = deps
 
-  async function remoteGet(
+  // Forked READ — route through the shared gateway (UDS hub-local-child OR
+  // Moleculer remote agent). Degrades to null when the forked addon can't
+  // answer yet (mid-boot / missing service) so the panel shows its empty state
+  // instead of bubbling a 500.
+  async function forkedGet(
     addonId: string,
-    nodeId: string,
-    action: string,
-    extraParams?: Record<string, unknown>,
+    method: AddonSettingsMethod,
+    args: Record<string, unknown>,
+    nodeId?: string,
   ): Promise<ReshapedSchema | null> {
-    const params = { ...extraParams }
-    const workerNodeId = resolveWorkerNodeId(addonId, nodeId)
     try {
-      const result: unknown = await broker.call(
-        `${addonId}.settings.${action}`,
-        params,
-        workerNodeId ? { nodeID: workerNodeId, timeout: 10_000 } : { timeout: 10_000 },
-      )
+      const result = await gateway.callForked(addonId, { target: 'settings', method, args }, nodeId)
       return result ? reshapeForOutput(result as ConfigUISchemaWithValues) : null
     } catch (err) {
-      // A forked addon that is still booting (or wedged in
-      // `onInitialize`) has not yet registered its
-      // `<addonId>.settings.*` Moleculer service. A settings READ
-      // against a missing service should degrade to "no schema" so the
-      // panel shows its empty state — NOT bubble a 500 to the operator.
       if (isServiceNotFoundError(err)) return null
       throw err
     }
   }
 
-  async function remoteUpdate(
+  // Forked UPDATE — route through the shared gateway; returns the ack.
+  async function forkedUpdate(
     addonId: string,
-    nodeId: string,
-    action: string,
-    extraParams: Record<string, unknown>,
+    method: AddonSettingsMethod,
+    args: Record<string, unknown>,
+    nodeId?: string,
   ): Promise<SettingsUpdateResult> {
-    const workerNodeId = resolveWorkerNodeId(addonId, nodeId)
-    await broker.call(
-      `${addonId}.settings.${action}`,
-      extraParams,
-      workerNodeId ? { nodeID: workerNodeId, timeout: 10_000 } : { timeout: 10_000 },
-    )
+    await gateway.callForked(addonId, { target: 'settings', method, args }, nodeId)
     return { success: true as const }
   }
 
@@ -220,18 +148,20 @@ function createAddonSettingsProvider(deps: AddonSettingsProviderDeps): IAddonSet
 
   return {
     async getGlobalSettings(input: AddonIdInput) {
-      if (isLocal(input.addonId, input.nodeId)) {
+      if (gateway.isInProcess(input.addonId, input.nodeId)) {
         const addon = getAddon(input.addonId)
         if (!addon || typeof addon.getGlobalSettings !== 'function') return null
-        const result = await addon.getGlobalSettings(input.overlay)
+        const result = await addon.getGlobalSettings(input.overlay, input.cap)
         return result ? reshapeForOutput(result) : null
       }
-      const nodeId = input.nodeId ?? resolveNode(input.addonId)
-      return remoteGet(input.addonId, nodeId, 'getGlobalSettings', { ...(input.overlay ? { overlay: input.overlay } : {}) })
+      return forkedGet(input.addonId, 'getGlobalSettings', {
+        ...(input.overlay ? { overlay: input.overlay } : {}),
+        ...(input.cap ? { cap: input.cap } : {}),
+      }, input.nodeId)
     },
 
     async updateGlobalSettings(input: AddonPatchInput) {
-      if (isLocal(input.addonId, input.nodeId)) {
+      if (gateway.isInProcess(input.addonId, input.nodeId)) {
         const addon = getAddon(input.addonId)
         if (!addon || typeof addon.updateGlobalSettings !== 'function') {
           throw new Error(`Addon "${input.addonId}" does not implement updateGlobalSettings`)
@@ -239,23 +169,21 @@ function createAddonSettingsProvider(deps: AddonSettingsProviderDeps): IAddonSet
         await addon.updateGlobalSettings(input.patch)
         return { success: true as const }
       }
-      const nodeId = input.nodeId ?? resolveNode(input.addonId)
-      return remoteUpdate(input.addonId, nodeId, 'updateGlobalSettings', { patch: input.patch })
+      return forkedUpdate(input.addonId, 'updateGlobalSettings', { patch: input.patch }, input.nodeId)
     },
 
     async getDeviceSettings(input: DeviceGetInput) {
-      if (isLocal(input.addonId, input.nodeId)) {
+      if (gateway.isInProcess(input.addonId, input.nodeId)) {
         const addon = getAddon(input.addonId)
         if (!addon || typeof addon.getDeviceSettings !== 'function') return null
         const result = await addon.getDeviceSettings(input.deviceId)
         return result ? reshapeForOutput(result) : null
       }
-      const nodeId = input.nodeId ?? resolveNode(input.addonId)
-      return remoteGet(input.addonId, nodeId, 'getDeviceSettings', { deviceId: input.deviceId })
+      return forkedGet(input.addonId, 'getDeviceSettings', { deviceId: input.deviceId }, input.nodeId)
     },
 
     async updateDeviceSettings(input: DeviceUpdateInput) {
-      if (isLocal(input.addonId, input.nodeId)) {
+      if (gateway.isInProcess(input.addonId, input.nodeId)) {
         const addon = getAddon(input.addonId)
         if (!addon || typeof addon.updateDeviceSettings !== 'function') {
           throw new Error(`Addon "${input.addonId}" does not implement updateDeviceSettings`)
@@ -263,11 +191,7 @@ function createAddonSettingsProvider(deps: AddonSettingsProviderDeps): IAddonSet
         await addon.updateDeviceSettings(input.deviceId, input.patch)
         return { success: true as const }
       }
-      const nodeId = input.nodeId ?? resolveNode(input.addonId)
-      return remoteUpdate(input.addonId, nodeId, 'updateDeviceSettings', {
-        deviceId: input.deviceId,
-        patch: input.patch,
-      })
+      return forkedUpdate(input.addonId, 'updateDeviceSettings', { deviceId: input.deviceId, patch: input.patch }, input.nodeId)
     },
   }
 }

package/src/core/capability/capability.service.ts

@@ -25,6 +25,15 @@ export class CapabilityService {
     return this.registry?.getSingleton<T>(capability) ?? null
   }
 
+  /**
+   * Resolve the hub-local provider honoring the 'hub' per-node singleton override.
+   * Delegates to `CapabilityRegistry.getSingletonForNode` so the in-process lookup
+   * respects per-node overrides set by the operator.
+   */
+  getSingletonForNode<T>(capability: string, nodeId: string): T | null {
+    return this.registry?.getSingletonForNode<T>(capability, nodeId) ?? null
+  }
+
   /** Get the addon ID of the active singleton provider for a capability */
   getSingletonAddonId(capability: string): string | null {
     return this.registry?.getSingletonAddonId(capability) ?? null

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

@@ -0,0 +1,166 @@
+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

@@ -0,0 +1,103 @@
+/**
+ * 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)
+  }
+}