@camstack/server 1.2.73 → 1.2.75

package/dist/agent/agent-service.js

@@ -545,6 +545,13 @@ function createAgentService(deps) {
                         return { success: false, loaded: [] };
                     }
                     const loaded = await deps.reloadDeployedAddons();
+                    // The reload just changed this node's capability set. Re-run the
+                    // atomic registerNode so the hub's routing authority learns it now,
+                    // instead of at the next restart / reconnect. Unconditional: an
+                    // empty `loaded` still covers a RE-load of an existing addon whose
+                    // manifest gained a capability, and registerNode is an idempotent
+                    // replace (D3), so a no-op re-register costs one acked RPC.
+                    deps.reconcileNodeRegistration?.();
                     return { success: true, loaded };
                 },
             },

package/dist/agent/builtins-seed.js

@@ -0,0 +1,84 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seedBuiltinsFromClosure = seedBuiltinsFromClosure;
+/**
+ * Self-heal the agent's builtins package before the infra scan.
+ *
+ * `bootCoreAddons` scans `config.addonsDir` and nothing else, the image seed
+ * ships no `@camstack/system`, and the running closure's copy is NOT loaded
+ * as an addon — so an agent whose `/data/addons/@camstack/system` is missing
+ * (greenfield container, an operator cleanup, a failed deploy) boots with
+ * zero infrastructure. Before D87 that produced a silently gutted node; with
+ * the D87 guard it produces a crash-loop. Both are wrong answers to a
+ * question the node can answer itself: the closure it is RUNNING carries the
+ * exact builtins package it needs.
+ *
+ * The copy is files-list shaped — `package.json` + `dist` — and NEVER
+ * `node_modules`: a nested `node_modules/@camstack/*` carries its own
+ * `package.json`s, the addon scan discovers those too, and the same addon
+ * initializing twice is a boot abort (measured live 2026-08-08, twice, two
+ * different vehicles).
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+function seedBuiltinsFromClosure(addonsDir, log = console.log, resolveClosurePkg = () => require.resolve('@camstack/system/package.json')) {
+    const target = path.join(addonsDir, '@camstack', 'system');
+    if (fs.existsSync(path.join(target, 'package.json')))
+        return 'present';
+    let closurePkgJson;
+    try {
+        closurePkgJson = resolveClosurePkg();
+    }
+    catch {
+        log('[Agent] builtins seed: @camstack/system not resolvable from the closure — cannot self-heal');
+        return 'unavailable';
+    }
+    const closureRoot = path.dirname(closurePkgJson);
+    const closureDist = path.join(closureRoot, 'dist');
+    if (!fs.existsSync(closureDist)) {
+        log(`[Agent] builtins seed: closure copy at ${closureRoot} has no dist — cannot self-heal`);
+        return 'unavailable';
+    }
+    fs.mkdirSync(target, { recursive: true });
+    fs.copyFileSync(closurePkgJson, path.join(target, 'package.json'));
+    fs.cpSync(closureDist, path.join(target, 'dist'), {
+        recursive: true,
+        filter: (src) => !src.split(path.sep).includes('node_modules'),
+    });
+    log(`[Agent] builtins seed: @camstack/system was missing under ${addonsDir} — ` +
+        `seeded package.json + dist from the running closure (${closureRoot})`);
+    return 'seeded';
+}

package/dist/agent/infra-boot-guard.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * infra-boot-guard.ts — the agent's "did my infrastructure actually load?" gate.
+ *
+ * `bootCoreAddons` resolves each {@link INFRA_CAPABILITIES} entry to an addon
+ * package found under `<dataDir>/addons`. Two things can go wrong, and until
+ * 2026-08-08 only ONE of them was fatal:
+ *
+ *   - the addon was found but its `initialize()` threw  → boot aborted (correct);
+ *   - the addon was NOT FOUND at all                    → `console.error`, continue.
+ *
+ * The second branch is strictly worse than the first and it was the quiet one.
+ * On `little-unraid` the whole `@camstack/system` package was renamed out of
+ * `/data/addons/@camstack/` at 16:40 on 2026-08-07 (a builtin-shadow cleanup).
+ * On an AGENT that directory is the SOLE source of the builtins — there is no
+ * seed fallback — so the next boot came up with ZERO infra addons: no storage,
+ * no settings-store, no metrics, no `platform-probe`, and no `hub-forwarder`.
+ *
+ * The node then reported `healthy`, registered its 14 forked addons with the
+ * hub, and kept running. Nothing said otherwise, because the ONE addon that
+ * ships an agent's logs to the hub (`hub-forwarder`, a `log-destination`) is in
+ * the same missing package: the failure was unobservable BY CONSTRUCTION. It
+ * surfaced five hours later, and only indirectly, as
+ * `getNodeInferenceDevices → reachable:false` on the hub — because the node's
+ * `registerNode` manifest legitimately no longer contained `platform-probe`,
+ * so `CapRouteResolver.nodeKnowsCap` correctly answered "no provider".
+ *
+ * `InfraCapability.required` is documented as "boot aborts when this
+ * capability's addon fails to initialize". A capability whose addon is not
+ * even present has failed harder. This guard makes both branches agree.
+ *
+ * It reports EVERY missing required capability in one throw, not just the
+ * first — an operator staring at a crash-loop needs the whole list, and the
+ * four that vanished together on little-unraid vanished for one single reason.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertRequiredInfraResolved = assertRequiredInfraResolved;
+/**
+ * Throw when any `required` infra capability resolved to no addon at all.
+ *
+ * Called AFTER the resolution pass so the message names every missing
+ * capability at once. Non-required misses (`platform-probe`,
+ * `metrics-provider`, `log-destination`) are the caller's business — they are
+ * already logged individually and are legitimately absent on some nodes.
+ */
+function assertRequiredInfraResolved(resolutions, addonsDir) {
+    const missing = resolutions.filter((r) => r.required && r.addonId === null).map((r) => r.name);
+    if (missing.length === 0)
+        return;
+    throw new Error(`Required infrastructure capabilities have no addon under "${addonsDir}": ` +
+        `${missing.join(', ')}. The agent's builtins package (@camstack/system) is ` +
+        `missing or unreadable — this node cannot store, configure or probe itself, ` +
+        `and every hub routing decision that consults its manifest would be wrong. ` +
+        `Refusing to boot degraded.`);
+}

package/dist/agent/infra-boot-plan.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planInfraBoot = planInfraBoot;
+exports.planToResolutions = planToResolutions;
+/**
+ * `log-destination` prefers `hub-forwarder` (ships agent logs to the hub)
+ * over a local winston — mirrors the historical inline choice.
+ */
+function pickCandidate(capName, candidates) {
+    if (capName === 'log-destination') {
+        return candidates.find((a) => a.id === 'hub-forwarder') ?? candidates[0];
+    }
+    return candidates[0];
+}
+function planInfraBoot(addons, infraList) {
+    const initialized = new Set();
+    const steps = [];
+    for (const infra of infraList) {
+        const candidates = addons.filter((a) => a.capabilities.includes(infra.name));
+        const chosen = pickCandidate(infra.name, candidates);
+        if (!chosen) {
+            steps.push({
+                capName: infra.name,
+                required: infra.required,
+                addonId: null,
+                initialize: false,
+            });
+            continue;
+        }
+        const first = !initialized.has(chosen.id);
+        if (first)
+            initialized.add(chosen.id);
+        steps.push({
+            capName: infra.name,
+            required: infra.required,
+            addonId: chosen.id,
+            initialize: first,
+        });
+    }
+    return steps;
+}
+/** Project a plan onto the guard's resolution shape. */
+function planToResolutions(steps) {
+    return steps.map((s) => ({ name: s.capName, required: s.required, addonId: s.addonId }));
+}

package/dist/agent/main.js

@@ -45,6 +45,9 @@ const types_2 = require("@camstack/types");
 const agent_config_js_1 = require("./agent-config.js");
 const agent_update_service_js_1 = require("./agent-update-service.js");
 const server_management_provider_js_1 = require("../api/core/server-management.provider.js");
+const infra_boot_guard_js_1 = require("./infra-boot-guard.js");
+const infra_boot_plan_js_1 = require("./infra-boot-plan.js");
+const builtins_seed_js_1 = require("./builtins-seed.js");
 const agent_service_js_1 = require("./agent-service.js");
 const agent_group_runner_js_1 = require("./agent-group-runner.js");
 const register_agent_cap_dispatch_js_1 = require("./register-agent-cap-dispatch.js");
@@ -409,6 +412,13 @@ async function startAgent(configPath) {
             }
             return loaded;
         },
+        // The reload above changed this node's capability set — re-derive the
+        // manifest from the live registry and re-run the atomic `registerNode`
+        // so the hub's `CapRouteResolver` can route to what this node now has.
+        // Hung on the existing `$agent.reload` trigger; no timer (D3).
+        reconcileNodeRegistration: () => {
+            triggerUpwardRegistration();
+        },
         // D3 subtree aggregation: when a group-runner child delivers its manifest
         // via `$agent.registerNode`, merge it into the local subtree registry and
         // immediately re-register the complete union with the hub.
@@ -759,6 +769,10 @@ async function startAgent(configPath) {
 // Core infra addons to load on agent — all infra including log-destination (hub-forwarder)
 const AGENT_INFRA = system_1.INFRA_CAPABILITIES;
 async function bootCoreAddons(broker, config, registry, loadedAddons, loggerFactory) {
+    // Self-heal FIRST: a missing builtins package is answerable from the
+    // running closure (see `builtins-seed.ts`) — without this, the D87 guard
+    // below turns a recoverable gap into a crash-loop.
+    (0, builtins_seed_js_1.seedBuiltinsFromClosure)(config.addonsDir);
     // Scan every installed addon package — infra providers may live outside
     // `@camstack/system` (e.g. `@camstack/addon-platform-probe-native`).
     const packageDirs = resolveAddonPackageDirs(config.addonsDir);
@@ -776,21 +790,38 @@ async function bootCoreAddons(broker, config, registry, loadedAddons, loggerFact
             console.warn(`[Agent] Failed to scan ${dir}: ${(0, types_2.errMsg)(err)}`);
         }
     }
-    for (const infra of AGENT_INFRA) {
-        const candidates = loader.listAddons().filter((a) => a.declaration.capabilities?.some((c) => {
-            const capName = typeof c === 'string' ? c : c.name;
-            return capName === infra.name;
-        }));
-        // For log-destination, prefer hub-forwarder over winston-logging
-        const addon = infra.name === 'log-destination'
-            ? (candidates.find((a) => a.declaration.id === 'hub-forwarder') ?? candidates[0])
-            : candidates[0];
-        if (!addon) {
-            if (infra.required) {
-                console.error(`[Agent] Required infrastructure addon for "${infra.name}" not found`);
-            }
+    // Resolution is per-CAPABILITY (the guard names every missing required
+    // cap), initialization is per-ADDON: since D44 one addon legitimately
+    // serves several infra caps (`storage-orchestrator` owns both `storage`
+    // and `settings-store`), and initializing it once per capability
+    // re-registers the same provider — a boot abort by the registry's own
+    // double-registration error. That combination took both agents down on
+    // 2026-08-08 the moment D87 promoted infra failures to fatal. The plan
+    // makes the dedupe explicit and testable (see `infra-boot-plan.ts`).
+    const byId = new Map(loader.listAddons().map((a) => [a.declaration.id, a]));
+    const plan = (0, infra_boot_plan_js_1.planInfraBoot)(loader.listAddons().map((a) => ({
+        id: a.declaration.id,
+        capabilities: (a.declaration.capabilities ?? []).map((c) => typeof c === 'string' ? c : c.name),
+    })), AGENT_INFRA);
+    const resolutions = (0, infra_boot_plan_js_1.planToResolutions)(plan);
+    for (const step of plan) {
+        if (step.addonId === null) {
+            // Say it per-capability (an OPTIONAL miss is the only thing this line
+            // will ever report given the guard below); the required ones abort
+            // boot together after the pass.
+            console.error(`[Agent] Infrastructure addon for "${step.capName}" not found`);
             continue;
         }
+        if (!step.initialize) {
+            // Served by an addon an earlier capability already booted — the
+            // entry exists so a deployment missing it fails loudly, not to boot
+            // the addon twice.
+            console.log(`[Agent] Infra capability "${step.capName}" served by already-booted "${step.addonId}"`);
+            continue;
+        }
+        const addon = byId.get(step.addonId);
+        if (!addon)
+            continue;
         const addonId = addon.declaration.id;
         try {
             const instance = new addon.addonClass();
@@ -829,11 +860,17 @@ async function bootCoreAddons(broker, config, registry, loadedAddons, loggerFact
         catch (err) {
             const msg = (0, types_2.errMsg)(err);
             console.error(`[Agent] Failed to initialize core addon "${addonId}": ${msg}`);
-            if (infra.required) {
+            if (step.required) {
                 throw new Error(`Required infrastructure addon "${addonId}" failed: ${msg}`, { cause: err });
             }
         }
     }
+    // A required infra capability with NO addon at all is strictly worse than
+    // one whose addon threw (which already aborted above) — and it used to be
+    // the SILENT branch. Abort here instead of booting a node that cannot
+    // store, configure or probe itself and whose manifest then makes every hub
+    // routing decision about it wrong. See `infra-boot-guard.ts`.
+    (0, infra_boot_guard_js_1.assertRequiredInfraResolved)(resolutions, config.addonsDir);
 }
 // ---------------------------------------------------------------------------
 // Phase 1.5: Load cluster-capable addon packages

package/dist/api/sse-no-compression.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markSseRequestNoCompression = markSseRequestNoCompression;
+/** Mutates the request headers in place; returns whether it marked the request. */
+function markSseRequestNoCompression(request) {
+    const accept = request.headers.accept;
+    if (typeof accept === 'string' && accept.includes('text/event-stream')) {
+        request.headers['x-no-compression'] = '1';
+        return true;
+    }
+    return false;
+}

package/dist/api/trpc/generated-cap-routers.js

@@ -5817,6 +5817,105 @@ function createCapRouter_pipelineAnalytics(getProvider, createRemoteProxy) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
             return p.getTrainingExportUrl(methodInput);
         }),
+        listRetrainStaging: trpc_middleware_js_1.adminProcedure
+            .input(types_81.pipelineAnalyticsCapability.methods.listRetrainStaging.input.loose())
+            .output(types_81.pipelineAnalyticsCapability.methods.listRetrainStaging.output)
+            .query(async ({ input, ctx }) => {
+            const { nodeId, ...methodInput } = input;
+            const p = resolveProvider('pipeline-analytics', nodeId, () => getProvider(ctx), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.listRetrainStaging(methodInput);
+        }),
+        listRetrainFrames: trpc_middleware_js_1.adminProcedure
+            .input(types_81.pipelineAnalyticsCapability.methods.listRetrainFrames.input.loose())
+            .output(types_81.pipelineAnalyticsCapability.methods.listRetrainFrames.output)
+            .query(async ({ input, ctx }) => {
+            const { nodeId, ...methodInput } = input;
+            const p = resolveProvider('pipeline-analytics', nodeId, () => getProvider(ctx), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.listRetrainFrames(methodInput);
+        }),
+        selectRetrainFrames: trpc_middleware_js_1.adminProcedure
+            .input(types_81.pipelineAnalyticsCapability.methods.selectRetrainFrames.input.loose())
+            .output(types_81.pipelineAnalyticsCapability.methods.selectRetrainFrames.output)
+            .mutation(async ({ input, ctx }) => {
+            const { nodeId, ...methodInput } = input;
+            const p = resolveProvider('pipeline-analytics', nodeId, () => getProvider(ctx), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.selectRetrainFrames(methodInput);
+        }),
+        deselectRetrainFrame: trpc_middleware_js_1.adminProcedure
+            .input(types_81.pipelineAnalyticsCapability.methods.deselectRetrainFrame.input.loose())
+            .output(types_81.pipelineAnalyticsCapability.methods.deselectRetrainFrame.output)
+            .mutation(async ({ input, ctx }) => {
+            const { nodeId, ...methodInput } = input;
+            const p = resolveProvider('pipeline-analytics', nodeId, () => getProvider(ctx), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.deselectRetrainFrame(methodInput);
+        }),
+        getRetrainFrameImage: trpc_middleware_js_1.adminProcedure
+            .input(types_81.pipelineAnalyticsCapability.methods.getRetrainFrameImage.input.loose())
+            .output(types_81.pipelineAnalyticsCapability.methods.getRetrainFrameImage.output)
+            .query(async ({ input, ctx }) => {
+            const { nodeId, ...methodInput } = input;
+            const p = resolveProvider('pipeline-analytics', nodeId, () => getProvider(ctx), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.getRetrainFrameImage(methodInput);
+        }),
+        proposeRetrainAnnotations: trpc_middleware_js_1.adminProcedure
+            .input(types_81.pipelineAnalyticsCapability.methods.proposeRetrainAnnotations.input.loose())
+            .output(types_81.pipelineAnalyticsCapability.methods.proposeRetrainAnnotations.output)
+            .mutation(async ({ input, ctx }) => {
+            const { nodeId, ...methodInput } = input;
+            const p = resolveProvider('pipeline-analytics', nodeId, () => getProvider(ctx), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.proposeRetrainAnnotations(methodInput);
+        }),
+        listRetrainAnnotations: trpc_middleware_js_1.adminProcedure
+            .input(types_81.pipelineAnalyticsCapability.methods.listRetrainAnnotations.input.loose())
+            .output(types_81.pipelineAnalyticsCapability.methods.listRetrainAnnotations.output)
+            .query(async ({ input, ctx }) => {
+            const { nodeId, ...methodInput } = input;
+            const p = resolveProvider('pipeline-analytics', nodeId, () => getProvider(ctx), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.listRetrainAnnotations(methodInput);
+        }),
+        saveRetrainAnnotations: trpc_middleware_js_1.adminProcedure
+            .input(types_81.pipelineAnalyticsCapability.methods.saveRetrainAnnotations.input.loose())
+            .output(types_81.pipelineAnalyticsCapability.methods.saveRetrainAnnotations.output)
+            .mutation(async ({ input, ctx }) => {
+            const { nodeId, ...methodInput } = input;
+            const p = resolveProvider('pipeline-analytics', nodeId, () => getProvider(ctx), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.saveRetrainAnnotations(methodInput);
+        }),
+        completeRetrainTrack: trpc_middleware_js_1.adminProcedure
+            .input(types_81.pipelineAnalyticsCapability.methods.completeRetrainTrack.input.loose())
+            .output(types_81.pipelineAnalyticsCapability.methods.completeRetrainTrack.output)
+            .mutation(async ({ input, ctx }) => {
+            const { nodeId, ...methodInput } = input;
+            const p = resolveProvider('pipeline-analytics', nodeId, () => getProvider(ctx), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.completeRetrainTrack(methodInput);
+        }),
+        restageRetrainTrack: trpc_middleware_js_1.adminProcedure
+            .input(types_81.pipelineAnalyticsCapability.methods.restageRetrainTrack.input.loose())
+            .output(types_81.pipelineAnalyticsCapability.methods.restageRetrainTrack.output)
+            .mutation(async ({ input, ctx }) => {
+            const { nodeId, ...methodInput } = input;
+            const p = resolveProvider('pipeline-analytics', nodeId, () => getProvider(ctx), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.restageRetrainTrack(methodInput);
+        }),
+        getRetrainExportUrl: trpc_middleware_js_1.adminProcedure
+            .input(types_81.pipelineAnalyticsCapability.methods.getRetrainExportUrl.input.loose())
+            .output(types_81.pipelineAnalyticsCapability.methods.getRetrainExportUrl.output)
+            .query(async ({ input, ctx }) => {
+            const { nodeId, ...methodInput } = input;
+            const p = resolveProvider('pipeline-analytics', nodeId, () => getProvider(ctx), createRemoteProxy);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+            return p.getRetrainExportUrl(methodInput);
+        }),
         getEventMedia: trpc_middleware_js_1.protectedProcedure
             .input(types_81.pipelineAnalyticsCapability.methods.getEventMedia.input.loose())
             .output(types_81.pipelineAnalyticsCapability.methods.getEventMedia.output)

package/dist/main.js

@@ -42,6 +42,7 @@ const ws_1 = require("@trpc/server/adapters/ws");
 const static_1 = __importDefault(require("@fastify/static"));
 const compress_1 = __importDefault(require("@fastify/compress"));
 const cookie_1 = __importDefault(require("@fastify/cookie"));
+const sse_no_compression_js_1 = require("./api/sse-no-compression.js");
 const ws_2 = require("ws");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -223,7 +224,16 @@ async function bootstrap() {
     // replaces — so the telemetry reaches a running hub the same day it is
     // written. See packages/system/src/kernel/heap-watch.ts for why it exists
     // (four silent OOMs in ~15h, one nine seconds after a viewer connected).
-    (0, system_2.startHeapWatch)();
+    //
+    // The reclaimer is what turns the heartbeat from a report into a fix. hub-main's
+    // RSS is a HIGH-WATER MARK — measured over 1019 samples and seven boots, it never
+    // once fell below the running maximum of heapTotal+external — because V8 keeps the
+    // 256KB pages it committed at a sawtooth peak, and an ordinary major GC does not
+    // return them. `createV8Reclaimer()` returns undefined if V8 declines, and the
+    // heartbeat then behaves exactly as it did before.
+    const heapReclaimer = (0, system_2.createV8Reclaimer)();
+    const heapReclaim = heapReclaimer === undefined ? undefined : { reclaim: heapReclaimer };
+    (0, system_2.startHeapWatch)('hub-main', undefined, undefined, heapReclaim);
     // Clean up orphaned processes from previous crashes before starting
     cleanupOrphanProcesses();
     // SPA fallback — set later when admin UI is resolved, used by addon route catch-all
@@ -252,6 +262,13 @@ async function bootstrap() {
     // Registered before @fastify/static so the compress plugin wraps the
     // static send path — hashed admin-ui chunks go from ~2MB to ~600KB on
     // the wire. threshold:1024 skips compression for tiny payloads.
+    //
+    // SSE opt-out FIRST: without it a gzipped low-rate event stream starves
+    // silently in the compressor buffer — see `api/sse-no-compression.ts` for
+    // the mechanism and the live measurement.
+    fastify.addHook('onRequest', async (request) => {
+        (0, sse_no_compression_js_1.markSseRequestNoCompression)(request);
+    });
     await fastify.register(compress_1.default, { global: true, threshold: 1024 });
     // Data-plane POST bodies: the addon reverse-proxy (`proxyToUpstream`) pipes
     // `request.raw` upstream, but Fastify's default application/json parser would

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/server",
-  "version": "1.2.73",
+  "version": "1.2.75",
   "private": false,
   "files": [
     "dist",
@@ -33,19 +33,19 @@
     ]
   },
   "dependencies": {
-    "@camstack/addon-admin-ui": "1.2.34",
+    "@camstack/addon-admin-ui": "1.2.35",
     "@camstack/addon-agent-ui": "1.2.10",
     "@camstack/addon-auth": "1.2.11",
     "@camstack/addon-decoder-nodeav": "1.2.9",
     "@camstack/addon-notifiers": "1.2.13",
-    "@camstack/addon-pipeline": "1.2.45",
-    "@camstack/addon-pipeline-orchestrator": "1.2.28",
-    "@camstack/addon-post-analysis": "1.2.50",
+    "@camstack/addon-pipeline": "1.2.46",
+    "@camstack/addon-pipeline-orchestrator": "1.2.29",
+    "@camstack/addon-post-analysis": "1.2.51",
     "@camstack/sdk": "1.2.10",
     "@camstack/shm-ring": "1.1.9",
-    "@camstack/system": "1.2.60",
-    "@camstack/types": "1.2.44",
-    "@camstack/ui-library": "1.2.32",
+    "@camstack/system": "1.2.61",
+    "@camstack/types": "1.2.45",
+    "@camstack/ui-library": "1.2.33",
     "@fastify/compress": "^9.0.0",
     "@fastify/cookie": "^11.0.2",
     "@fastify/cors": "^11.2.0",