@camstack/server 1.2.138 → 1.2.140

package/dist/agent/agent-update-service.js

@@ -70,6 +70,7 @@ const system_exec_npm_js_1 = require("../core/server-update/system-exec-npm.js")
 const update_availability_emitter_js_1 = require("../core/update-availability-emitter.js");
 const update_availability_store_js_1 = require("../core/update-availability-store.js");
 const index_js_1 = require("../server-root/index.js");
+const restart_marker_js_1 = require("../core/updates/restart-marker.js");
 /**
  * The synthetic addonId the agent's OWN runtime registers infra providers
  * under (no addon owns them — the bootstrap does). Appears in the agent's
@@ -168,8 +169,8 @@ class AgentUpdateService extends index_js_1.RootUpdateService {
                 seedDir: 'CAMSTACK_SEED_SERVER_DIR',
             },
             logger: options.logger,
-            restartServer: (requestedBy) => {
-                writeAgentRestartMarker(options.dataDir, requestedBy);
+            restartServer: (requestedBy, update) => {
+                writeAgentRestartMarker(options.dataDir, requestedBy, update);
                 restartAgent(requestedBy);
             },
             dataDir: options.dataDir,
@@ -253,20 +254,15 @@ class AgentUpdateService extends index_js_1.RootUpdateService {
     }
 }
 exports.AgentUpdateService = AgentUpdateService;
-function writeAgentRestartMarker(dataDir, requestedBy) {
-    const toVersion = /@([^@\s]+)$/.exec(requestedBy)?.[1];
+function writeAgentRestartMarker(dataDir, requestedBy, update) {
     try {
-        (0, system_1.writePendingRestart)(dataDir, {
-            kind: requestedBy.startsWith('server-update:') ? 'framework-update' : 'manual',
+        // Same builder as the hub: an agent's "Server aggiornato" notification must
+        // name both versions too — see `core/updates/restart-marker.ts`.
+        (0, system_1.writePendingRestart)(dataDir, (0, restart_marker_js_1.buildRestartMarker)({
             requestedAt: Date.now(),
             requestedBy,
-            ...(requestedBy.startsWith('server-update:')
-                ? {
-                    packageName: '@camstack/server',
-                    ...(toVersion !== undefined ? { toVersion } : {}),
-                }
-                : {}),
-        });
+            ...(update !== undefined ? { update } : {}),
+        }));
     }
     catch {
         // Marker write must never block the restart.

package/dist/core/addon/addon-package.service.js

@@ -47,6 +47,7 @@ const system_1 = require("@camstack/system");
 const types_1 = require("@camstack/types");
 const update_availability_emitter_js_1 = require("../update-availability-emitter.js");
 const update_check_scheduler_js_1 = require("../updates/update-check-scheduler.js");
+const restart_marker_js_1 = require("../updates/restart-marker.js");
 const package_dir_utils_js_1 = require("./package-dir-utils.js");
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 /**
@@ -1105,28 +1106,25 @@ class AddonPackageService {
     /**
      * Gracefully restart the server process.
      *
-     * Writes a `manual` restart marker so the post-boot service can
-     * emit `system.restart-completed` on the next boot (powers the
-     * admin-UI "Server restarted" toast). Emits `system.restarting`
+     * Writes the restart marker so the post-boot service can emit
+     * `system.restart-completed` on the next boot (powers the admin-UI
+     * "Server restarted" toast AND the operator's "Server aggiornato"
+     * notification). `update` is passed by `RootUpdateService` for an
+     * update-driven restart and is the ONLY source of the version being left
+     * behind — see `updates/restart-marker.ts`. Emits `system.restarting`
      * with the same payload so subscribers can show a reconnect overlay
      * immediately. Then delegates to `scheduleSelfRestart` which picks
      * the right exit path (Electron `app.relaunch` vs supervisor-driven
      * `process.exit`).
      */
-    restartServer(requestedBy) {
+    restartServer(requestedBy, update) {
         this.logger.info('Server restart requested -- initiating graceful shutdown');
-        const toVersion = toVersionFromRestartReason(requestedBy);
-        const payload = {
-            kind: isServerUpdateRequest(requestedBy) ? 'framework-update' : 'manual',
+        // Both versions, one builder, shared with the agent — see `restart-marker.ts`.
+        const payload = (0, restart_marker_js_1.buildRestartMarker)({
             requestedAt: Date.now(),
             ...(requestedBy !== undefined ? { requestedBy } : {}),
-            ...(isServerUpdateRequest(requestedBy)
-                ? {
-                    packageName: '@camstack/server',
-                    ...(toVersion !== undefined ? { toVersion } : {}),
-                }
-                : {}),
-        };
+            ...(update !== undefined ? { update } : {}),
+        });
         try {
             (0, system_1.writePendingRestart)(this.resolveDataDir(), payload);
         }
@@ -1682,22 +1680,26 @@ class AddonPackageService {
      * re-announces them on the next good poll.
      */
     publishAddonAvailability(updates, failures, nodeId) {
+        // The hub's own sweep passes no nodeId — but its rows are about a NODE
+        // like any other, and a list whose lines cannot be attributed is what made
+        // three announcements look like one.
+        const scope = nodeId ?? this.resolveNodeId();
         const candidates = updates.map((update) => ({
             target: 'addon',
             packageName: update.name,
             currentVersion: update.currentVersion,
             latestVersion: update.latestVersion,
-            ...(nodeId !== undefined ? { nodeId } : {}),
+            nodeId: scope,
         }));
         if (failures > 0) {
             this.logger.warn('Addon update check incomplete — availability published as partial', {
-                tags: { nodeId: nodeId ?? 'hub' },
+                tags: { nodeId: scope },
                 meta: { failures, published: candidates.length },
             });
             this.updateAvailability.publishCandidates(candidates);
             return;
         }
-        this.updateAvailability.publishSnapshot('addon', candidates, nodeId);
+        this.updateAvailability.publishSnapshot('addon', candidates, scope);
     }
     /** Fetch npm search results for camstack addon packages (cached 5 min) */
     async fetchSearchFromNpm() {
@@ -1860,15 +1862,6 @@ class AddonPackageService {
     }
 }
 exports.AddonPackageService = AddonPackageService;
-function isServerUpdateRequest(requestedBy) {
-    return requestedBy !== undefined && requestedBy.startsWith('server-update:');
-}
-function toVersionFromRestartReason(requestedBy) {
-    if (requestedBy === undefined)
-        return undefined;
-    const match = /@([^@\s]+)$/.exec(requestedBy);
-    return match?.[1];
-}
 // ---------------------------------------------------------------------------
 // Tarball extraction helper (exported for regression tests)
 // ---------------------------------------------------------------------------

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MoleculerService = void 0;
+exports.childOwnerToken = childOwnerToken;
 exports.buildChildUdsManifest = buildChildUdsManifest;
 const node_crypto_1 = require("node:crypto");
 const system_1 = require("@camstack/system");
@@ -27,6 +28,21 @@ class MoleculerService {
      * `$hub.registerNode`. Populated by `onRegisterNode` in `hubDeps`.
      */
     nodeRegistry = new system_1.HubNodeRegistry();
+    /**
+     * nodeId → the owner token of the INCARNATION whose manifest currently backs
+     * that node's capability registrations.
+     *
+     * A node id is not unique over time: `resolveRunnerId` is deterministic, so a
+     * runner replaced by an addon update reconnects as the same `hub/<runner>`
+     * node. Without an incarnation the predecessor's teardown and the successor's
+     * registration are the same `(cap, addonId)` key, and the teardown wins by
+     * arriving last — `recording`, `storage-evictable` and `recording-export`
+     * were unregistered from a healthy process for 7 hours on 2026-08-20.
+     * Populated only for transports that can observe an incarnation (UDS
+     * children); remote nodes stay ownerless and behave exactly as before.
+     * See `docs/decisions/adr-0188-an-unregister-carries-proof-of-ownership.md`.
+     */
+    nodeOwners = new Map();
     /**
      * Fixed-period agent-readiness snapshot sweep (D8 reconcile) — repairs
      * agent-origin readiness deltas lost while the agent stayed connected.
@@ -405,16 +421,23 @@ class MoleculerService {
                 const hubNodeId = this.brokerSafe.nodeID;
                 const childNodeId = `${hubNodeId}/${child.childId}`;
                 const params = buildChildUdsManifest(childNodeId, child.childId, child.caps);
-                this.onRegisterNode(params);
-                logger.info('UDS child registered — manifest applied', { meta: { nodeId: childNodeId } });
+                // The UDS connection is the only thing that can tell two generations of
+                // the same runner apart — carry its incarnation into the registry as
+                // the owner of every registration this manifest makes.
+                this.onRegisterNode(params, childOwnerToken(childNodeId, child.incarnation));
+                logger.info('UDS child registered — manifest applied', {
+                    meta: { nodeId: childNodeId, incarnation: child.incarnation },
+                });
             });
             // E1: cleanup on child disconnect — same effect as `$node.disconnected`
             // for hub-local children. The Moleculer path stays for AGENT nodes.
-            registry.onChildGone((childId) => {
+            registry.onChildGone((childId, incarnation) => {
                 const hubNodeId = this.brokerSafe.nodeID;
                 const childNodeId = `${hubNodeId}/${childId}`;
-                logger.info('UDS child gone — removing from registry', { meta: { childId } });
-                this.removeNodeFromRegistry(childNodeId);
+                logger.info('UDS child gone — removing from registry', {
+                    meta: { childId, incarnation },
+                });
+                this.removeNodeFromRegistry(childNodeId, childOwnerToken(childNodeId, incarnation));
             });
             // B2: ingest UDS child logs into the hub's LoggingService so they appear
             // in the LogManager / admin-UI log stream alongside broker-forwarded logs.
@@ -449,6 +472,10 @@ class MoleculerService {
         // sent a $hub.registerNode manifest get cleaned up on disconnect.
         const bridgeBus = this.broker;
         bridgeBus.localBus.on('$node.disconnected', ({ node }) => {
+            // No owner token: this listener cannot observe WHICH incarnation died.
+            // For a hub-local child the UDS `onChildGone` is the authority (it holds
+            // the incarnation) and this call is refused if the id has been reclaimed;
+            // remote nodes register no owner at all, so they clean up as before.
             this.removeNodeFromRegistry(node.id);
         });
         // D8 reverse-leg snapshot-reconcile: on every agent (re)connect, pull
@@ -682,10 +709,15 @@ class MoleculerService {
      * CapabilityRegistry update is a diff (atomic replace) rather than an
      * unconditional re-register — see `applyNodeManifest` for the rationale.
      */
-    onRegisterNode(params) {
+    onRegisterNode(params, owner) {
         const previousManifest = this.nodeRegistry.getNodeManifest(params.nodeId);
+        const previousOwner = this.nodeOwners.get(params.nodeId);
         this.nodeRegistry.registerNode(params);
-        this.applyNodeManifest(params, previousManifest);
+        if (owner === undefined)
+            this.nodeOwners.delete(params.nodeId);
+        else
+            this.nodeOwners.set(params.nodeId, owner);
+        this.applyNodeManifest(params, previousManifest, owner, previousOwner);
         // Notify AgentRegistryService to reconcile placement for bare-ID
         // agent nodes (no '/' = not a hub child worker, not the hub itself).
         // The handshake is the authoritative completeness signal — the full
@@ -717,7 +749,7 @@ class MoleculerService {
      * already; this method handles only `params.addons` (system caps).
      * Native-cap wiring into device-manager is done in a later task.
      */
-    applyNodeManifest(params, previousManifest) {
+    applyNodeManifest(params, previousManifest, owner, previousOwner) {
         const { nodeId, addons } = params;
         const hubNodeId = this.brokerSafe.nodeID;
         const isLocalChild = nodeId.startsWith(hubNodeId + '/');
@@ -763,9 +795,23 @@ class MoleculerService {
         for (const [key, { addonId, capName }] of previous) {
             if (desired.has(key))
                 continue;
-            registry.unregisterProvider(capName, registryKeyFor(addonId));
+            // Present the token the DROPPED registration was made under — this node
+            // is dropping its own cap, and the registry refuses anything else.
+            registry.unregisterProvider(capName, registryKeyFor(addonId), previousOwner);
             this.nodeCallFns.delete(`${nodeId}::${capName}`);
         }
+        // ── TAKE OVER ── caps present in BOTH manifests when the node id has been
+        // reclaimed by a NEW incarnation. The registration is correct and stays
+        // (zero churn), but it is still stamped with the dead generation's token —
+        // leave it there and nothing the live generation can present would ever
+        // clean it up when IT dies. Re-stamp instead.
+        if (owner !== undefined && previousOwner !== undefined && owner !== previousOwner) {
+            for (const [key, { addonId, capName }] of desired) {
+                if (!previous.has(key))
+                    continue;
+                registry.reassignProviderOwner(capName, registryKeyFor(addonId), owner);
+            }
+        }
         // ── REGISTER ── caps the new manifest applies that the previous one
         // did not. Caps present in BOTH sets are left untouched — zero churn,
         // no duplicate `registerProvider`, no spurious page/widget re-emit.
@@ -810,7 +856,7 @@ class MoleculerService {
             for (const methodName of Object.keys((0, system_1.expandCapMethods)(capDef))) {
                 proxy[methodName] = (methodParams) => callFn(methodName, methodParams);
             }
-            registry.registerProvider(capName, registryKey, proxy);
+            registry.registerProvider(capName, registryKey, proxy, owner);
             // Local-first singleton preference (UDS regression fix). A
             // `placement: 'any-node'` singleton (e.g. `pipeline-executor`) can
             // register on BOTH the hub-local forked child and a remote agent.
@@ -857,7 +903,17 @@ class MoleculerService {
      * Unregisters every cap the node's last manifest declared and emits
      * synthetic readiness-down events for each.
      */
-    removeNodeFromRegistry(nodeId) {
+    removeNodeFromRegistry(nodeId, owner) {
+        const currentOwner = this.nodeOwners.get(nodeId);
+        if (currentOwner !== undefined && currentOwner !== owner) {
+            // The node id has been reclaimed by a newer incarnation since this
+            // teardown was scheduled. Tearing down here would unregister the LIVE
+            // process's capabilities and remove a node that is still connected.
+            this.logger.info('Node teardown ignored — node id reclaimed by a newer incarnation', {
+                meta: { nodeId, currentOwner, presentedOwner: owner ?? null },
+            });
+            return;
+        }
         const manifest = this.nodeRegistry.getNodeManifest(nodeId);
         if (!manifest)
             return; // node never sent a handshake — nothing to do
@@ -871,7 +927,7 @@ class MoleculerService {
             const registryKey = isLocalChild ? addonId : `${addonId}@${nodeId}`;
             if (registry) {
                 for (const capName of capabilities) {
-                    registry.unregisterProvider(capName, registryKey);
+                    registry.unregisterProvider(capName, registryKey, owner);
                 }
             }
             for (const capName of capabilities) {
@@ -893,6 +949,7 @@ class MoleculerService {
                 }
             }
         }
+        this.nodeOwners.delete(nodeId);
         this.nodeRegistry.removeNode(nodeId);
     }
     findCallFn(nodeId, capabilityName) {
@@ -1083,6 +1140,18 @@ exports.MoleculerService = MoleculerService;
 // ---------------------------------------------------------------------------
 // Module-level helpers
 // ---------------------------------------------------------------------------
+/**
+ * The owner token a hub-local UDS child's capability registrations carry.
+ *
+ * `nodeId` alone is NOT an identity over time — a runner replaced by an addon
+ * update reconnects under the same deterministic `hub/<runner>` id — so the
+ * connection's incarnation is what makes the pair unique. Exported for the
+ * regression suite: the rule is only worth anything if register and unregister
+ * derive the token the SAME way.
+ */
+function childOwnerToken(childNodeId, incarnation) {
+    return `${childNodeId}#${incarnation}`;
+}
 /**
  * E1: Adapt a child's UDS `ChildCapDescriptor[]` into a `RegisterNodeParams`
  * that `onRegisterNode` / `applyNodeManifest` can consume.

package/dist/core/update-availability-emitter.js

@@ -7,10 +7,16 @@ const types_1 = require("@camstack/types");
  * `latestVersion` (or first-sees a package/node that has one). Repeated polls
  * of the same latests are silent.
  *
- * Addon snapshots emit ONE event carrying the **entire** currently-available
- * list. Server snapshots do the same across nodes, so the Notification Center
- * can say "1.0.3 is available on hub and little-unraid" instead of one push
- * per package or per node.
+ * One event carries the entire currently-available list **of one node** — the
+ * scope that changed, never the union across nodes. The Notification Center
+ * turns that into "2 aggiornamenti addon disponibili su little-unraid" with
+ * that node's packages under it.
+ *
+ * The union was the shape until 2026-08-19, and on a three-node cluster one
+ * 6-hourly sweep sent the operator THREE pushes that each listed hub +
+ * MinidiGianluca + little-unraid and named no node: every scope's change
+ * re-emitted the whole held map, so the notifications differed by one line and
+ * read as identical. A list is only actionable if it belongs to somebody.
  *
  * A successful empty snapshot clears prior state for that scope; failed checks
  * should not call this method.
@@ -67,22 +73,22 @@ class UpdateAvailabilityEmitter {
         this.persistIfDirty();
         if (!latestChanged)
             return;
-        this.emitList(target);
+        this.emitList(target, scope);
     }
     /** Publish a partial candidate set without treating omissions as up-to-date. */
     publishCandidates(candidates) {
-        let latestChanged = false;
-        const targets = new Set();
+        // Only the (target, node) pairs that actually moved are announced — a
+        // partial sweep of one node must not re-announce another node's list.
+        const changed = new Map();
         for (const candidate of candidates) {
-            targets.add(candidate.target);
-            if (this.note(candidate))
-                latestChanged = true;
+            if (!this.note(candidate))
+                continue;
+            const scope = scopeOf(candidate);
+            changed.set(`${candidate.target}:${scope}`, { target: candidate.target, scope });
         }
         this.persistIfDirty();
-        if (!latestChanged)
-            return;
-        for (const target of targets)
-            this.emitList(target);
+        for (const { target, scope } of changed.values())
+            this.emitList(target, scope);
     }
     note(candidate) {
         const key = this.key(candidate);
@@ -111,21 +117,24 @@ class UpdateAvailabilityEmitter {
             held: Object.fromEntries(this.held),
         });
     }
-    emitList(target) {
-        const list = [...this.held.values()].filter((candidate) => candidate.target === target);
+    /** Announce ONE scope's full list. `scope` is the node id, `hub` for the hub. */
+    emitList(target, scope) {
+        const list = [...this.held.values()].filter((candidate) => candidate.target === target && scopeOf(candidate) === scope);
         if (list.length === 0)
             return;
+        // Every row names its node, the hub's included: the row a caller published
+        // without a nodeId is still ABOUT a node, and an unlabelled line in a
+        // cluster-wide list is unreadable.
         const packages = list.map((candidate) => ({
             packageName: candidate.packageName,
             currentVersion: candidate.currentVersion,
             latestVersion: candidate.latestVersion,
-            ...(candidate.nodeId !== undefined ? { nodeId: candidate.nodeId } : {}),
+            nodeId: scope,
         }));
-        const nodeIds = unique(packages.map((pkg) => pkg.nodeId).filter((id) => id !== undefined));
         const head = list[0];
         this.eventBus.emit({
-            id: `update.available:${target}:${packages
-                .map((pkg) => `${pkg.nodeId ?? 'hub'}:${pkg.packageName}@${pkg.latestVersion}`)
+            id: `update.available:${target}:${scope}:${packages
+                .map((pkg) => `${pkg.packageName}@${pkg.latestVersion}`)
                 .toSorted()
                 .join(',')}`,
             timestamp: new Date(),
@@ -137,21 +146,22 @@ class UpdateAvailabilityEmitter {
                 currentVersion: head.currentVersion,
                 latestVersion: head.latestVersion,
                 packages,
-                ...(head.nodeId !== undefined ? { nodeId: head.nodeId } : {}),
-                ...(nodeIds.length > 0 ? { nodeIds } : {}),
+                nodeId: scope,
+                nodeIds: [scope],
             },
         });
     }
     key(candidate) {
-        return `${candidate.target}:${candidate.nodeId ?? 'hub'}:${candidate.packageName}`;
+        return `${candidate.target}:${scopeOf(candidate)}:${candidate.packageName}`;
     }
 }
 exports.UpdateAvailabilityEmitter = UpdateAvailabilityEmitter;
+/** The node an availability row belongs to. A row without one is the hub's. */
+function scopeOf(candidate) {
+    return candidate.nodeId ?? 'hub';
+}
 function stampNode(candidate, nodeId) {
     if (nodeId === undefined || candidate.nodeId !== undefined)
         return candidate;
     return { ...candidate, nodeId };
 }
-function unique(values) {
-    return [...new Set(values)];
-}

package/dist/core/updates/restart-marker.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRestartMarker = buildRestartMarker;
+exports.isServerUpdateReason = isServerUpdateReason;
+exports.versionFromReason = versionFromReason;
+/** Reason-string prefix every `RootUpdateService`-driven restart carries. */
+const SERVER_UPDATE_PREFIX = 'server-update:';
+/** The root package a version-less `server-update:` reason is about. */
+const ROOT_PACKAGE_NAME = '@camstack/server';
+function buildRestartMarker(input) {
+    const { requestedBy, update, requestedAt } = input;
+    const toVersion = update?.toVersion ?? versionFromReason(requestedBy);
+    const isUpdate = update !== undefined || (isServerUpdateReason(requestedBy) && toVersion !== undefined);
+    if (!isUpdate) {
+        return {
+            kind: 'manual',
+            requestedAt,
+            ...(requestedBy !== undefined ? { requestedBy } : {}),
+        };
+    }
+    return {
+        kind: 'framework-update',
+        requestedAt,
+        ...(requestedBy !== undefined ? { requestedBy } : {}),
+        packageName: update?.packageName ?? ROOT_PACKAGE_NAME,
+        ...(update?.fromVersion !== undefined ? { fromVersion: update.fromVersion } : {}),
+        ...(toVersion !== undefined ? { toVersion } : {}),
+    };
+}
+function isServerUpdateReason(requestedBy) {
+    return requestedBy !== undefined && requestedBy.startsWith(SERVER_UPDATE_PREFIX);
+}
+/** `server-update: @camstack/server@1.2.138` → `1.2.138`; `… manual restart` → none. */
+function versionFromReason(requestedBy) {
+    if (requestedBy === undefined)
+        return undefined;
+    return /@([^@\s]+)$/.exec(requestedBy)?.[1];
+}

package/dist/manual-boot.js

@@ -238,7 +238,7 @@ async function bootManual(opts) {
     // AddonPackageService.restartServer for the marker + reconnect toast.
     const serverUpdateService = new server_update_service_1.ServerUpdateService({
         logger: loggingService.createLogger('ServerUpdate'),
-        restartServer: (requestedBy) => addonPackageService.restartServer(requestedBy),
+        restartServer: (requestedBy, update) => addonPackageService.restartServer(requestedBy, update),
         eventBus: eventBusService,
         updateAvailabilityStore: new update_availability_store_js_1.FileUpdateAvailabilityStore(availabilityDataDir, 'server-update', loggingService.createLogger('UpdateAvailability')),
     });

package/dist/server-root/index.js

@@ -1216,7 +1216,13 @@ var require_dist = __commonJS({
             fromVersion: runningVersion
           }
         });
-        this.restartServerFn(`${RESTART_REASON_PREFIX}: ${this.spec.packageName}@${target}`);
+        this.restartServerFn(`${RESTART_REASON_PREFIX}: ${this.spec.packageName}@${target}`, {
+          packageName: this.spec.packageName,
+          ...runningVersion !== null ? {
+            fromVersion: runningVersion
+          } : {},
+          toVersion: target
+        });
         return {
           accepted: true,
           targetVersion: target,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/server",
-  "version": "1.2.138",
+  "version": "1.2.140",
   "private": false,
   "files": [
     "dist",
@@ -33,18 +33,18 @@
     ]
   },
   "dependencies": {
-    "@camstack/addon-admin-ui": "1.2.83",
+    "@camstack/addon-admin-ui": "1.2.84",
     "@camstack/addon-agent-ui": "1.2.24",
     "@camstack/addon-auth": "1.2.26",
     "@camstack/addon-decoder-nodeav": "1.2.22",
     "@camstack/addon-notifiers": "1.2.27",
-    "@camstack/addon-pipeline": "1.2.101",
-    "@camstack/addon-pipeline-orchestrator": "1.2.84",
-    "@camstack/addon-post-analysis": "1.2.101",
+    "@camstack/addon-pipeline": "1.2.103",
+    "@camstack/addon-pipeline-orchestrator": "1.2.85",
+    "@camstack/addon-post-analysis": "1.2.103",
     "@camstack/sdk": "1.2.25",
-    "@camstack/system": "1.2.109",
-    "@camstack/types": "1.2.91",
-    "@camstack/ui-library": "1.2.62",
+    "@camstack/system": "1.2.111",
+    "@camstack/types": "1.2.92",
+    "@camstack/ui-library": "1.2.63",
     "@fastify/compress": "^9.0.0",
     "@fastify/cookie": "^11.0.2",
     "@fastify/cors": "^11.2.0",