@camstack/server 1.1.21 → 1.1.23

package/dist/core/moleculer/cap-route-authority.js

@@ -16,6 +16,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodeCapAuthority = createNodeCapAuthority;
 exports.createInProcessProviderLookup = createInProcessProviderLookup;
+exports.createHubResidentProviderLookup = createHubResidentProviderLookup;
 /**
  * Build a NodeCapAuthority backed by a HubNodeRegistry.
  *
@@ -107,16 +108,42 @@ function createInProcessProviderLookup(capabilityService) {
             capabilityService.getSingleton(capName);
         if (provider === null || provider === undefined)
             return null;
-        const ref = {
-            invoke: (method, args) => {
-                const fn = provider[method];
-                if (typeof fn !== 'function') {
-                    return Promise.reject(new Error(`method "${method}" not found on cap "${capName}"`));
-                }
-                const result = fn.call(provider, args);
-                return Promise.resolve(result);
-            },
-        };
-        return ref;
+        return buildProviderRef(capName, provider);
+    };
+}
+/**
+ * NODE-ACCURATE variant of {@link createInProcessProviderLookup}: resolves a
+ * provider ONLY when one is physically resident on the hub node
+ * (`getSingletonForNode(cap, 'hub')`) — no fallback to the cluster-elected
+ * ACTIVE singleton.
+ *
+ * Rationale: `getSingleton(cap)` returns the elected provider OBJECT, which
+ * for a remote election is a Moleculer-proxy registered in the hub registry.
+ * That fallback is correct for UNPINNED singleton dispatch (election
+ * adherence) but must never satisfy an explicit `nodePin('hub')` — the
+ * "hub-in-process" route would silently execute on another node (the shm
+ * frame-plane cross-node decoder-session storm: a `decoder` call pinned to
+ * the hub landed on a remote agent whenever the hub's decoder runner was
+ * circuit-broken). Wired into `CapRouteResolver.hubResidentProviders`.
+ */
+function createHubResidentProviderLookup(capabilityService) {
+    return (capName) => {
+        const provider = capabilityService.getSingletonForNode?.(capName, 'hub');
+        if (provider === null || provider === undefined)
+            return null;
+        return buildProviderRef(capName, provider);
+    };
+}
+/** Shared cast-free InProcessProviderRef builder over a provider object. */
+function buildProviderRef(capName, provider) {
+    return {
+        invoke: (method, args) => {
+            const fn = provider[method];
+            if (typeof fn !== 'function') {
+                return Promise.reject(new Error(`method "${method}" not found on cap "${capName}"`));
+            }
+            const result = fn.call(provider, args);
+            return Promise.resolve(result);
+        },
     };
 }

package/dist/core/moleculer/moleculer.service.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MoleculerService = void 0;
 exports.buildChildUdsManifest = buildChildUdsManifest;
+const node_crypto_1 = require("node:crypto");
 const system_1 = require("@camstack/system");
+const types_1 = require("@camstack/types");
 const cap_router_runtime_js_1 = require("../../api/trpc/cap-router-runtime.js");
 const cap_call_fn_js_1 = require("./cap-call-fn.js");
 const cap_route_authority_js_1 = require("./cap-route-authority.js");
-const types_1 = require("@camstack/types");
-const node_crypto_1 = require("node:crypto");
 class MoleculerService {
     eventBus;
     config;
@@ -411,6 +411,12 @@ class MoleculerService {
                     null,
             }),
             inProcessProviders: (0, cap_route_authority_js_1.createInProcessProviderLookup)(this.capabilityService),
+            // Node-accurate lookup for EXPLICITLY hub-pinned calls: unlike the
+            // lookup above (which falls back to the cluster-elected ACTIVE
+            // singleton — possibly a remote proxy), this resolves only providers
+            // physically resident on the hub, so a `nodePin('hub')` fails precisely
+            // instead of silently executing on another node.
+            hubResidentProviders: (0, cap_route_authority_js_1.createHubResidentProviderLookup)(this.capabilityService),
             // Per-cap-method RPC timeout override (e.g. model-convert.convert, which
             // runs for minutes) — read from the cap definition's declared timeoutMs.
             capTimeoutMs: (capName, method) => this.capabilityService.getRegistry()?.getDefinition(capName)?.methods?.[method]?.timeoutMs,
@@ -436,7 +442,20 @@ class MoleculerService {
                 registry: this.localChildRegistry,
                 parentBus: this.eventBus,
                 parentNodeId: hubNodeId,
+                // D2: relay via pass-through so the bridge's wildcard is not counted as
+                // local interest (uniform with the agent; harmless here since the hub
+                // retains and always accepts inbound cross-node events anyway).
+                subscribePassthrough: (handler) => (0, system_1.subscribePassthrough)(this.broker, handler),
             });
+            // D2: expose the hub's aggregate child interest to its `$event-bus`
+            // inbound gate for uniformity with the agent. NOTE: the hub main process
+            // opts into `retainRecent` (it serves `getRecent` + the admin-ui live
+            // event stream), so `crossNodeAcceptsCategory` always accepts every
+            // inbound category here — the hub never filters agent-origin events. This
+            // wiring is therefore harmless-but-uniform; the real efficiency win is on
+            // agents (non-retaining nodes).
+            const hubChildRegistry = this.localChildRegistry;
+            (0, system_1.setNodeEventInterest)(this.broker, () => hubChildRegistry.aggregateEventInterest());
         }
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/server",
-  "version": "1.1.21",
+  "version": "1.1.23",
   "private": false,
   "files": [
     "dist",